Auto-format (#718)

Author: the-david-oy

model_analyzer/plots/simple_plot.py

@@ -143,9 +143,8 @@ def plot_data_and_constraints(self, constraints):
 
         for model_config_name, data in self._data.items():
             # Sort the data by x-axis
-            x_data, y_data = (
-                list(t)
-                for t in zip(*sorted(zip(data['x_data'], data['y_data']))))
+            x_data, y_data = (list(t) for t in zip(
+                *sorted(zip(data['x_data'], data['y_data']))))
 
             if self._monotonic:
                 filtered_x, filtered_y = [x_data[0]], [y_data[0]]

model_analyzer/result/constraint_manager.py

@@ -24,6 +24,7 @@
 from model_analyzer.config.input.config_command_profile import ConfigCommandProfile
 from model_analyzer.config.input.config_command_report import ConfigCommandReport
 
+
 class ConstraintManager:
     """
     Handles processing and applying
@@ -34,20 +35,21 @@ class ConstraintManager:
     config: ConfigCommandProfile or ConfigCommandReport
     """
 
-    def __init__(self, config: Union[ConfigCommandProfile, ConfigCommandReport]) -> None:
+    def __init__(
+            self, config: Union[ConfigCommandProfile,
+                                ConfigCommandReport]) -> None:
         self._constraints = {}
 
         if config:
             # Model constraints
             if "profile_models" in config.get_config():
                 for model in config.profile_models:
-                    self._constraints[model.model_name()
-                                            ] = model.constraints()
+                    self._constraints[model.model_name()] = model.constraints()
 
             # Global constraints
             if "constraints" in config.get_all_config():
-                self._constraints[GLOBAL_CONSTRAINTS_KEY] = ModelConstraints(config.get_all_config()[
-                    "constraints"])
+                self._constraints[GLOBAL_CONSTRAINTS_KEY] = ModelConstraints(
+                    config.get_all_config()["constraints"])
 
     def get_constraints_for_all_models(self):
         """
@@ -59,8 +61,8 @@ def get_constraints_for_all_models(self):
 
         return self._constraints
 
-    def satisfies_constraints(self,
-            run_config_measurement: 'RunConfigMeasurement') -> bool:
+    def satisfies_constraints(
+            self, run_config_measurement: 'RunConfigMeasurement') -> bool:
         """
         Checks that the measurements, for every model, satisfy 
         the provided list of constraints
@@ -77,18 +79,20 @@ def satisfies_constraints(self,
         """
 
         if self._constraints:
-            for (model_name, model_metrics) in run_config_measurement.data().items():
+            for (model_name,
+                 model_metrics) in run_config_measurement.data().items():
                 for metric in model_metrics:
                     if self._metric_matches_constraint(
                             metric, self._constraints[model_name]):
                         if self._get_failure_percentage(
-                                metric, self._constraints[model_name][metric.tag]) > 0:
+                                metric,
+                                self._constraints[model_name][metric.tag]) > 0:
                             return False
 
         return True
 
-    def constraint_failure_percentage(self,
-            run_config_measurement: 'RunConfigMeasurement') -> float:
+    def constraint_failure_percentage(
+            self, run_config_measurement: 'RunConfigMeasurement') -> float:
         """
         Additive percentage, for every measurement, in every model, of how much 
         the RCM is failing the constraints by
@@ -100,7 +104,8 @@ def constraint_failure_percentage(self,
         failure_percentage: float = 0
 
         if self._constraints:
-            for (model_name, model_metrics) in run_config_measurement.data().items():
+            for (model_name,
+                 model_metrics) in run_config_measurement.data().items():
                 for metric in model_metrics:
                     if self._metric_matches_constraint(
                             metric, self._constraints[model_name]):
@@ -109,15 +114,15 @@ def constraint_failure_percentage(self,
 
         return failure_percentage * 100
 
-    def _metric_matches_constraint(self,
-            metric: Record, constraint: ModelConstraints) -> bool:
+    def _metric_matches_constraint(self, metric: Record,
+                                   constraint: ModelConstraints) -> bool:
         if constraint.has_metric(metric.tag):
             return True
         else:
             return False
 
-    def _get_failure_percentage(self, metric: Record, constraint: Dict[str,
-                                                                 int]) -> float:
+    def _get_failure_percentage(self, metric: Record,
+                                constraint: Dict[str, int]) -> float:
 
         failure_percentage = 0
 

model_analyzer/result/model_constraints.py

@@ -30,7 +30,7 @@ def __init__(self, constraints):
         self._constraints = {}
         if constraints:
             self._constraints = constraints
-        
+
     def to_dict(self):
         """
         Returns constraints dictionary
@@ -54,7 +54,7 @@ def has_metric(self, name):
             return True
         else:
             return False
-    
+
     def __getitem__(self, name):
         """
         To subscript constraints using metric name
@@ -70,8 +70,7 @@ def __getitem__(self, name):
         else:
             msg = f"'{name}' key not found in constraints"
             raise KeyError(msg)
-    
-            
+
     def __bool__(self):
         """
         To check if constraints are empty
@@ -80,7 +79,7 @@ def __bool__(self):
             return True
         else:
             return False
-    
+
     def __eq__(self, other):
         """
         To compare two ModelConstraints objects

model_analyzer/result/result_manager.py

@@ -62,7 +62,8 @@ def __init__(self, config: Union[ConfigCommandProfile, ConfigCommandReport],
         self._constraint_manager = constraint_manager
 
         # Data structures for sorting results
-        self._per_model_sorted_results: DefaultDict[str, SortedResults] = defaultdict(SortedResults)
+        self._per_model_sorted_results: DefaultDict[
+            str, SortedResults] = defaultdict(SortedResults)
         self._across_model_sorted_results: SortedResults = SortedResults()
 
         if state_manager.starting_fresh_run():

model_analyzer/result/run_config_result.py

@@ -110,7 +110,7 @@ def add_run_config_measurement(self, run_config_measurement):
         insort(self._measurements, run_config_measurement)
 
         if self._constraint_manager.satisfies_constraints(
-                                                   run_config_measurement):
+                run_config_measurement):
             insort(self._passing_measurements, run_config_measurement)
         else:
             insort(self._failing_measurements, run_config_measurement)