Remove all backward compatibility code from codebase

Removes backward compatibility code and comments to maintain a clean, modern codebase:

**Config System (callbacks.py):**
- Remove old config style support for checkpoint callbacks
- Remove old config style support for early_stopping callbacks
- Keep only modern unified config style (cfg.monitor.*)

**Lightning Model (lit_model.py):**
- Remove legacy parameter conversion for decode_binary_contour_distance_watershed
- Remove legacy intensity_scale/output_scale fallbacks
- Keep only modern config names (intensity_scale, intensity_dtype)

**Transform Builders (build.py):**
- Remove backward compatibility comments
- Remove legacy image_transform.resize fallback
- Keep only modern data_transform.resize path

**Loss Functions (regularization.py):**
- Remove backward compatibility aliases (BinaryReg, FgDTConsistency, etc.)

**Utilities (visualizer.py):**
- Remove legacy create_visualizer() factory function

**Config (hydra_config.py, hydra_utils.py):**
- Remove deprecated config field comments
- Remove legacy path comments

**Impact:**
- 7 files modified
- 92 lines removed
- Clean, focused codebase without legacy support

Author: claude

connectomics/config/hydra_config.py

@@ -392,9 +392,7 @@ class DataConfig:
         default_factory=list
     )  # Axis permutation for training data (e.g., [2,1,0] for xyz->zyx)
     val_transpose: List[int] = field(default_factory=list)  # Axis permutation for validation data
-    test_transpose: List[int] = field(
-        default_factory=list
-    )  # Axis permutation for test data (deprecated, use inference.data.test_transpose)
+    test_transpose: List[int] = field(default_factory=list)  # Axis permutation for test data
 
     # Dataset statistics (for auto-planning)
     target_spacing: Optional[List[float]] = None  # Target voxel spacing [z, y, x] in mm
@@ -868,9 +866,7 @@ class TestTimeAugmentationConfig:
     flip_axes: Any = (
         None  # TTA flip strategy: "all" (8 flips), null (no aug), or list like [[0], [1], [2]]
     )
-    act: Optional[str] = (
-        None  # Single activation for all channels: 'softmax', 'sigmoid', 'tanh', None (deprecated, use channel_activations)
-    )
+    act: Optional[str] = None  # Single activation for all channels: 'softmax', 'sigmoid', 'tanh', None
     channel_activations: Optional[List[Any]] = (
         None  # Per-channel activations: [[start_ch, end_ch, 'activation'], ...] e.g., [[0, 2, 'softmax'], [2, 3, 'sigmoid'], [3, 4, 'tanh']]
     )

connectomics/config/hydra_utils.py

@@ -244,8 +244,8 @@ def resolve_data_paths(cfg: Config) -> Config:
     Supported paths:
     - Training: cfg.data.train_path + cfg.data.train_image/train_label/train_mask
     - Validation: cfg.data.val_path + cfg.data.val_image/val_label/val_mask
-    - Testing (legacy): cfg.data.test_path + cfg.data.test_image/test_label/test_mask
-    - Inference (primary): cfg.inference.data.test_path + cfg.inference.data.test_image/test_label/test_mask
+    - Testing: cfg.data.test_path + cfg.data.test_image/test_label/test_mask
+    - Inference: cfg.inference.data.test_path + cfg.inference.data.test_image/test_label/test_mask
 
     Args:
         cfg: Config object to resolve paths for
@@ -316,7 +316,7 @@ def _combine_path(base_path: str, file_path: Optional[Union[str, List[str]]]) ->
         cfg.data.val_mask = _combine_path(cfg.data.val_path, cfg.data.val_mask)
         cfg.data.val_json = _combine_path(cfg.data.val_path, cfg.data.val_json)
 
-    # Resolve test paths (legacy support for cfg.data.test_path)
+    # Resolve test paths
     if cfg.data.test_path:
         cfg.data.test_image = _combine_path(cfg.data.test_path, cfg.data.test_image)
         cfg.data.test_label = _combine_path(cfg.data.test_path, cfg.data.test_label)

connectomics/data/augment/build.py

@@ -73,7 +73,7 @@ def build_train_transforms(
     # Load images first (unless using pre-cached dataset)
     if not skip_loading:
         # Use appropriate loader based on dataset type
-        dataset_type = getattr(cfg.data, "dataset_type", "volume")  # Default to volume for backward compatibility
+        dataset_type = getattr(cfg.data, "dataset_type", "volume")
 
         if dataset_type == "filename":
             # For filename-based datasets (PNG, JPG, etc.), use MONAI's LoadImaged
@@ -94,12 +94,9 @@ def build_train_transforms(
         transforms.append(ApplyVolumetricSplitd(keys=keys))
 
     # Apply resize if configured (before cropping)
-    # Check data_transform first (new), then fall back to image_transform.resize (legacy)
     resize_size = None
     if hasattr(cfg.data, "data_transform") and hasattr(cfg.data.data_transform, "resize") and cfg.data.data_transform.resize is not None:
         resize_size = cfg.data.data_transform.resize
-    elif hasattr(cfg.data.image_transform, "resize") and cfg.data.image_transform.resize is not None:
-        resize_size = cfg.data.image_transform.resize
 
     if resize_size:
         # Use bilinear for images, nearest for labels/masks
@@ -247,7 +244,7 @@ def _build_eval_transforms_impl(
     transforms = []
 
     # Load images first - use appropriate loader based on dataset type
-    dataset_type = getattr(cfg.data, "dataset_type", "volume")  # Default to volume for backward compatibility
+    dataset_type = getattr(cfg.data, "dataset_type", "volume")
 
     if dataset_type == "filename":
         # For filename-based datasets (PNG, JPG, etc.), use MONAI's LoadImaged
@@ -455,8 +452,8 @@ def _build_augmentations(aug_cfg: AugmentationConfig, keys: list[str], do_2d: bo
         List of MONAI transforms
     """
     transforms = []
-    
-    # Get preset mode (default to "some" for backward compatibility)
+
+    # Get preset mode
     preset = getattr(aug_cfg, "preset", "some")
 
     # Helper function to check if augmentation should be applied

connectomics/lightning/callbacks.py

@@ -428,25 +428,7 @@ def create_callbacks(cfg) -> list:
         callbacks.append(vis_callback)
 
     # Model checkpoint callback
-    # Support both new unified config (training.checkpoint_*) and old separate config (checkpoint.*)
-    if hasattr(cfg, 'checkpoint') and cfg.checkpoint is not None:
-        # Old config style (backward compatibility)
-        monitor = getattr(cfg.checkpoint, 'monitor', 'val/loss')
-        default_filename = f'epoch={{epoch:03d}}-{monitor}={{{monitor}:.4f}}'
-        filename = getattr(cfg.checkpoint, 'filename', default_filename)
-
-        checkpoint_callback = ModelCheckpoint(
-            monitor=monitor,
-            mode=getattr(cfg.checkpoint, 'mode', 'min'),
-            save_top_k=getattr(cfg.checkpoint, 'save_top_k', 3),
-            save_last=getattr(cfg.checkpoint, 'save_last', True),
-            dirpath=getattr(cfg.checkpoint, 'dirpath', 'checkpoints'),
-            filename=filename,
-            verbose=True
-        )
-        callbacks.append(checkpoint_callback)
-    elif hasattr(cfg, 'monitor') and hasattr(cfg.monitor, 'checkpoint'):
-        # New unified config style (monitor.checkpoint.*)
+    if hasattr(cfg, 'monitor') and hasattr(cfg.monitor, 'checkpoint'):
         monitor = getattr(cfg.monitor.checkpoint, 'monitor', 'val/loss')
         filename = getattr(cfg.monitor.checkpoint, 'filename', None)
         if filename is None:
@@ -465,19 +447,7 @@ def create_callbacks(cfg) -> list:
         callbacks.append(checkpoint_callback)
 
     # Early stopping callback
-    # Support both new unified config (training.early_stopping_*) and old separate config (early_stopping.*)
-    if hasattr(cfg, 'early_stopping') and cfg.early_stopping is not None and cfg.early_stopping.enabled:
-        # Old config style (backward compatibility)
-        early_stop_callback = EarlyStopping(
-            monitor=getattr(cfg.early_stopping, 'monitor', 'val/loss'),
-            patience=getattr(cfg.early_stopping, 'patience', 10),
-            mode=getattr(cfg.early_stopping, 'mode', 'min'),
-            min_delta=getattr(cfg.early_stopping, 'min_delta', 0.0),
-            verbose=True
-        )
-        callbacks.append(early_stop_callback)
-    elif hasattr(cfg, 'monitor') and hasattr(cfg.monitor, 'early_stopping') and getattr(cfg.monitor.early_stopping, 'enabled', False):
-        # New unified config style (monitor.early_stopping.*)
+    if hasattr(cfg, 'monitor') and hasattr(cfg.monitor, 'early_stopping') and getattr(cfg.monitor.early_stopping, 'enabled', False):
         early_stop_callback = EarlyStopping(
             monitor=getattr(cfg.monitor.early_stopping, 'monitor', 'val/loss'),
             patience=getattr(cfg.monitor.early_stopping, 'patience', 10),

connectomics/lightning/lit_model.py

@@ -597,17 +597,13 @@ def _apply_postprocessing(self, data: np.ndarray) -> np.ndarray:
             data = np.stack(results, axis=0)
             print(f"  DEBUG: _apply_postprocessing - after stacking, data shape: {data.shape}")
 
-        # Step 2: Apply scaling if configured (support both new and legacy names)
+        # Step 2: Apply scaling if configured
         intensity_scale = getattr(postprocessing, 'intensity_scale', None)
-        output_scale = getattr(postprocessing, 'output_scale', None)
-        scale = intensity_scale if intensity_scale is not None else output_scale
-        if scale is not None:
-            data = data * scale
+        if intensity_scale is not None:
+            data = data * intensity_scale
 
-        # Step 3: Apply dtype conversion if configured (support both new and legacy names)
-        intensity_dtype = getattr(postprocessing, 'intensity_dtype', None)
-        output_dtype = getattr(postprocessing, 'output_dtype', None)
-        target_dtype_str = intensity_dtype if intensity_dtype is not None else output_dtype
+        # Step 3: Apply dtype conversion if configured
+        target_dtype_str = getattr(postprocessing, 'intensity_dtype', None)
 
         if target_dtype_str is not None and target_dtype_str != 'float32':
             # Map string dtype to numpy dtype
@@ -739,27 +735,6 @@ def _apply_decode_mode(self, data: np.ndarray) -> np.ndarray:
 
                 decode_fn = decode_fn_map[fn_name]
 
-                # Backward compatibility: convert old parameter format to new tuple format
-                # for decode_binary_contour_distance_watershed
-                if fn_name == 'decode_binary_contour_distance_watershed':
-                    if 'seed_threshold' in kwargs or 'foreground_threshold' in kwargs:
-                        warnings.warn(
-                            "Detected legacy parameters (seed_threshold, contour_threshold, foreground_threshold) "
-                            "for decode_binary_contour_distance_watershed. Converting to new tuple format "
-                            "(binary_threshold, contour_threshold, distance_threshold). "
-                            "Please update your config files to use the new format.",
-                            DeprecationWarning,
-                        )
-                        # Convert old parameters to new tuple format
-                        seed_thresh = kwargs.pop('seed_threshold', 0.9)
-                        contour_thresh = kwargs.pop('contour_threshold', 0.8)
-                        foreground_thresh = kwargs.pop('foreground_threshold', 0.85)
-                        
-                        # Map old parameters to new tuple format
-                        kwargs['binary_threshold'] = (seed_thresh, foreground_thresh)
-                        kwargs['contour_threshold'] = (contour_thresh, 1.1)
-                        kwargs['distance_threshold'] = (0.5, -0.5)
-
                 try:
                     # Apply decoding function
                     sample = decode_fn(sample, **kwargs)

connectomics/models/loss/regularization.py

@@ -294,14 +294,6 @@ def forward(self, pred: torch.Tensor) -> torch.Tensor:
         return loss.mean()
 
 
-# Aliases for backward compatibility (if needed in configs)
-BinaryReg = BinaryRegularization
-FgDTConsistency = ForegroundDistanceConsistency
-ContourDTConsistency = ContourDistanceConsistency
-FgContourConsistency = ForegroundContourConsistency
-NonoverlapReg = NonOverlapRegularization
-
-
 __all__ = [
     'BinaryRegularization',
     'ForegroundDistanceConsistency',

connectomics/utils/visualizer.py

@@ -590,9 +590,3 @@ def _should_visualize(self, trainer, batch_idx: int) -> bool:
         log_every_n_steps = getattr(self.cfg.optimization, "vis_every_n_steps", 100)
 
         return trainer.global_step % log_every_n_steps == 0 and batch_idx == 0
-
-
-# Legacy compatibility
-def create_visualizer(cfg, **kwargs):
-    """Factory function for creating visualizer (backward compatible)."""
-    return Visualizer(cfg, **kwargs)