flowyml 1.7.2__py3-none-any.whl → 1.8.0__py3-none-any.whl

flowyml/plugins/trackers/mlflow.py

@@ -0,0 +1,316 @@
+"""MLflow Experiment Tracker - Native FlowyML Plugin.
+
+This is a native FlowyML implementation that uses MLflow directly,
+without requiring any external framework dependencies.
+
+Usage:
+    from flowyml.plugins import get_plugin
+
+    tracker = get_plugin("mlflow", tracking_uri="http://localhost:5000")
+
+    tracker.start_run("my_experiment", experiment_name="training")
+    tracker.log_params({"learning_rate": 0.001, "epochs": 100})
+    tracker.log_metrics({"accuracy": 0.95, "loss": 0.05})
+    tracker.end_run()
+"""
+
+import logging
+from typing import Any
+from pathlib import Path
+
+from flowyml.plugins.base import ExperimentTracker, PluginMetadata, PluginType
+
+logger = logging.getLogger(__name__)
+
+
+class MLflowTracker(ExperimentTracker):
+    """Native MLflow experiment tracker for FlowyML.
+
+    This tracker integrates directly with MLflow without any
+    intermediate framework, providing full control over the
+    tracking experience.
+
+    Args:
+        tracking_uri: MLflow tracking server URI. If not provided,
+            uses a local mlruns directory.
+        experiment_name: Default experiment name.
+        artifact_location: Custom artifact storage location.
+        registry_uri: Model registry URI (if different from tracking).
+
+    Example:
+        tracker = MLflowTracker(
+            tracking_uri="http://localhost:5000",
+            experiment_name="my_experiments"
+        )
+
+        run_id = tracker.start_run("training_v1")
+        tracker.log_params({"lr": 0.001})
+        tracker.log_metrics({"accuracy": 0.95})
+        tracker.log_artifact("model.pkl")
+        tracker.end_run()
+    """
+
+    METADATA = PluginMetadata(
+        name="mlflow",
+        description="MLflow experiment tracking and model registry",
+        plugin_type=PluginType.EXPERIMENT_TRACKER,
+        version="1.0.0",
+        author="FlowyML",
+        packages=["mlflow>=2.0"],
+        documentation_url="https://mlflow.org/docs/latest/index.html",
+        tags=["experiment-tracking", "model-registry", "popular"],
+    )
+
+    def __init__(
+        self,
+        tracking_uri: str = None,
+        experiment_name: str = None,
+        artifact_location: str = None,
+        registry_uri: str = None,
+        **kwargs,
+    ):
+        """Initialize the MLflow tracker."""
+        super().__init__(
+            name=kwargs.pop("name", "mlflow"),
+            tracking_uri=tracking_uri,
+            experiment_name=experiment_name,
+            artifact_location=artifact_location,
+            registry_uri=registry_uri,
+            **kwargs,
+        )
+
+        self._mlflow = None
+        self._current_run = None
+        self._experiment_name = experiment_name
+        self._artifact_location = artifact_location
+
+    def initialize(self) -> None:
+        """Initialize MLflow connection."""
+        try:
+            import mlflow
+
+            self._mlflow = mlflow
+
+            # Set tracking URI
+            tracking_uri = self._config.get("tracking_uri") or self._local_backend()
+            mlflow.set_tracking_uri(tracking_uri)
+
+            # Set registry URI if provided
+            registry_uri = self._config.get("registry_uri")
+            if registry_uri:
+                mlflow.set_registry_uri(registry_uri)
+
+            self._is_initialized = True
+            logger.info(f"MLflow initialized with tracking URI: {tracking_uri}")
+
+        except ImportError:
+            raise ImportError(
+                "MLflow is not installed. Run: flowyml plugin install mlflow",
+            )
+
+    def _local_backend(self) -> str:
+        """Get the local MLflow backend path."""
+        mlruns_path = Path.cwd() / "mlruns"
+        mlruns_path.mkdir(parents=True, exist_ok=True)
+        return f"file:{mlruns_path}"
+
+    def _ensure_initialized(self) -> None:
+        """Ensure MLflow is initialized."""
+        if not self._is_initialized:
+            self.initialize()
+
+    def start_run(
+        self,
+        run_name: str,
+        experiment_name: str = None,
+        tags: dict = None,
+    ) -> str:
+        """Start a new MLflow run.
+
+        Args:
+            run_name: Name for this run.
+            experiment_name: Experiment to log to. Uses default if not provided.
+            tags: Optional tags for the run.
+
+        Returns:
+            The run ID.
+        """
+        self._ensure_initialized()
+
+        # Set experiment
+        exp_name = experiment_name or self._experiment_name or "default"
+        self._mlflow.set_experiment(exp_name)
+
+        # Start run
+        run = self._mlflow.start_run(run_name=run_name, tags=tags)
+        self._current_run = run
+
+        logger.info(f"Started MLflow run '{run_name}' (ID: {run.info.run_id})")
+        return run.info.run_id
+
+    def end_run(self, status: str = "FINISHED") -> None:
+        """End the current run.
+
+        Args:
+            status: Final status (FINISHED, FAILED, KILLED).
+        """
+        self._ensure_initialized()
+
+        mlflow_status = {
+            "FINISHED": "FINISHED",
+            "FAILED": "FAILED",
+            "KILLED": "KILLED",
+        }.get(status.upper(), "FINISHED")
+
+        self._mlflow.end_run(status=mlflow_status)
+        self._current_run = None
+        logger.info(f"Ended MLflow run with status: {mlflow_status}")
+
+    def log_params(self, params: dict[str, Any]) -> None:
+        """Log parameters to the current run.
+
+        Args:
+            params: Dictionary of parameter names and values.
+        """
+        self._ensure_initialized()
+        self._mlflow.log_params(params)
+
+    def log_metrics(self, metrics: dict[str, float], step: int = None) -> None:
+        """Log metrics to the current run.
+
+        Args:
+            metrics: Dictionary of metric names and values.
+            step: Optional step number.
+        """
+        self._ensure_initialized()
+        self._mlflow.log_metrics(metrics, step=step)
+
+    def log_artifact(self, local_path: str, artifact_path: str = None) -> None:
+        """Log an artifact file.
+
+        Args:
+            local_path: Path to the local file.
+            artifact_path: Optional subdirectory in artifacts.
+        """
+        self._ensure_initialized()
+        self._mlflow.log_artifact(local_path, artifact_path)
+
+    def log_artifacts(self, local_dir: str, artifact_path: str = None) -> None:
+        """Log all files in a directory as artifacts.
+
+        Args:
+            local_dir: Path to the local directory.
+            artifact_path: Optional subdirectory in artifacts.
+        """
+        self._ensure_initialized()
+        self._mlflow.log_artifacts(local_dir, artifact_path)
+
+    def log_model(
+        self,
+        model: Any,
+        artifact_path: str,
+        model_type: str = None,
+        registered_model_name: str = None,
+    ) -> None:
+        """Log a model to the current run.
+
+        Args:
+            model: The model object.
+            artifact_path: Path within artifacts.
+            model_type: Type of model (sklearn, pytorch, tensorflow, keras).
+            registered_model_name: Optional name to register in model registry.
+        """
+        self._ensure_initialized()
+
+        # Auto-detect model type if not provided
+        if model_type is None:
+            model_type = self._detect_model_type(model)
+
+        # Log using appropriate MLflow flavor
+        if model_type == "sklearn":
+            self._mlflow.sklearn.log_model(
+                model,
+                artifact_path,
+                registered_model_name=registered_model_name,
+            )
+        elif model_type == "pytorch":
+            self._mlflow.pytorch.log_model(
+                model,
+                artifact_path,
+                registered_model_name=registered_model_name,
+            )
+        elif model_type == "tensorflow" or model_type == "keras":
+            self._mlflow.keras.log_model(
+                model,
+                artifact_path,
+                registered_model_name=registered_model_name,
+            )
+        elif model_type == "xgboost":
+            self._mlflow.xgboost.log_model(
+                model,
+                artifact_path,
+                registered_model_name=registered_model_name,
+            )
+        else:
+            # Fallback to generic pickling
+            self._mlflow.pyfunc.log_model(
+                artifact_path,
+                python_model=model,
+                registered_model_name=registered_model_name,
+            )
+
+    def _detect_model_type(self, model: Any) -> str:
+        """Detect the type of ML model."""
+        model_class = type(model).__module__
+
+        if "sklearn" in model_class:
+            return "sklearn"
+        elif "torch" in model_class:
+            return "pytorch"
+        elif "tensorflow" in model_class or "keras" in model_class:
+            return "keras"
+        elif "xgboost" in model_class:
+            return "xgboost"
+        else:
+            return "generic"
+
+    def get_tracking_uri(self) -> str:
+        """Get the current tracking URI."""
+        self._ensure_initialized()
+        return self._mlflow.get_tracking_uri()
+
+    def get_run_id(self) -> str | None:
+        """Get the current run ID."""
+        if self._current_run:
+            return self._current_run.info.run_id
+        return None
+
+    def set_tag(self, key: str, value: str) -> None:
+        """Set a tag on the current run."""
+        self._ensure_initialized()
+        self._mlflow.set_tag(key, value)
+
+    def set_tags(self, tags: dict[str, str]) -> None:
+        """Set multiple tags on the current run."""
+        self._ensure_initialized()
+        self._mlflow.set_tags(tags)
+
+    def autolog(self, framework: str = None) -> None:
+        """Enable MLflow autologging.
+
+        Args:
+            framework: Specific framework to enable (sklearn, pytorch, etc.)
+                      If None, enables for all supported frameworks.
+        """
+        self._ensure_initialized()
+
+        if framework:
+            getattr(self._mlflow, framework).autolog()
+        else:
+            self._mlflow.autolog()
+
+    def cleanup(self) -> None:
+        """Cleanup resources."""
+        if self._current_run:
+            self.end_run()
+        self._is_initialized = False

flowyml/plugins/validators/__init__.py

@@ -0,0 +1,3 @@
+"""FlowyML Data Validator Plugins."""
+
+__all__ = []

flowyml/plugins/validators/deepchecks.py

@@ -0,0 +1,119 @@
+"""Deepchecks Data Validator - Native FlowyML Plugin.
+
+This plugin integrates Deepchecks for robust data validation,
+including integrity, drift, and performance checks.
+"""
+
+import logging
+from typing import Any
+
+from flowyml.plugins.base import DataValidatorPlugin, PluginMetadata, PluginType
+
+logger = logging.getLogger(__name__)
+
+
+class DeepchecksValidator(DataValidatorPlugin):
+    """Deepchecks data validator for FlowyML.
+
+    Run suites of data validation checks using Deepchecks.
+
+    Args:
+        suite: Name of the default suite to run (e.g., 'integrity', 'train_test_validation').
+    """
+
+    metadata = PluginMetadata(
+        name="deepchecks",
+        version="1.0.0",
+        description="Deepchecks Data Validator",
+        author="FlowyML Team",
+        plugin_type=PluginType.DATA_VALIDATOR,
+        tags=["validation", "data-quality", "drift"],
+        packages=["deepchecks>=0.17.0"],
+    )
+
+    def __init__(self, suite: str = "integrity", **kwargs):
+        super().__init__(**kwargs)
+        self.default_suite = suite
+        self._deepchecks = None
+
+    @property
+    def plugin_type(self) -> PluginType:
+        return PluginType.DATA_VALIDATOR
+
+    def initialize(self) -> None:
+        """Initialize Deepchecks."""
+        try:
+            import deepchecks
+            from deepchecks.tabular import Dataset
+            from deepchecks.tabular import suites
+
+            self._deepchecks = deepchecks
+            self._dc_suites = suites
+            self._dc_dataset = Dataset
+
+            logger.info("Deepchecks validator initialized.")
+
+        except ImportError:
+            raise ImportError(
+                "deepchecks is required. Install with: pip install deepchecks",
+            )
+
+    def validate(self, data: Any, expectations: Any = None) -> dict[str, Any]:
+        """Validate data using Deepchecks.
+
+        Args:
+            data: Pandas DataFrame or supported Deepchecks dataset.
+            expectations: Optional suite name or Suite object.
+                         If None, uses self.default_suite.
+
+        Returns:
+            Validation result dictionary (passed, results json).
+        """
+        self.initialize()
+
+        # Resolve suite
+        suite_obj = None
+        suite_name = expectations or self.default_suite
+
+        if isinstance(suite_name, str):
+            if hasattr(self._dc_suites, suite_name):
+                suite_obj = getattr(self._dc_suites, suite_name)()
+            else:
+                # Try to create a full suite if name not found in presets
+                logger.warning(f"Suite '{suite_name}' not found in default suites, falling back to full suite.")
+                suite_obj = self._dc_suites.full_suite()
+        else:
+            # Assume it's a Suite object passed directly
+            suite_obj = suite_name
+
+        # Wrap data if needed
+        # This is a simplified wrapper; real usage might require label/cat_features config
+        if not isinstance(data, self._dc_dataset):
+            from pandas import DataFrame
+
+            if isinstance(data, DataFrame):
+                ds = self._dc_dataset(data)
+            else:
+                raise ValueError(f"Deepchecks requires DataFrame or Dataset, got {type(data)}")
+        else:
+            ds = data
+
+        logger.info(f"Running Deepchecks suite: {suite_name}")
+        result = suite_obj.run(ds)
+
+        # Determine overall success (if any check failed)
+        # Deepchecks results structure varies, but we can serialize to json/dict
+        passed = result.passed() if hasattr(result, "passed") else True  # simplified check
+
+        return {
+            "passed": passed,
+            "suite_name": str(suite_name),
+            "results": result.to_json(),
+            "report_html": result.save_as_html(),  # Returns path string usually
+        }
+
+    def get_data_profile(self, data: Any) -> dict[str, Any]:
+        """Profile data using Deepchecks integrity suite as a proxy."""
+        # Deepchecks doesn't have a pure "profile" methods like pandas-profiling
+        # but we can run a quick check
+        return self.validate(data, expectations="integrity")

flowyml/registry/__init__.py

@@ -1,5 +1,6 @@
 """Model registry for versioning and deployment."""
 
 from flowyml.registry.model_registry import ModelRegistry, ModelVersion, ModelStage
+from flowyml.registry.model_environment import ModelEnvironment
 
-__all__ = ["ModelRegistry", "ModelVersion", "ModelStage"]
+__all__ = ["ModelRegistry", "ModelVersion", "ModelStage", "ModelEnvironment"]

flowyml/registry/model_environment.py

@@ -0,0 +1,109 @@
+"""Model environment capture for reproducibility."""
+
+import sys
+import subprocess
+import platform
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class ModelEnvironment:
+    r"""Captures Python environment for model reproducibility.
+
+    Example:
+        >>> env = ModelEnvironment.from_current()
+        >>> print(env.python_version)
+        '3.11.5'
+        >>> env.to_requirements_txt()
+        'numpy==1.24.0\npandas==2.0.0\n...'
+    """
+
+    python_version: str
+    platform: str
+    dependencies: list[str] = field(default_factory=list)
+    system_info: dict[str, str] = field(default_factory=dict)
+    captured_at: str = field(default_factory=lambda: datetime.now().isoformat())
+
+    @classmethod
+    def from_current(cls, include_all: bool = False) -> "ModelEnvironment":  # noqa: ARG003
+        """Capture current Python environment.
+
+        Args:
+            include_all: If True, capture all packages. If False, only top-level.
+
+        Returns:
+            ModelEnvironment with current system info and dependencies
+        """
+        # Get pip freeze output
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "freeze"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            deps = [line.strip() for line in result.stdout.splitlines() if line.strip()]
+        except Exception:
+            deps = []
+
+        # System info
+        system_info = {
+            "os": platform.system(),
+            "os_version": platform.version(),
+            "machine": platform.machine(),
+            "processor": platform.processor(),
+        }
+
+        return cls(
+            python_version=platform.python_version(),
+            platform=platform.platform(),
+            dependencies=deps,
+            system_info=system_info,
+        )
+
+    def to_requirements_txt(self) -> str:
+        """Export dependencies as requirements.txt format.
+
+        Returns:
+            String with one dependency per line
+        """
+        return "\n".join(self.dependencies)
+
+    def save_requirements(self, path: str) -> None:
+        """Save dependencies to a requirements.txt file.
+
+        Args:
+            path: Path to save the file
+        """
+        with open(path, "w") as f:
+            f.write(self.to_requirements_txt())
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ModelEnvironment":
+        """Create from dictionary."""
+        return cls(**data)
+
+    def get_package_version(self, package_name: str) -> str | None:
+        """Get version of a specific package.
+
+        Args:
+            package_name: Name of the package to look up
+
+        Returns:
+            Version string or None if not found
+        """
+        for dep in self.dependencies:
+            if dep.lower().startswith(package_name.lower() + "=="):
+                return dep.split("==")[1]
+            elif dep.lower().startswith(package_name.lower() + ">="):
+                return dep.split(">=")[1]
+        return None
+
+    def __repr__(self) -> str:
+        return f"ModelEnvironment(python={self.python_version}, deps={len(self.dependencies)})"