dragon-ml-toolbox 19.14.0__py3-none-any.whl → 20.0.0__py3-none-any.whl

ml_tools/ML_callbacks/_scheduler.py

@@ -0,0 +1,197 @@
+import torch
+from typing import Literal
+
+from ..keys._keys import PyTorchLogKeys
+from .._core import get_logger
+
+from ._base import _Callback
+
+
+_LOGGER = get_logger("LR Scheduler")
+
+
+__all__ = [
+    "DragonScheduler",
+    "DragonPlateauScheduler"
+]
+
+
+class _DragonLRScheduler(_Callback):
+    """
+    Base class for Dragon LR Schedulers. 
+    Handles common logic like logging and attaching to the trainer.
+    """
+    def __init__(self):
+        super().__init__()
+        self.scheduler = None
+        self.previous_lr = None
+
+    def set_trainer(self, trainer):
+        """Associates the callback with the trainer."""
+        super().set_trainer(trainer)
+        # Note: Subclasses must ensure self.scheduler is set before or during this call
+        # if they want to register it immediately.
+        if self.scheduler:
+            self.trainer.scheduler = self.scheduler # type: ignore
+
+    def on_train_begin(self, logs=None):
+        """Store the initial learning rate."""
+        if not self.trainer.optimizer: # type: ignore
+            _LOGGER.warning("No optimizer found in trainer. LRScheduler cannot track learning rate.")
+            return
+        self.previous_lr = self.trainer.optimizer.param_groups[0]['lr'] # type: ignore
+
+    def _check_and_log_lr(self, epoch, logs, verbose: bool):
+        """Helper to log LR changes and update history."""
+        if not self.trainer.optimizer: # type: ignore
+            return
+
+        current_lr = self.trainer.optimizer.param_groups[0]['lr'] # type: ignore
+
+        # Log change
+        if self.previous_lr is not None and current_lr != self.previous_lr:
+            if verbose:
+                print(f"    > Epoch {epoch}: Learning rate changed to {current_lr:.6f}")
+            self.previous_lr = current_lr
+        
+        # Log to dictionary
+        logs[PyTorchLogKeys.LEARNING_RATE] = current_lr
+        
+        # Log to history
+        if hasattr(self.trainer, 'history'):
+            self.trainer.history.setdefault(PyTorchLogKeys.LEARNING_RATE, []).append(current_lr) # type: ignore
+
+
+class DragonScheduler(_DragonLRScheduler):
+    """
+    Callback for standard PyTorch Learning Rate Schedulers.
+    
+    Compatible with: StepLR, MultiStepLR, ExponentialLR, CosineAnnealingLR, etc.
+    
+    NOT Compatible with: ReduceLROnPlateau (Use `DragonReduceLROnPlateau` instead).
+    """
+    def __init__(self, scheduler, verbose: bool=True):
+        """
+        Args:
+            scheduler: An initialized PyTorch learning rate scheduler instance.
+            verbose (bool): If True, logs learning rate changes to console.
+        """
+        super().__init__()
+        if isinstance(scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):
+            raise ValueError(
+                "DragonLRScheduler does not support 'ReduceLROnPlateau'. "
+                "Please use the `DragonReduceLROnPlateau` callback instead."
+            )
+        self.scheduler = scheduler
+        self.verbose = verbose
+        
+    def set_trainer(self, trainer):
+        super().set_trainer(trainer)
+        # Explicitly register the scheduler again to be safe
+        self.trainer.scheduler = self.scheduler # type: ignore
+        if self.verbose:
+            _LOGGER.info(f"Registered LR Scheduler: {self.scheduler.__class__.__name__}")
+
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+        
+        # Standard step (no metrics needed)
+        self.scheduler.step()
+        
+        self._check_and_log_lr(epoch, logs, self.verbose)
+
+
+class DragonPlateauScheduler(_DragonLRScheduler):
+    """
+    Specific callback for `torch.optim.lr_scheduler.ReduceLROnPlateau`. Reduces learning rate when a monitored metric has stopped improving.
+    
+    This wrapper initializes the scheduler internally using the Trainer's optimizer, simplifying the setup process.
+    """
+    def __init__(self, 
+                 monitor: Literal["Training Loss", "Validation Loss"] = "Validation Loss",
+                 mode: Literal['min', 'max'] = 'min', 
+                 factor: float = 0.1, 
+                 patience: int = 5, 
+                 threshold: float = 1e-4, 
+                 threshold_mode: Literal['rel', 'abs'] = 'rel', 
+                 cooldown: int = 0, 
+                 min_lr: float = 0, 
+                 eps: float = 1e-8, 
+                 verbose: bool = True):
+        """
+        Args:
+            monitor ("Training Loss", "Validation Loss"): Metric to monitor.
+            mode ('min', 'max'): One of 'min', 'max'.
+            factor (float): Factor by which the learning rate will be reduced. new_lr = lr * factor.
+            patience (int): Number of epochs with no improvement after which learning rate will be reduced.
+            threshold (float): Threshold for measuring the new optimum.
+            threshold_mode ('rel', 'abs'): One of 'rel', 'abs'.
+            cooldown (int): Number of epochs to wait before resuming normal operation after lr has been reduced.
+            min_lr (float or list): A scalar or a list of scalars.
+            eps (float): Minimal decay applied to lr.
+            verbose (bool): If True, logs learning rate changes to console.
+        """
+        super().__init__()
+        
+        # Standardize monitor key
+        if monitor == "Training Loss":
+            std_monitor = PyTorchLogKeys.TRAIN_LOSS
+        elif monitor == "Validation Loss":
+            std_monitor = PyTorchLogKeys.VAL_LOSS
+        else:
+            _LOGGER.error(f"Unknown monitor key: {monitor}.")
+            raise ValueError()
+        
+        self.monitor = std_monitor
+        self.verbose = verbose
+        
+        # Config storage for delayed initialization
+        self.config = {
+            'mode': mode,
+            'factor': factor,
+            'patience': patience,
+            'threshold': threshold,
+            'threshold_mode': threshold_mode,
+            'cooldown': cooldown,
+            'min_lr': min_lr,
+            'eps': eps,
+        }
+
+    def set_trainer(self, trainer):
+        """
+        Initializes the ReduceLROnPlateau scheduler using the trainer's optimizer and registers it.
+        """
+        super().set_trainer(trainer)
+        
+        if not hasattr(self.trainer, 'optimizer'):
+            _LOGGER.error("Trainer has no optimizer. Cannot initialize ReduceLROnPlateau.")
+            raise ValueError()
+            
+        # Initialize the actual scheduler with the optimizer
+        if self.verbose:
+            _LOGGER.info(f"Initializing ReduceLROnPlateau monitoring '{self.monitor}'")
+        
+        self.scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+            optimizer=self.trainer.optimizer, # type: ignore
+            **self.config
+        )
+        
+        # Register with trainer for checkpointing
+        self.trainer.scheduler = self.scheduler # type: ignore
+
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+        
+        metric_val = logs.get(self.monitor)
+        
+        if metric_val is None:
+            _LOGGER.warning(f"DragonReduceLROnPlateau could not find metric '{self.monitor}' in logs. Scheduler step skipped.")
+            # Still log LR to keep history consistent
+            self._check_and_log_lr(epoch, logs, self.verbose)
+            return
+
+        # Step with metric
+        self.scheduler.step(metric_val)
+        
+        self._check_and_log_lr(epoch, logs, self.verbose)
+

ml_tools/{ML_chaining_utilities.py → ML_chain/__init__.py}

@@ -1,11 +1,16 @@
-from ._core._ML_chaining_utilities import (
-    DragonChainOrchestrator,
+from ._dragon_chain import (
+    DragonChainOrchestrator
+)
+
+from ._chaining_tools import (
     augment_dataset_with_predictions,
     augment_dataset_with_predictions_multi,
     prepare_chaining_dataset,
-    info
 )
 
+from ._imprimir import info
+
+
 __all__ = [
     "DragonChainOrchestrator",
     "augment_dataset_with_predictions",

ml_tools/{_core/_ML_chaining_utilities.py → ML_chain/_chaining_tools.py}

@@ -3,17 +3,16 @@ import numpy as np
 from math import ceil
 from typing import Optional, Literal
 
-from ._ML_inference import DragonInferenceHandler
-from ._keys import MLTaskKeys, PyTorchInferenceKeys
-from ._logger import get_logger
-from ._script_info import _script_info
+from ..ML_inference import DragonInferenceHandler
 
+from ..keys._keys import MLTaskKeys, PyTorchInferenceKeys
+from .._core import get_logger
 
-_LOGGER = get_logger("ML Chaining")
+
+_LOGGER = get_logger("ML Chain")
 
 
 __all__ = [
-    "DragonChainOrchestrator",
     "augment_dataset_with_predictions",
     "augment_dataset_with_predictions_multi",
     "prepare_chaining_dataset",
@@ -321,126 +320,3 @@ def prepare_chaining_dataset(
 
     return df
 
-
-class DragonChainOrchestrator:
-    """
-    Manages the data flow for a sequential chain of ML models (Model 1 -> Model 2 -> ... -> Model N).
-    
-    This orchestrator maintains a master copy of the dataset that grows as models are applied.
-    1. Use `get_training_data` to extract a clean, target-specific subset for training a model.
-    2. Train your model externally.
-    3. Use `update_with_inference` to run that model on the master dataset and append predictions 
-       as features for subsequent steps.
-    """
-    def __init__(self, initial_dataset: pd.DataFrame, all_targets: list[str]):
-        """
-        Args:
-            initial_dataset (pd.DataFrame): The starting dataframe with original features and all ground truth targets.
-            all_targets (list[str]): A list of all ground truth target column names present in the dataset.
-        """
-        # Validation: Ensure targets exist
-        missing = [t for t in all_targets if t not in initial_dataset.columns]
-        if missing:
-            _LOGGER.error(f"The following targets were not found in the initial dataset: {missing}")
-            raise ValueError()
-
-        self.current_dataset = initial_dataset.copy()
-        self.all_targets = all_targets
-        _LOGGER.info(f"Orchestrator initialized with {len(initial_dataset)} samples, {len(initial_dataset.columns) - len(all_targets)} features, and {len(all_targets)} targets.")
-
-    def get_training_data(
-        self, 
-        target_subset: list[str], 
-        dropna_how: Literal["any", "all"] = "all"
-    ) -> pd.DataFrame:
-        """
-        Generates a clean dataframe tailored for training a specific step in the chain.
-        
-        This method does NOT modify the internal state. It returns a view with:
-        - Current features (including previous model predictions).
-        - Only the specified `target_subset`.
-        - Rows cleaned based on `dropna_how`.
-        
-        Args:
-            target_subset (list[str]): The targets for the current model.
-            dropna_how (Literal["any", "all"]): "any" drops row if any target is missing; "all" drops if all are missing.
-
-        Returns:
-            pd.DataFrame: A prepared dataframe for training.
-        """
-        _LOGGER.info(f"Extracting training data for targets {target_subset}...")
-        return prepare_chaining_dataset(
-            dataset=self.current_dataset, 
-            all_targets=self.all_targets, 
-            target_subset=target_subset, 
-            dropna_how=dropna_how,
-            verbose=False
-        )
-
-    def update_with_inference(
-        self, 
-        handler: DragonInferenceHandler, 
-        prefix: str = "pred_", 
-        batch_size: int = 4096
-    ) -> None:
-        """
-        Runs inference using the provided handler on the full internal dataset and appends the results as new features.
-        
-        This updates the internal state of the Orchestrator. Subsequent calls to `get_training_data` 
-        will include these new prediction columns as features.
-
-        Args:
-            handler (DragonInferenceHandler): The trained model handler.
-            prefix (str): Prefix for the new prediction columns (e.g., "m1_", "step2_").
-            batch_size (int): Batch size for inference.
-        """
-        _LOGGER.info(f"Orchestrator: Updating internal state with predictions from handler (Targets: {handler.target_ids})...")
-        
-        # We use the existing utility to handle the augmentation
-        # This keeps the logic consistent (drop GT -> predict -> concat GT)
-        self.current_dataset = augment_dataset_with_predictions(
-            handler=handler,
-            dataset=self.current_dataset,
-            ground_truth_targets=self.all_targets,
-            prediction_col_prefix=prefix,
-            batch_size=batch_size
-        )
-        
-        _LOGGER.debug(f"Orchestrator State updated. Current feature count (approx): {self.current_dataset.shape[1] - len(self.all_targets)}")
-        
-    def update_with_ensemble(
-        self,
-        handlers: list[DragonInferenceHandler],
-        prefixes: Optional[list[str]] = None,
-        batch_size: int = 4096
-    ) -> None:
-        """
-        Runs multiple independent inference handlers (e.g. for Stacking) on the full internal dataset 
-        and appends all results as new features.
-        
-        Args:
-            handlers (list[DragonInferenceHandler]): List of trained model handlers.
-            prefixes (list[str], optional): Prefixes for each model's columns.
-            batch_size (int): Batch size for inference.
-        """
-        _LOGGER.info(f"Orchestrator: Updating internal state with ensemble of {len(handlers)} models...")
-        
-        self.current_dataset = augment_dataset_with_predictions_multi(
-            handlers=handlers,
-            dataset=self.current_dataset,
-            ground_truth_targets=self.all_targets,
-            model_prefixes=prefixes,
-            batch_size=batch_size
-        )
-        
-        new_feat_count = self.current_dataset.shape[1] - len(self.all_targets)
-        _LOGGER.debug(f"Orchestrator: State updated. Total current features: {new_feat_count}")
-
-    @property
-    def latest_dataset(self) -> pd.DataFrame:
-        """Returns a copy of the current master dataset including all accumulated predictions."""
-        return self.current_dataset.copy()
-
-
-def info():
-    _script_info(__all__)

ml_tools/ML_chain/_dragon_chain.py

@@ -0,0 +1,140 @@
+import pandas as pd
+from typing import Optional, Literal
+
+from ..ML_inference import DragonInferenceHandler
+
+from .._core import get_logger
+
+from ._chaining_tools import (
+    augment_dataset_with_predictions,
+    augment_dataset_with_predictions_multi,
+    prepare_chaining_dataset,
+)
+
+
+_LOGGER = get_logger("DragonChainOrchestrator")
+
+
+__all__ = [
+    "DragonChainOrchestrator",
+]
+
+class DragonChainOrchestrator:
+    """
+    Manages the data flow for a sequential chain of ML models (Model 1 -> Model 2 -> ... -> Model N).
+    
+    This orchestrator maintains a master copy of the dataset that grows as models are applied.
+    1. Use `get_training_data` to extract a clean, target-specific subset for training a model.
+    2. Train your model externally.
+    3. Use `update_with_inference` to run that model on the master dataset and append predictions 
+       as features for subsequent steps.
+    """
+    def __init__(self, initial_dataset: pd.DataFrame, all_targets: list[str]):
+        """
+        Args:
+            initial_dataset (pd.DataFrame): The starting dataframe with original features and all ground truth targets.
+            all_targets (list[str]): A list of all ground truth target column names present in the dataset.
+        """
+        # Validation: Ensure targets exist
+        missing = [t for t in all_targets if t not in initial_dataset.columns]
+        if missing:
+            _LOGGER.error(f"The following targets were not found in the initial dataset: {missing}")
+            raise ValueError()
+
+        self.current_dataset = initial_dataset.copy()
+        self.all_targets = all_targets
+        _LOGGER.info(f"Orchestrator initialized with {len(initial_dataset)} samples, {len(initial_dataset.columns) - len(all_targets)} features, and {len(all_targets)} targets.")
+
+    def get_training_data(
+        self, 
+        target_subset: list[str], 
+        dropna_how: Literal["any", "all"] = "all"
+    ) -> pd.DataFrame:
+        """
+        Generates a clean dataframe tailored for training a specific step in the chain.
+        
+        This method does NOT modify the internal state. It returns a view with:
+        - Current features (including previous model predictions).
+        - Only the specified `target_subset`.
+        - Rows cleaned based on `dropna_how`.
+        
+        Args:
+            target_subset (list[str]): The targets for the current model.
+            dropna_how (Literal["any", "all"]): "any" drops row if any target is missing; "all" drops if all are missing.
+
+        Returns:
+            pd.DataFrame: A prepared dataframe for training.
+        """
+        _LOGGER.info(f"Extracting training data for targets {target_subset}...")
+        return prepare_chaining_dataset(
+            dataset=self.current_dataset, 
+            all_targets=self.all_targets, 
+            target_subset=target_subset, 
+            dropna_how=dropna_how,
+            verbose=False
+        )
+
+    def update_with_inference(
+        self, 
+        handler: DragonInferenceHandler, 
+        prefix: str = "pred_", 
+        batch_size: int = 4096
+    ) -> None:
+        """
+        Runs inference using the provided handler on the full internal dataset and appends the results as new features.
+        
+        This updates the internal state of the Orchestrator. Subsequent calls to `get_training_data` 
+        will include these new prediction columns as features.
+
+        Args:
+            handler (DragonInferenceHandler): The trained model handler.
+            prefix (str): Prefix for the new prediction columns (e.g., "m1_", "step2_").
+            batch_size (int): Batch size for inference.
+        """
+        _LOGGER.info(f"Orchestrator: Updating internal state with predictions from handler (Targets: {handler.target_ids})...")
+        
+        # We use the existing utility to handle the augmentation
+        # This keeps the logic consistent (drop GT -> predict -> concat GT)
+        self.current_dataset = augment_dataset_with_predictions(
+            handler=handler,
+            dataset=self.current_dataset,
+            ground_truth_targets=self.all_targets,
+            prediction_col_prefix=prefix,
+            batch_size=batch_size
+        )
+        
+        _LOGGER.debug(f"Orchestrator State updated. Current feature count (approx): {self.current_dataset.shape[1] - len(self.all_targets)}")
+        
+    def update_with_ensemble(
+        self,
+        handlers: list[DragonInferenceHandler],
+        prefixes: Optional[list[str]] = None,
+        batch_size: int = 4096
+    ) -> None:
+        """
+        Runs multiple independent inference handlers (e.g. for Stacking) on the full internal dataset 
+        and appends all results as new features.
+        
+        Args:
+            handlers (list[DragonInferenceHandler]): List of trained model handlers.
+            prefixes (list[str], optional): Prefixes for each model's columns.
+            batch_size (int): Batch size for inference.
+        """
+        _LOGGER.info(f"Orchestrator: Updating internal state with ensemble of {len(handlers)} models...")
+        
+        self.current_dataset = augment_dataset_with_predictions_multi(
+            handlers=handlers,
+            dataset=self.current_dataset,
+            ground_truth_targets=self.all_targets,
+            model_prefixes=prefixes,
+            batch_size=batch_size
+        )
+        
+        new_feat_count = self.current_dataset.shape[1] - len(self.all_targets)
+        _LOGGER.debug(f"Orchestrator: State updated. Total current features: {new_feat_count}")
+
+    @property
+    def latest_dataset(self) -> pd.DataFrame:
+        """Returns a copy of the current master dataset including all accumulated predictions."""
+        return self.current_dataset.copy()
+

ml_tools/ML_chain/_imprimir.py

@@ -0,0 +1,11 @@
+from .._core import _imprimir_disponibles
+
+_GRUPOS = [
+    "DragonChainOrchestrator",
+    "augment_dataset_with_predictions",
+    "augment_dataset_with_predictions_multi",
+    "prepare_chaining_dataset",
+]
+
+def info():
+    _imprimir_disponibles(_GRUPOS)

ml_tools/ML_configuration/__init__.py

@@ -0,0 +1,90 @@
+from ._metrics import (
+    FormatRegressionMetrics,
+    FormatMultiTargetRegressionMetrics,
+    FormatBinaryClassificationMetrics,
+    FormatMultiClassClassificationMetrics,
+    FormatBinaryImageClassificationMetrics,
+    FormatMultiClassImageClassificationMetrics,
+    FormatMultiLabelBinaryClassificationMetrics,
+    FormatBinarySegmentationMetrics,
+    FormatMultiClassSegmentationMetrics,
+    FormatSequenceValueMetrics,
+    FormatSequenceSequenceMetrics,
+)
+
+from ._finalize import (
+    FinalizeBinaryClassification,
+    FinalizeBinarySegmentation,
+    FinalizeBinaryImageClassification,
+    FinalizeMultiClassClassification,
+    FinalizeMultiClassImageClassification,
+    FinalizeMultiClassSegmentation,
+    FinalizeMultiLabelBinaryClassification,
+    FinalizeMultiTargetRegression,
+    FinalizeRegression,
+    FinalizeObjectDetection,
+    FinalizeSequenceSequencePrediction,
+    FinalizeSequenceValuePrediction,
+)
+
+from ._models import (
+    DragonMLPParams,
+    DragonAttentionMLPParams,
+    DragonMultiHeadAttentionNetParams,
+    DragonTabularTransformerParams,
+    DragonGateParams,
+    DragonNodeParams,
+    DragonTabNetParams,
+    DragonAutoIntParams,
+)
+
+from ._training import (
+    DragonTrainingConfig,
+    DragonParetoConfig,
+)
+
+from ._imprimir import info
+
+
+__all__ = [
+    # --- Metrics Formats ---
+    "FormatRegressionMetrics",
+    "FormatMultiTargetRegressionMetrics",
+    "FormatBinaryClassificationMetrics",
+    "FormatMultiClassClassificationMetrics",
+    "FormatBinaryImageClassificationMetrics",
+    "FormatMultiClassImageClassificationMetrics",
+    "FormatMultiLabelBinaryClassificationMetrics",
+    "FormatBinarySegmentationMetrics",
+    "FormatMultiClassSegmentationMetrics",
+    "FormatSequenceValueMetrics",
+    "FormatSequenceSequenceMetrics",
+    
+    # --- Finalize Configs ---
+    "FinalizeBinaryClassification",
+    "FinalizeBinarySegmentation",
+    "FinalizeBinaryImageClassification",
+    "FinalizeMultiClassClassification",
+    "FinalizeMultiClassImageClassification",
+    "FinalizeMultiClassSegmentation",
+    "FinalizeMultiLabelBinaryClassification",
+    "FinalizeMultiTargetRegression",
+    "FinalizeRegression",
+    "FinalizeObjectDetection",
+    "FinalizeSequenceSequencePrediction",
+    "FinalizeSequenceValuePrediction",
+    
+    # --- Model Parameter Configs ---
+    "DragonMLPParams",
+    "DragonAttentionMLPParams",
+    "DragonMultiHeadAttentionNetParams",
+    "DragonTabularTransformerParams",
+    "DragonGateParams",
+    "DragonNodeParams",
+    "DragonTabNetParams",
+    "DragonAutoIntParams",
+    
+    # --- Training Config ---
+    "DragonTrainingConfig",
+    "DragonParetoConfig",
+]

ml_tools/ML_configuration/_base_model_config.py

@@ -0,0 +1,69 @@
+from typing import Any
+from pathlib import Path
+from collections.abc import Mapping
+
+from ..schema import FeatureSchema
+
+
+__all__ = [    
+    "_BaseModelParams",
+]
+
+
+class _BaseModelParams(Mapping):
+    """
+    [PRIVATE] Base class for model parameter configs.
+    
+    Inherits from Mapping to behave like a dictionary, enabling
+    `**params` unpacking directly into model constructors.
+    """
+    def __getitem__(self, key: str) -> Any:
+        return self.__dict__[key]
+    
+    def __iter__(self):
+        return iter(self.__dict__)
+    
+    def __len__(self) -> int:
+        return len(self.__dict__)
+    
+    def __or__(self, other) -> dict[str, Any]:
+        """Allows merging with other Mappings using the | operator."""
+        if isinstance(other, Mapping):
+            return dict(self) | dict(other)
+        return NotImplemented
+    
+    def __ror__(self, other) -> dict[str, Any]:
+        """Allows merging with other Mappings using the | operator."""
+        if isinstance(other, Mapping):
+            return dict(other) | dict(self)
+        return NotImplemented
+
+    def __repr__(self) -> str:
+        """Returns a formatted multi-line string representation."""
+        class_name = self.__class__.__name__
+        # Format parameters for clean logging
+        params = []
+        for k, v in self.__dict__.items():
+            # If value is huge (like FeatureSchema), use its own repr
+            val_str = repr(v)
+            params.append(f"  {k}={val_str}")
+            
+        params_str = ",\n".join(params)
+        return f"{class_name}(\n{params_str}\n)"
+    
+    def to_log(self) -> dict[str, Any]:
+        """        
+        Safely converts complex types (like FeatureSchema) to their string 
+        representation for cleaner JSON logging.
+        """
+        clean_dict = {}
+        for k, v in self.__dict__.items():
+            if isinstance(v, FeatureSchema):
+                # Force the repr() string, otherwise json.dump treats it as a list
+                clean_dict[k] = repr(v)
+            elif isinstance(v, Path):
+                # JSON cannot serialize Path objects, convert to string
+                clean_dict[k] = str(v)
+            else:
+                clean_dict[k] = v
+        return clean_dict