ruff format

Author: mgumowsk

src/model_api/models/anomaly.py

@@ -75,26 +75,26 @@ def __init__(
 
     def preprocess(self, inputs: np.ndarray) -> list[dict]:
         """Data preprocess method for Anomalib models.
-        
+
         Anomalib models typically expect inputs in [0,1] range as float32.
         """
         original_shape = inputs.shape
-        
+
         if self._is_dynamic:
             h, w, c = inputs.shape
             resized_shape = (w, h, c)
-            
+
             # For anomalib models, convert to float32 and normalize to [0,1] if needed
             if inputs.dtype == np.uint8:
                 processed_image = inputs.astype(np.float32) / 255.0
             else:
                 processed_image = inputs.astype(np.float32)
-                
+
             # Apply layout change but skip InputTransform (which might apply wrong normalization)
             processed_image = self._change_layout(processed_image)
         else:
             resized_shape = (self.w, self.h, self.c)
-            # For fixed models, use standard preprocessing 
+            # For fixed models, use standard preprocessing
             if self.embedded_processing:
                 processed_image = inputs[None]
             else:
@@ -104,15 +104,15 @@ def preprocess(self, inputs: np.ndarray) -> list[dict]:
                 else:
                     processed_image = inputs.astype(np.float32)
                 processed_image = self._change_layout(processed_image)
-            
+
         return [
             {self.image_blob_name: processed_image},
             {
                 "original_shape": original_shape,
                 "resized_shape": resized_shape,
             },
         ]
-    
+
     def postprocess(self, outputs: dict[str, np.ndarray], meta: dict[str, Any]) -> AnomalyResult:
         """Post-processes the outputs and returns the results.
 
@@ -128,7 +128,7 @@ def postprocess(self, outputs: dict[str, np.ndarray], meta: dict[str, Any]) -> A
         pred_mask: np.ndarray | None = None
         pred_boxes: np.ndarray | None = None
 
-        anomalib_keys = ['pred_score', 'pred_label', 'pred_mask', 'anomaly_map']
+        anomalib_keys = ["pred_score", "pred_label", "pred_mask", "anomaly_map"]
         if not all(key in outputs for key in anomalib_keys):
             predictions = outputs[next(iter(self.outputs))]
 
@@ -149,12 +149,12 @@ def postprocess(self, outputs: dict[str, np.ndarray], meta: dict[str, Any]) -> A
 
             if pred_label == self.labels[0]:  # normal
                 npred_score = 1 - npred_score  # Score of normal is 1 - score of anomaly
-            pred_score=npred_score.item()
+            pred_score = npred_score.item()
         else:
-            pred_score = outputs['pred_score'].item()
-            pred_label = str(outputs['pred_label'].item())
-            anomaly_map = outputs['anomaly_map'].squeeze()
-            pred_mask =  outputs['pred_mask'].squeeze().astype(np.uint8)
+            pred_score = outputs["pred_score"].item()
+            pred_label = str(outputs["pred_label"].item())
+            anomaly_map = outputs["anomaly_map"].squeeze()
+            pred_mask = outputs["pred_mask"].squeeze().astype(np.uint8)
 
         anomaly_map *= 255
         anomaly_map = np.round(anomaly_map).astype(np.uint8)
@@ -173,7 +173,6 @@ def postprocess(self, outputs: dict[str, np.ndarray], meta: dict[str, Any]) -> A
         if self.task == "detection":
             pred_boxes = self._get_boxes(pred_mask)
 
-
         return AnomalyResult(
             anomaly_map=anomaly_map,
             pred_boxes=pred_boxes,

src/model_api/models/image_model.py

@@ -73,13 +73,13 @@ def __init__(self, inference_adapter: InferenceAdapter, configuration: dict = {}
             self.n, self.c, self.h, self.w = self.inputs[self.image_blob_name].shape
         else:
             self.n, self.h, self.w, self.c = self.inputs[self.image_blob_name].shape
-        
+
         self._is_dynamic = False
         if self.h == -1 or self.w == -1 or self.n == -1:
             self._is_dynamic = True
             if self.n == -1:
                 self.n = 1
-        
+
         self.resize = RESIZE_TYPES[self.resize_type]
         self.input_transform = InputTransform(
             self.reverse_input_channels,
@@ -232,7 +232,7 @@ def preprocess(self, inputs: np.ndarray) -> list[dict]:
             else:
                 processed_image = self.input_transform(inputs)
                 processed_image = self._change_layout(processed_image)
-            
+
         return [
             {self.image_blob_name: processed_image},
             {

src/model_api/models/model.py

@@ -125,8 +125,7 @@ def get_model_class(cls, name: str) -> Type:
             if name.lower() == subclass.__model__.lower():
                 return subclass
         return cls.raise_error(
-            f"There is no model with name {name} in list: "
-            f"{', '.join([subclass.__model__ for subclass in subclasses])}",
+            f"There is no model with name {name} in list: {', '.join([subclass.__model__ for subclass in subclasses])}",
         )
 
     @classmethod
@@ -209,16 +208,16 @@ def detect_model_type(cls, inference_adapter) -> str:
         """Detects model type on available information"""
         input_layers = inference_adapter.get_input_layers()
         output_layers = inference_adapter.get_output_layers()
-        
+
         # Check for Anomalib model pattern: 1 input and specific output layer names
         if len(input_layers) == 1 and len(output_layers) == 4:
-            expected_outputs = {'pred_score', 'pred_label', 'anomaly_map', 'pred_mask'}
+            expected_outputs = {"pred_score", "pred_label", "anomaly_map", "pred_mask"}
             actual_outputs = set(output_layers.keys())
             if expected_outputs == actual_outputs:
                 return "AnomalyDetection"
-                    
-        return 'uknown'
-    
+
+        return "uknown"
+
     @classmethod
     def get_subclasses(cls) -> list[Any]:
         """Retrieves all the subclasses of the model class given."""