Refactor whitespace and improve code clarity in pipeline generator

- Removed unnecessary whitespace in the app_generator and bundle_downloader files to enhance readability.
- Streamlined import statements in test files for better organization.
- Ensured consistent formatting across various sections of the codebase.

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

Author: mocsharp

tools/pipeline-generator/pipeline_generator/generator/app_generator.py

@@ -112,7 +112,7 @@ def generate_app(
         # Download the bundle
         logger.info(f"Downloading bundle: {model_id}")
         bundle_path = self.downloader.download_bundle(model_id, output_dir)
-        
+
         # Organize bundle into proper structure if needed
         self.downloader.organize_bundle_structure(bundle_path)
 
@@ -278,19 +278,19 @@ def _prepare_context(
         # Collect dependency hints from metadata.json
         required_packages_version = metadata.get("required_packages_version", {}) if metadata else {}
         extra_dependencies = getattr(model_config, "dependencies", []) if model_config else []
-        
+
         # Handle dependency conflicts between config and metadata
         config_deps = []
         if extra_dependencies:
             # Extract dependency names from config overrides
             config_deps = [dep.split(">=")[0].split("==")[0].split("<")[0] for dep in extra_dependencies]
-            
+
         # Add metadata dependencies only if not overridden by config
         if metadata and "numpy_version" in metadata and "numpy" not in config_deps:
             extra_dependencies.append(f"numpy=={metadata['numpy_version']}")
         if metadata and "pytorch_version" in metadata and "torch" not in config_deps:
             extra_dependencies.append(f"torch=={metadata['pytorch_version']}")
-            
+
         # Handle MONAI version - move logic from template to Python for better maintainability
         has_monai_config = any(dep.startswith("monai") for dep in extra_dependencies)
         if has_monai_config and metadata:

tools/pipeline-generator/pipeline_generator/generator/bundle_downloader.py

@@ -147,7 +147,7 @@ def detect_model_file(self, bundle_path: Path) -> Optional[Path]:
 
     def organize_bundle_structure(self, bundle_path: Path) -> None:
         """Organize bundle files into the expected MONAI Bundle structure.
-        
+
         Creates the standard structure if files are in the root directory:
         bundle_root/
           configs/
@@ -156,60 +156,54 @@ def organize_bundle_structure(self, bundle_path: Path) -> None:
           models/
             model.pt
             model.ts
-            
+
         Args:
             bundle_path: Path to the downloaded bundle
         """
         configs_dir = bundle_path / "configs"
         models_dir = bundle_path / "models"
-        
+
         # Check if structure already exists
-        has_configs_structure = (
-            configs_dir.exists() and 
-            (configs_dir / "metadata.json").exists()
-        )
-        has_models_structure = (
-            models_dir.exists() and 
-            any(models_dir.glob("model.*"))
-        )
-        
+        has_configs_structure = configs_dir.exists() and (configs_dir / "metadata.json").exists()
+        has_models_structure = models_dir.exists() and any(models_dir.glob("model.*"))
+
         if has_configs_structure and has_models_structure:
             logger.debug("Bundle already has proper structure")
             return
-            
+
         logger.info("Organizing bundle into standard structure")
-        
+
         # Create directories
         configs_dir.mkdir(exist_ok=True)
         models_dir.mkdir(exist_ok=True)
-        
+
         # Move config files to configs/
         config_files = ["metadata.json", "inference.json"]
         for config_file in config_files:
             src_path = bundle_path / config_file
             if src_path.exists() and not (configs_dir / config_file).exists():
                 src_path.rename(configs_dir / config_file)
                 logger.debug(f"Moved {config_file} to configs/")
-        
+
         # Move model files to models/
         # Prefer PyTorch (.pt) > ONNX (.onnx) > TorchScript (.ts) for better compatibility
         model_extensions = [".pt", ".onnx", ".ts"]
-        
+
         # First move model files from root directory
         for ext in model_extensions:
             for model_file in bundle_path.glob(f"*{ext}"):
                 if model_file.is_file() and not (models_dir / model_file.name).exists():
                     model_file.rename(models_dir / model_file.name)
                     logger.debug(f"Moved {model_file.name} to models/")
-        
+
         # Check if we already have a suitable model in the main directory
         # Prefer .pt files, then .onnx, then .ts
         has_suitable_model = False
         for ext in model_extensions:
             if any(models_dir.glob(f"*{ext}")):
                 has_suitable_model = True
                 break
-        
+
         # If no suitable model in main directory, move from subdirectories
         if not has_suitable_model:
             # Also move model files from subdirectories to the main models/ directory
@@ -219,33 +213,33 @@ def organize_bundle_structure(self, bundle_path: Path) -> None:
                 model_files = list(models_dir.glob(f"**/*{ext}"))
                 if not model_files:
                     continue
-                    
+
                 # Filter files that are not in the main models directory
                 subdirectory_files = [f for f in model_files if f.parent != models_dir]
                 if not subdirectory_files:
                     continue
-                    
+
                 target_name = f"model{ext}"
                 target_path = models_dir / target_name
                 if target_path.exists():
                     continue  # Target already exists
-                
+
                 # Prefer non-TensorRT models for better compatibility
                 # TensorRT models often have "_trt" in their name
                 preferred_file = None
                 for model_file in subdirectory_files:
                     if "_trt" not in model_file.name.lower():
                         preferred_file = model_file
                         break
-                
+
                 # If no non-TensorRT model found, use the first available
                 if preferred_file is None:
                     preferred_file = subdirectory_files[0]
-                
+
                 # Move the preferred model file
                 preferred_file.rename(target_path)
                 logger.debug(f"Moved {preferred_file.name} from {preferred_file.parent.name}/ to models/{target_name}")
-                
+
                 # Clean up empty subdirectory if it exists
                 try:
                     if preferred_file.parent.exists() and not any(preferred_file.parent.iterdir()):
@@ -254,7 +248,7 @@ def organize_bundle_structure(self, bundle_path: Path) -> None:
                 except OSError:
                     pass  # Directory not empty or other issue
                 break  # Only move one model file total
-        
+
         # Ensure we have model.pt or model.ts in the main directory for MONAI Deploy
         # Create symlinks with standard names if needed
         standard_model_path = models_dir / "model.pt"

tools/pipeline-generator/tests/test_bundle_downloader.py

@@ -230,7 +230,7 @@ def test_organize_bundle_structure_flat_to_structured(self, tmp_path):
         inference_file = bundle_path / "inference.json"
         model_pt_file = bundle_path / "model.pt"
         model_ts_file = bundle_path / "model.ts"
-        
+
         metadata_file.write_text('{"name": "Test"}')
         inference_file.write_text('{"config": "test"}')
         model_pt_file.touch()
@@ -244,7 +244,7 @@ def test_organize_bundle_structure_flat_to_structured(self, tmp_path):
         assert (bundle_path / "configs" / "inference.json").exists()
         assert (bundle_path / "models" / "model.pt").exists()
         assert (bundle_path / "models" / "model.ts").exists()
-        
+
         # Check that original files were moved (not copied)
         assert not metadata_file.exists()
         assert not inference_file.exists()
@@ -437,7 +437,7 @@ def test_organize_bundle_structure_skips_when_suitable_model_exists(self, tmp_pa
         # Main model should be renamed to standard name
         assert (models_dir / "model.pt").exists()
         assert not main_model.exists()
-        
+
         # Subdirectory model should remain untouched
         assert subdir_model.exists()
         assert subdir.exists()
@@ -453,9 +453,9 @@ def test_organize_bundle_structure_multiple_extensions_preference(self, tmp_path
         pt_model = subdir / "model.pt"
         onnx_model = subdir / "model.onnx"
         ts_model = subdir / "model.ts"
-        
+
         pt_model.write_bytes(b"pytorch model")
-        onnx_model.write_bytes(b"onnx model") 
+        onnx_model.write_bytes(b"onnx model")
         ts_model.write_text("torchscript model")
 
         # Organize structure
@@ -466,7 +466,7 @@ def test_organize_bundle_structure_multiple_extensions_preference(self, tmp_path
         assert not (models_dir / "model.onnx").exists()
         assert not (models_dir / "model.ts").exists()
         assert not pt_model.exists()
-        
+
         # Other models should remain in subdirectory
         assert onnx_model.exists()
         assert ts_model.exists()