adamops 0.1.0__py3-none-any.whl

adamops/models/registry.py

@@ -0,0 +1,250 @@
+"""
+AdamOps Model Registry Module
+
+Provides model versioning, metadata tracking, and comparison.
+"""
+
+import json
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import joblib
+
+from adamops.utils.logging import get_logger
+from adamops.utils.config import get_config
+
+logger = get_logger(__name__)
+
+
+class ModelVersion:
+    """Represents a model version."""
+    
+    def __init__(self, name: str, version: str, path: str, metadata: Dict):
+        self.name = name
+        self.version = version
+        self.path = path
+        self.metadata = metadata
+        self.created_at = metadata.get("created_at", datetime.now().isoformat())
+    
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name, "version": self.version, "path": self.path,
+            "metadata": self.metadata, "created_at": self.created_at
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> "ModelVersion":
+        return cls(data["name"], data["version"], data["path"], data["metadata"])
+
+
+class ModelRegistry:
+    """Model registry for versioning and tracking."""
+    
+    def __init__(self, path: Optional[str] = None, backend: str = "json"):
+        """
+        Initialize registry.
+        
+        Args:
+            path: Registry storage path.
+            backend: 'json' or 'sqlite'.
+        """
+        config = get_config()
+        self.path = Path(path or config.registry_path)
+        self.backend = backend
+        self.path.mkdir(parents=True, exist_ok=True)
+        
+        if backend == "sqlite":
+            self._init_sqlite()
+        else:
+            self._init_json()
+    
+    def _init_json(self):
+        self.registry_file = self.path / "registry.json"
+        if not self.registry_file.exists():
+            self._save_json({})
+    
+    def _init_sqlite(self):
+        self.db_file = self.path / "registry.db"
+        conn = sqlite3.connect(self.db_file)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS models (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT, version TEXT, path TEXT,
+                metadata TEXT, created_at TEXT,
+                UNIQUE(name, version)
+            )
+        """)
+        conn.commit()
+        conn.close()
+    
+    def _load_json(self) -> Dict:
+        with open(self.registry_file) as f:
+            return json.load(f)
+    
+    def _save_json(self, data: Dict):
+        with open(self.registry_file, "w") as f:
+            json.dump(data, f, indent=2)
+    
+    def register(self, name: str, model: Any, metadata: Optional[Dict] = None,
+                 version: Optional[str] = None) -> ModelVersion:
+        """
+        Register a model.
+        
+        Args:
+            name: Model name.
+            model: Model object to save.
+            metadata: Model metadata (algorithm, metrics, etc).
+            version: Version string (auto-incremented if None).
+        
+        Returns:
+            ModelVersion: Registered model version.
+        """
+        # Get next version
+        if version is None:
+            existing = self.list_versions(name)
+            version = f"v{len(existing) + 1}"
+        
+        # Save model
+        model_path = self.path / "models" / name / f"{version}.joblib"
+        model_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(model, model_path)
+        
+        # Create version record
+        meta = metadata or {}
+        meta["created_at"] = datetime.now().isoformat()
+        model_version = ModelVersion(name, version, str(model_path), meta)
+        
+        # Store in registry
+        if self.backend == "json":
+            data = self._load_json()
+            if name not in data:
+                data[name] = {}
+            data[name][version] = model_version.to_dict()
+            self._save_json(data)
+        else:
+            conn = sqlite3.connect(self.db_file)
+            conn.execute(
+                "INSERT OR REPLACE INTO models (name, version, path, metadata, created_at) VALUES (?, ?, ?, ?, ?)",
+                (name, version, str(model_path), json.dumps(meta), meta["created_at"])
+            )
+            conn.commit()
+            conn.close()
+        
+        logger.info(f"Registered model {name} version {version}")
+        return model_version
+    
+    def get(self, name: str, version: str = "latest") -> Optional[ModelVersion]:
+        """Get a model version."""
+        if version == "latest":
+            versions = self.list_versions(name)
+            if not versions:
+                return None
+            version = versions[-1].version
+        
+        if self.backend == "json":
+            data = self._load_json()
+            if name in data and version in data[name]:
+                return ModelVersion.from_dict(data[name][version])
+        else:
+            conn = sqlite3.connect(self.db_file)
+            cur = conn.execute(
+                "SELECT name, version, path, metadata FROM models WHERE name=? AND version=?",
+                (name, version)
+            )
+            row = cur.fetchone()
+            conn.close()
+            if row:
+                return ModelVersion(row[0], row[1], row[2], json.loads(row[3]))
+        
+        return None
+    
+    def load(self, name: str, version: str = "latest") -> Any:
+        """Load a model."""
+        model_version = self.get(name, version)
+        if model_version is None:
+            raise ValueError(f"Model {name} version {version} not found")
+        return joblib.load(model_version.path)
+    
+    def list_versions(self, name: str) -> List[ModelVersion]:
+        """List all versions of a model."""
+        if self.backend == "json":
+            data = self._load_json()
+            if name not in data:
+                return []
+            return [ModelVersion.from_dict(v) for v in data[name].values()]
+        else:
+            conn = sqlite3.connect(self.db_file)
+            cur = conn.execute(
+                "SELECT name, version, path, metadata FROM models WHERE name=? ORDER BY created_at",
+                (name,)
+            )
+            versions = [ModelVersion(r[0], r[1], r[2], json.loads(r[3])) for r in cur.fetchall()]
+            conn.close()
+            return versions
+    
+    def list_models(self) -> List[str]:
+        """List all registered model names."""
+        if self.backend == "json":
+            return list(self._load_json().keys())
+        else:
+            conn = sqlite3.connect(self.db_file)
+            cur = conn.execute("SELECT DISTINCT name FROM models")
+            names = [r[0] for r in cur.fetchall()]
+            conn.close()
+            return names
+    
+    def compare(self, name: str, metric: str = "accuracy") -> Dict:
+        """Compare all versions of a model by a metric."""
+        versions = self.list_versions(name)
+        comparison = []
+        for v in versions:
+            metrics = v.metadata.get("metrics", {})
+            comparison.append({
+                "version": v.version,
+                "created_at": v.created_at,
+                metric: metrics.get(metric),
+                **{k: val for k, val in metrics.items() if k != metric}
+            })
+        return sorted(comparison, key=lambda x: x.get(metric, 0) or 0, reverse=True)
+    
+    def delete(self, name: str, version: Optional[str] = None):
+        """Delete a model or version."""
+        if version:
+            model_version = self.get(name, version)
+            if model_version and Path(model_version.path).exists():
+                Path(model_version.path).unlink()
+            
+            if self.backend == "json":
+                data = self._load_json()
+                if name in data and version in data[name]:
+                    del data[name][version]
+                    self._save_json(data)
+            else:
+                conn = sqlite3.connect(self.db_file)
+                conn.execute("DELETE FROM models WHERE name=? AND version=?", (name, version))
+                conn.commit()
+                conn.close()
+        else:
+            # Delete all versions
+            for v in self.list_versions(name):
+                self.delete(name, v.version)
+
+
+# Global registry instance
+_registry: Optional[ModelRegistry] = None
+
+def get_registry() -> ModelRegistry:
+    """Get global registry instance."""
+    global _registry
+    if _registry is None:
+        _registry = ModelRegistry()
+    return _registry
+
+def register_model(name: str, model: Any, **kwargs) -> ModelVersion:
+    """Register a model in the global registry."""
+    return get_registry().register(name, model, **kwargs)
+
+def load_model(name: str, version: str = "latest") -> Any:
+    """Load a model from the global registry."""
+    return get_registry().load(name, version)

adamops/monitoring/__init__.py

@@ -0,0 +1,21 @@
+"""
+AdamOps Monitoring Module
+
+Provides model monitoring capabilities:
+- drift: Detect data and concept drift
+- performance: Track model performance metrics
+- alerts: Set up alerting for performance degradation
+- dashboard: Create monitoring dashboards
+"""
+
+from adamops.monitoring import drift
+from adamops.monitoring import performance
+from adamops.monitoring import alerts
+from adamops.monitoring import dashboard
+
+__all__ = [
+    "drift",
+    "performance",
+    "alerts",
+    "dashboard",
+]

adamops/monitoring/alerts.py

@@ -0,0 +1,200 @@
+"""
+AdamOps Alerts Module
+
+Alerting for model performance degradation.
+"""
+
+from datetime import datetime
+from typing import Any, Callable, Dict, List, Optional
+from enum import Enum
+
+from adamops.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class AlertSeverity(Enum):
+    INFO = "info"
+    WARNING = "warning"
+    CRITICAL = "critical"
+
+
+class Alert:
+    """Represents an alert."""
+    
+    def __init__(self, name: str, message: str, severity: AlertSeverity,
+                 metadata: Optional[Dict] = None):
+        self.name = name
+        self.message = message
+        self.severity = severity
+        self.metadata = metadata or {}
+        self.timestamp = datetime.now().isoformat()
+    
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name,
+            "message": self.message,
+            "severity": self.severity.value,
+            "timestamp": self.timestamp,
+            "metadata": self.metadata,
+        }
+
+
+class AlertRule:
+    """Defines an alert rule."""
+    
+    def __init__(self, name: str, condition: Callable[[Dict], bool],
+                 message_template: str, severity: AlertSeverity = AlertSeverity.WARNING):
+        self.name = name
+        self.condition = condition
+        self.message_template = message_template
+        self.severity = severity
+    
+    def check(self, data: Dict) -> Optional[Alert]:
+        """Check if alert should be triggered."""
+        if self.condition(data):
+            message = self.message_template.format(**data)
+            return Alert(self.name, message, self.severity, data)
+        return None
+
+
+class AlertManager:
+    """Manage alerts and notifications."""
+    
+    def __init__(self):
+        self.rules: List[AlertRule] = []
+        self.handlers: List[Callable[[Alert], None]] = []
+        self.alert_history: List[Alert] = []
+    
+    def add_rule(self, rule: AlertRule):
+        """Add an alert rule."""
+        self.rules.append(rule)
+        logger.info(f"Added alert rule: {rule.name}")
+    
+    def add_handler(self, handler: Callable[[Alert], None]):
+        """Add an alert handler (callback)."""
+        self.handlers.append(handler)
+    
+    def check(self, data: Dict) -> List[Alert]:
+        """Check all rules against data."""
+        triggered = []
+        
+        for rule in self.rules:
+            alert = rule.check(data)
+            if alert:
+                triggered.append(alert)
+                self._handle_alert(alert)
+        
+        return triggered
+    
+    def _handle_alert(self, alert: Alert):
+        """Handle triggered alert."""
+        self.alert_history.append(alert)
+        
+        # Log alert
+        log_method = logger.warning if alert.severity == AlertSeverity.WARNING else \
+                     logger.critical if alert.severity == AlertSeverity.CRITICAL else logger.info
+        log_method(f"[{alert.severity.value.upper()}] {alert.name}: {alert.message}")
+        
+        # Call handlers
+        for handler in self.handlers:
+            try:
+                handler(alert)
+            except Exception as e:
+                logger.error(f"Alert handler error: {e}")
+    
+    def get_history(self, severity: Optional[AlertSeverity] = None) -> List[Alert]:
+        """Get alert history."""
+        if severity:
+            return [a for a in self.alert_history if a.severity == severity]
+        return self.alert_history
+
+
+# Default alert rules
+def accuracy_drop_rule(threshold: float = 0.1) -> AlertRule:
+    """Alert rule for accuracy drop."""
+    return AlertRule(
+        name="accuracy_drop",
+        condition=lambda d: d.get("accuracy_change", 0) < -threshold,
+        message_template="Accuracy dropped by {accuracy_change:.1%}",
+        severity=AlertSeverity.WARNING,
+    )
+
+
+def drift_detected_rule() -> AlertRule:
+    """Alert rule for drift detection."""
+    return AlertRule(
+        name="drift_detected",
+        condition=lambda d: d.get("drift_detected", False),
+        message_template="Data drift detected in {drifted_columns} columns",
+        severity=AlertSeverity.WARNING,
+    )
+
+
+def high_latency_rule(threshold_ms: float = 1000) -> AlertRule:
+    """Alert rule for high latency."""
+    return AlertRule(
+        name="high_latency",
+        condition=lambda d: d.get("latency_ms", 0) > threshold_ms,
+        message_template="High latency detected: {latency_ms:.0f}ms",
+        severity=AlertSeverity.WARNING,
+    )
+
+
+# Notification handlers
+def console_handler(alert: Alert):
+    """Print alert to console."""
+    print(f"[ALERT] {alert.severity.value.upper()}: {alert.message}")
+
+
+def email_handler(recipients: List[str], smtp_config: Dict):
+    """Create email alert handler."""
+    def handler(alert: Alert):
+        try:
+            import smtplib
+            from email.message import EmailMessage
+            
+            msg = EmailMessage()
+            msg['Subject'] = f"[{alert.severity.value.upper()}] {alert.name}"
+            msg['From'] = smtp_config.get('from', 'alerts@adamops.local')
+            msg['To'] = ', '.join(recipients)
+            msg.set_content(f"{alert.message}\n\nTimestamp: {alert.timestamp}")
+            
+            with smtplib.SMTP(smtp_config['host'], smtp_config.get('port', 587)) as s:
+                if smtp_config.get('use_tls'):
+                    s.starttls()
+                if 'username' in smtp_config:
+                    s.login(smtp_config['username'], smtp_config['password'])
+                s.send_message(msg)
+                
+            logger.info(f"Sent email alert to {recipients}")
+        except Exception as e:
+            logger.error(f"Failed to send email: {e}")
+    
+    return handler
+
+
+def create_alert_manager(
+    rules: Optional[List[str]] = None,
+    handlers: Optional[List[str]] = None
+) -> AlertManager:
+    """Create alert manager with default rules."""
+    manager = AlertManager()
+    
+    default_rules = {
+        "accuracy": accuracy_drop_rule(),
+        "drift": drift_detected_rule(),
+        "latency": high_latency_rule(),
+    }
+    
+    rules = rules or list(default_rules.keys())
+    for rule_name in rules:
+        if rule_name in default_rules:
+            manager.add_rule(default_rules[rule_name])
+    
+    handlers = handlers or ["console"]
+    for handler_name in handlers:
+        if handler_name == "console":
+            manager.add_handler(console_handler)
+    
+    return manager

adamops/monitoring/dashboard.py

@@ -0,0 +1,117 @@
+"""
+AdamOps Dashboard Module
+
+Simple monitoring dashboard.
+"""
+
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+
+from adamops.utils.logging import get_logger
+from adamops.monitoring.performance import PerformanceMonitor
+
+logger = get_logger(__name__)
+
+
+def generate_dashboard_html(
+    monitors: Dict[str, PerformanceMonitor],
+    title: str = "AdamOps Monitoring Dashboard"
+) -> str:
+    """
+    Generate HTML dashboard for monitoring.
+    
+    Args:
+        monitors: Dict of model names to monitors.
+        title: Dashboard title.
+    
+    Returns:
+        HTML string.
+    """
+    
+    model_cards = ""
+    for name, monitor in monitors.items():
+        summary = monitor.summary()
+        metrics = summary.get("latest_metrics", {})
+        
+        metrics_html = ""
+        for metric, value in metrics.items():
+            if isinstance(value, float):
+                metrics_html += f'<div class="metric"><span class="label">{metric}</span><span class="value">{value:.4f}</span></div>'
+        
+        model_cards += f'''
+        <div class="card">
+            <h3>{name}</h3>
+            <p>Entries: {summary.get("entries", 0)}</p>
+            <p>Last update: {summary.get("latest_timestamp", "N/A")}</p>
+            <div class="metrics">{metrics_html}</div>
+        </div>
+        '''
+    
+    html = f'''<!DOCTYPE html>
+<html>
+<head>
+    <title>{title}</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 0; padding: 20px; background: #1a1a2e; color: #eee; }}
+        h1 {{ color: #4a90d9; }}
+        .container {{ max-width: 1200px; margin: 0 auto; }}
+        .grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; }}
+        .card {{ background: #16213e; padding: 20px; border-radius: 10px; box-shadow: 0 4px 6px rgba(0,0,0,0.3); }}
+        .card h3 {{ color: #4a90d9; margin-top: 0; }}
+        .metrics {{ margin-top: 15px; }}
+        .metric {{ display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #333; }}
+        .label {{ color: #888; }}
+        .value {{ font-weight: bold; color: #4ecdc4; }}
+        .timestamp {{ color: #666; font-size: 12px; margin-top: 20px; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>{title}</h1>
+        <div class="grid">{model_cards}</div>
+        <p class="timestamp">Generated: {datetime.now().isoformat()}</p>
+    </div>
+</body>
+</html>'''
+    
+    return html
+
+
+def save_dashboard(
+    monitors: Dict[str, PerformanceMonitor],
+    output_path: str,
+    title: str = "AdamOps Monitoring Dashboard"
+):
+    """Save dashboard to HTML file."""
+    html = generate_dashboard_html(monitors, title)
+    with open(output_path, 'w') as f:
+        f.write(html)
+    logger.info(f"Dashboard saved to {output_path}")
+
+
+def create_streamlit_dashboard(monitors: Dict[str, PerformanceMonitor]) -> str:
+    """Generate Streamlit dashboard code."""
+    return '''"""AdamOps Monitoring Dashboard
+Run with: streamlit run dashboard.py
+"""
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from adamops.monitoring.performance import PerformanceMonitor
+
+st.set_page_config(page_title="AdamOps Monitor", layout="wide")
+st.title("AdamOps Monitoring Dashboard")
+
+# Load monitors (customize paths)
+# monitor = PerformanceMonitor("model_name")
+
+# Placeholder content
+st.subheader("Model Performance")
+st.info("Configure monitors to see metrics")
+
+# Example metrics display
+col1, col2, col3 = st.columns(3)
+col1.metric("Accuracy", "0.95", "+0.02")
+col2.metric("Latency", "45ms", "-5ms")
+col3.metric("Predictions", "1,234", "+100")
+'''