expops 0.1.3__py3-none-any.whl

mlops/__main__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""
+MLOps Platform __main__ module
+
+Allows the package to be run with `python -m mlops.main`
+"""
+
+from .main import main
+
+if __name__ == '__main__':
+    main() 

mlops/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)
+
+__commit_id__ = commit_id = None

mlops/adapters/__init__.py

@@ -0,0 +1,12 @@
+"""Adapter plugins package.
+
+This package contains subpackages that each expose an `Adapter` symbol
+for plugin discovery (e.g., `mlops.adapters.custom.Adapter`).
+"""
+
+__all__ = [
+    "custom",
+    "sklearn",
+]
+
+

mlops/adapters/base.py

@@ -0,0 +1,86 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+from dataclasses import dataclass
+from pathlib import Path
+
+@dataclass
+class ModelConfig:
+    """Configuration for a model adapter."""
+    name: str
+    framework: str
+    language: str
+    version: str
+    parameters: Dict[str, Any]
+    requirements: Dict[str, str]
+    hardware_requirements: Optional[Dict[str, Any]] = None
+
+class ModelAdapter(ABC):
+    """Base class for all model adapters.
+    
+    This interface defines the contract that all model adapters must implement.
+    It provides methods for training, evaluation, and model management.
+    """
+    
+    def __init__(self, config: ModelConfig, python_interpreter: Optional[str] = None, environment_name: Optional[str] = None, conda_env_name: Optional[str] = None):
+        self.config = config
+        self.model = None
+        self.python_interpreter = python_interpreter
+        
+        # Support both new and legacy parameter names
+        self.environment_name = environment_name or conda_env_name
+        # Keep legacy property for backward compatibility
+        self.conda_env_name = self.environment_name
+        
+        if self.python_interpreter:
+            print(f"[{self.__class__.__name__}] Initialized with Python interpreter: {self.python_interpreter}")
+        
+        if self.environment_name:
+            print(f"[{self.__class__.__name__}] Initialized with environment: {self.environment_name}")
+        else:
+            print(f"[{self.__class__.__name__}] Initialized without specific environment")
+    
+    @abstractmethod
+    def initialize(self) -> None:
+        """Initialize the model with the given configuration."""
+        pass
+    
+    @abstractmethod
+    def run(self, data_paths: Dict[str, Path] | None = None, **kwargs) -> Dict[str, Any]:
+        """Run the pipeline according to the configured processes/steps.
+        
+        Args:
+            data_paths: Optional mapping of named data roles to paths (e.g., {"training": Path(...), "validation": Path(...)}).
+            **kwargs: Additional parameters forwarded to the adapter/pipeline.
+            
+        Returns:
+            Dictionary containing pipeline results and/or metrics.
+        """
+        pass
+    
+    @abstractmethod
+    def save(self, path: Path) -> None:
+        """Save the model to the specified path."""
+        pass
+    
+    @abstractmethod
+    def load(self, path: Path) -> None:
+        """Load the model from the specified path."""
+        pass
+    
+    # Optional prediction interface for adapters that expose direct predict APIs
+    def predict(self, data: Any) -> Any:
+        """Optional: Make predictions using the model if supported by the adapter."""
+        raise NotImplementedError("This adapter does not implement a direct predict() API.")
+    
+    @classmethod
+    @abstractmethod
+    def validate_config(cls, config: ModelConfig) -> bool:
+        """Validate the configuration for this adapter.
+        
+        Args:
+            config: Configuration to validate
+            
+        Returns:
+            True if configuration is valid, False otherwise
+        """
+        pass 

mlops/adapters/config_schema.py

@@ -0,0 +1,89 @@
+from typing import Dict, Any, Optional, List, Union
+from pydantic import BaseModel, Field, ConfigDict
+
+class HardwareRequirements(BaseModel):
+    """Hardware requirements for model training."""
+    gpu: bool = False
+    min_memory_gb: Optional[float] = None
+    min_cpu_cores: Optional[int] = None
+
+class ModelParameters(BaseModel):
+    """Model-specific parameters."""
+    class_name: Optional[str] = Field(None, description="Fully qualified class name of the model (for pre-built frameworks)")
+    custom_script_path: Optional[str] = Field(None, description="Path to the custom Python script (relative to project root or absolute)")
+    custom_target: Optional[str] = Field(None, description="(Optional) Name of the class or function within the custom script. If not provided, the adapter will look for a MLOpsCustomModelBase subclass.")
+    hyperparameters: Dict[str, Any] = Field(default_factory=dict, description="Model initialization parameters")
+    training_params: Dict[str, Any] = Field(default_factory=dict, description="Training-specific parameters")
+    # Caching and execution
+    cache: Dict[str, Any] = Field(default_factory=dict, description="Caching configuration (ttl_hours, backend, object_store)")
+    executor: Dict[str, Any] = Field(default_factory=dict, description="Executor configuration (n_workers, scheduler_address)")
+    
+    # NetworkX pipeline configuration - supports process-level DAGs with step-level loops
+    pipeline: Optional[Dict[str, Any]] = Field(None, description="NetworkX pipeline configuration with processes and steps")
+
+class AdapterConfig(BaseModel):
+    """Configuration for a model adapter."""
+    name: str = Field(..., description="Name of the model")
+    framework: str = Field(..., description="ML framework (e.g., sklearn, pytorch, tensorflow, custom)")
+    language: str = Field(..., description="Programming language (e.g., python, cpp)")
+    version: str = Field(..., description="Version of the framework or custom model")
+    parameters: ModelParameters = Field(..., description="Model-specific parameters")
+    requirements: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Package requirements (package_name: version)"
+    )
+    hardware_requirements: Optional[HardwareRequirements] = Field(
+        None,
+        description="Hardware requirements for training"
+    )
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "name": "custom_model_with_loops",
+                "framework": "custom",
+                "language": "python",
+                "version": "1.0.0",
+                "parameters": {
+                    "custom_script_path": "examples/custom_models/networkx_examples/models/kmeans_model.py",
+                    "custom_target": "KMeansCustomModel",
+                    "hyperparameters": {
+                        "n_clusters": 3,
+                        "max_iterations": 100,
+                        "convergence_threshold": 0.001
+                    },
+                    # NetworkX pipeline configuration with process-level DAGs and step-level loops
+                    "pipeline": {
+                        "process_adjlist": "data_prep clustering\nclustering evaluation",
+                        "processes": [
+                            {"name": "data_prep", "max_iterations": 1},
+                            {"name": "clustering", "max_iterations": 100, "convergence_threshold": 0.001},
+                            {"name": "evaluation", "max_iterations": 1}
+                        ],
+                        "steps": [
+                            {"name": "preprocess_data", "process": "data_prep"},
+                            {"name": "initialize_centroids", "process": "clustering"},
+                            {"name": "update_centroids", "process": "clustering", "loop_back_to": "assign_clusters"},
+                            {"name": "assign_clusters", "process": "clustering", "depends_on": ["update_centroids"], "loop_back_to": "update_centroids"},
+                            {"name": "evaluate_clustering", "process": "evaluation", "depends_on": ["assign_clusters"]}
+                        ],
+                        "execution": {
+                            "parallel": True,
+                            "failure_mode": "stop",
+                            "max_workers": 4
+                        }
+                    }
+                },
+                "requirements": {
+                    "networkx": "3.0",
+                    "numpy": "1.24.0",
+                    "scikit-learn": "1.3.0"
+                },
+                "hardware_requirements": {
+                    "gpu": False,
+                    "min_memory_gb": 4.0,
+                    "min_cpu_cores": 2
+                }
+            }
+        }
+    ) 

mlops/adapters/custom/__init__.py

@@ -0,0 +1,3 @@
+from .custom_adapter import CustomModelAdapter
+
+Adapter = CustomModelAdapter