Refactor code formatting and improve readability across multiple operators

- Consolidated and simplified code formatting in various operator files, including ImageOverlayWriter, JSONResultsWriter, and Llama3VILAInferenceOperator.
- Removed unnecessary line breaks and improved the consistency of function definitions and logging statements.
- Enhanced overall code clarity by ensuring uniform indentation and spacing.

Signed-off-by: Victor Chang <[email protected]>

Author: mocsharp

monai/deploy/operators/image_overlay_writer_operator.py

@@ -78,9 +78,7 @@ def _to_hwc_uint8(self, image) -> np.ndarray:
         else:
             arr = np.asarray(image)
         if arr.ndim != 3 or arr.shape[2] not in (3, 4):
-            raise ValueError(
-                f"Expected HWC image with 3 or 4 channels, got shape {arr.shape}"
-            )
+            raise ValueError(f"Expected HWC image with 3 or 4 channels, got shape {arr.shape}")
         # Drop alpha if present
         if arr.shape[2] == 4:
             arr = arr[..., :3]
@@ -105,17 +103,14 @@ def _to_mask_uint8(self, pred) -> np.ndarray:
         return arr
 
     @staticmethod
-    def _blend_overlay(
-        img: np.ndarray, mask_u8: np.ndarray, alpha: float, color: Tuple[int, int, int]
-    ) -> np.ndarray:
+    def _blend_overlay(img: np.ndarray, mask_u8: np.ndarray, alpha: float, color: Tuple[int, int, int]) -> np.ndarray:
         # img: HWC uint8, mask_u8: HW uint8
         mask = (mask_u8 > 0).astype(np.float32)[..., None]
         color_img = np.zeros_like(img, dtype=np.uint8)
         color_img[..., 0] = color[0]
         color_img[..., 1] = color[1]
         color_img[..., 2] = color[2]
         blended = (
-            img.astype(np.float32) * (1.0 - alpha * mask)
-            + color_img.astype(np.float32) * (alpha * mask)
+            img.astype(np.float32) * (1.0 - alpha * mask) + color_img.astype(np.float32) * (alpha * mask)
         ).astype(np.uint8)
         return blended

monai/deploy/operators/json_results_writer_operator.py

@@ -128,15 +128,11 @@ def _process_prediction(self, pred: Any, filename: str) -> Dict[str, Any]:
                     }
                 else:
                     # Generic classification
-                    result["probabilities"] = {
-                        f"class_{i}": float(pred_data[i]) for i in range(len(pred_data))
-                    }
+                    result["probabilities"] = {f"class_{i}": float(pred_data[i]) for i in range(len(pred_data))}
 
                 # Add predicted class
                 max_idx = int(np.argmax(pred_data))
-                result["predicted_class"] = list(result["probabilities"].keys())[
-                    max_idx
-                ]
+                result["predicted_class"] = list(result["probabilities"].keys())[max_idx]
                 result["confidence"] = float(pred_data[max_idx])
 
             elif pred_data.ndim == 2:  # 2D array (batch of predictions)
@@ -172,9 +168,7 @@ def _print_classification_summary(self, result: Dict[str, Any]):
         for class_name, prob in probs.items():
             print(f"  {class_name}: {prob:.4f}")
         if "predicted_class" in result:
-            print(
-                f"  Predicted: {result['predicted_class']} (confidence: {result['confidence']:.4f})"
-            )
+            print(f"  Predicted: {result['predicted_class']} (confidence: {result['confidence']:.4f})")
 
 
 def test():

monai/deploy/operators/llama3_vila_inference_operator.py

@@ -116,9 +116,7 @@ def _load_model(self):
             config = AutoConfig.from_pretrained(self.model_path)
 
             # Load tokenizer
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.model_path / "llm", use_fast=False
-            )
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_path / "llm", use_fast=False)
 
             # For LLaVA-style models, we typically need to handle image processing
             # and model loading in a specific way. For now, we'll create a simplified
@@ -156,9 +154,7 @@ def _preprocess_image(self, image: Image) -> torch.Tensor:
         # For now, we'll just convert to tensor
         return torch.from_numpy(image_array).float()
 
-    def _generate_response(
-        self, image_tensor: torch.Tensor, prompt: str, generation_params: Dict[str, Any]
-    ) -> str:
+    def _generate_response(self, image_tensor: torch.Tensor, prompt: str, generation_params: Dict[str, Any]) -> str:
         """Generate text response from the model."""
         if self._mock_mode:
             # Mock response based on common medical VQA patterns
@@ -276,44 +272,30 @@ def compute(self, op_input, op_output, context):
         request_id = op_input.receive("request_id")
         generation_params = op_input.receive("generation_params")
 
-        self._logger.info(
-            f"Processing request {request_id} with output type '{output_type}'"
-        )
+        self._logger.info(f"Processing request {request_id} with output type '{output_type}'")
 
         try:
             # Preprocess image
             image_tensor = self._preprocess_image(image)
 
             # Generate text response
-            text_response = self._generate_response(
-                image_tensor, prompt, generation_params
-            )
+            text_response = self._generate_response(image_tensor, prompt, generation_params)
 
             # Get image metadata if available
-            image_metadata = (
-                image.metadata()
-                if hasattr(image, "metadata") and callable(image.metadata)
-                else None
-            )
+            image_metadata = image.metadata() if hasattr(image, "metadata") and callable(image.metadata) else None
 
             # Create result based on output type
             if output_type == "json":
-                result = self._create_json_result(
-                    text_response, request_id, prompt, image_metadata
-                )
+                result = self._create_json_result(text_response, request_id, prompt, image_metadata)
             elif output_type == "image":
                 # For now, just return the original image
                 # In future, this could generate new images
                 result = image
             elif output_type == "image_overlay":
                 result = self._create_image_overlay(image, text_response)
             else:
-                self._logger.warning(
-                    f"Unknown output type: {output_type}, defaulting to json"
-                )
-                result = self._create_json_result(
-                    text_response, request_id, prompt, image_metadata
-                )
+                self._logger.warning(f"Unknown output type: {output_type}, defaulting to json")
+                result = self._create_json_result(text_response, request_id, prompt, image_metadata)
 
             # Emit outputs
             op_output.emit(result, "result")