adamops 0.1.0__py3-none-any.whl

adamops/deployment/api.py

@@ -0,0 +1,237 @@
+"""
+AdamOps API Module
+
+Create REST APIs for model serving with FastAPI/Flask.
+"""
+
+from typing import Any, Callable, Dict, List, Optional
+import json
+from pathlib import Path
+
+from adamops.utils.logging import get_logger
+from adamops.deployment.exporters import load_model
+
+logger = get_logger(__name__)
+
+
+def create_fastapi_app(
+    model: Any, model_name: str = "model",
+    input_schema: Optional[Dict] = None,
+    preprocess_fn: Optional[Callable] = None,
+    postprocess_fn: Optional[Callable] = None
+):
+    """
+    Create FastAPI application for model serving.
+    
+    Args:
+        model: Trained model.
+        model_name: Name for the model.
+        input_schema: Pydantic model or dict for input validation.
+        preprocess_fn: Function to preprocess input.
+        postprocess_fn: Function to postprocess output.
+    
+    Returns:
+        FastAPI application.
+    """
+    try:
+        from fastapi import FastAPI, HTTPException
+        from pydantic import BaseModel, create_model
+    except ImportError:
+        raise ImportError("FastAPI required. Install with: pip install fastapi uvicorn")
+    
+    import numpy as np
+    
+    app = FastAPI(title=f"{model_name} API", version="1.0.0")
+    
+    # Create input model
+    class PredictionInput(BaseModel):
+        features: List[List[float]]
+    
+    class PredictionOutput(BaseModel):
+        predictions: List
+        model_name: str
+    
+    @app.get("/")
+    def root():
+        return {"message": f"Welcome to {model_name} API", "status": "healthy"}
+    
+    @app.get("/health")
+    def health():
+        return {"status": "healthy", "model": model_name}
+    
+    @app.post("/predict", response_model=PredictionOutput)
+    def predict(input_data: PredictionInput):
+        try:
+            features = np.array(input_data.features)
+            
+            if preprocess_fn:
+                features = preprocess_fn(features)
+            
+            predictions = model.predict(features).tolist()
+            
+            if postprocess_fn:
+                predictions = postprocess_fn(predictions)
+            
+            return PredictionOutput(predictions=predictions, model_name=model_name)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.post("/predict_proba")
+    def predict_proba(input_data: PredictionInput):
+        if not hasattr(model, 'predict_proba'):
+            raise HTTPException(status_code=400, detail="Model does not support probability predictions")
+        
+        try:
+            features = np.array(input_data.features)
+            probas = model.predict_proba(features).tolist()
+            return {"probabilities": probas, "model_name": model_name}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    return app
+
+
+def create_flask_app(
+    model: Any, model_name: str = "model",
+    preprocess_fn: Optional[Callable] = None,
+    postprocess_fn: Optional[Callable] = None
+):
+    """Create Flask application for model serving."""
+    try:
+        from flask import Flask, request, jsonify
+    except ImportError:
+        raise ImportError("Flask required. Install with: pip install flask")
+    
+    import numpy as np
+    
+    app = Flask(model_name)
+    
+    @app.route("/")
+    def root():
+        return jsonify({"message": f"Welcome to {model_name} API", "status": "healthy"})
+    
+    @app.route("/health")
+    def health():
+        return jsonify({"status": "healthy", "model": model_name})
+    
+    @app.route("/predict", methods=["POST"])
+    def predict():
+        try:
+            data = request.get_json()
+            features = np.array(data["features"])
+            
+            if preprocess_fn:
+                features = preprocess_fn(features)
+            
+            predictions = model.predict(features).tolist()
+            
+            if postprocess_fn:
+                predictions = postprocess_fn(predictions)
+            
+            return jsonify({"predictions": predictions, "model_name": model_name})
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+    
+    return app
+
+
+def run_api(
+    model: Any, framework: str = "fastapi",
+    host: str = "0.0.0.0", port: int = 8000, **kwargs
+):
+    """
+    Run model serving API.
+    
+    Args:
+        model: Trained model.
+        framework: 'fastapi' or 'flask'.
+        host: Host address.
+        port: Port number.
+    """
+    if framework == "fastapi":
+        import uvicorn
+        app = create_fastapi_app(model, **kwargs)
+        uvicorn.run(app, host=host, port=port)
+    elif framework == "flask":
+        app = create_flask_app(model, **kwargs)
+        app.run(host=host, port=port)
+    else:
+        raise ValueError(f"Unknown framework: {framework}")
+
+
+def generate_api_code(
+    model_path: str, output_path: str, framework: str = "fastapi", model_name: str = "model"
+) -> str:
+    """
+    Generate standalone API code.
+    
+    Args:
+        model_path: Path to saved model.
+        output_path: Output file path.
+        framework: 'fastapi' or 'flask'.
+        model_name: Name for the model.
+    
+    Returns:
+        Path to generated file.
+    """
+    if framework == "fastapi":
+        code = f'''"""Auto-generated FastAPI model serving code."""
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List
+import numpy as np
+import joblib
+
+app = FastAPI(title="{model_name} API")
+model = joblib.load("{model_path}")
+
+class PredictionInput(BaseModel):
+    features: List[List[float]]
+
+@app.get("/")
+def root():
+    return {{"message": "Welcome to {model_name} API"}}
+
+@app.get("/health")
+def health():
+    return {{"status": "healthy"}}
+
+@app.post("/predict")
+def predict(input_data: PredictionInput):
+    features = np.array(input_data.features)
+    predictions = model.predict(features).tolist()
+    return {{"predictions": predictions}}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+'''
+    else:
+        code = f'''"""Auto-generated Flask model serving code."""
+from flask import Flask, request, jsonify
+import numpy as np
+import joblib
+
+app = Flask(__name__)
+model = joblib.load("{model_path}")
+
+@app.route("/")
+def root():
+    return jsonify({{"message": "Welcome to {model_name} API"}})
+
+@app.route("/predict", methods=["POST"])
+def predict():
+    data = request.get_json()
+    features = np.array(data["features"])
+    predictions = model.predict(features).tolist()
+    return jsonify({{"predictions": predictions}})
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=8000)
+'''
+    
+    with open(output_path, 'w') as f:
+        f.write(code)
+    
+    logger.info(f"Generated API code at {output_path}")
+    return output_path

adamops/deployment/cloud.py

@@ -0,0 +1,191 @@
+"""
+AdamOps Cloud Deployment Module
+
+AWS, GCP, and Azure deployment helpers.
+"""
+
+from typing import Any, Dict, Optional
+from pathlib import Path
+
+from adamops.utils.logging import get_logger
+from adamops.utils.helpers import ensure_dir
+
+logger = get_logger(__name__)
+
+
+class CloudDeployer:
+    """Base class for cloud deployment."""
+    
+    def __init__(self, config: Optional[Dict] = None):
+        self.config = config or {}
+    
+    def deploy(self, model_path: str, name: str) -> Dict:
+        raise NotImplementedError
+
+
+class AWSDeployer(CloudDeployer):
+    """AWS SageMaker deployment."""
+    
+    def upload_to_s3(self, local_path: str, bucket: str, key: str) -> str:
+        """Upload file to S3."""
+        try:
+            import boto3
+        except ImportError:
+            raise ImportError("boto3 required. Install with: pip install boto3")
+        
+        s3 = boto3.client('s3')
+        s3.upload_file(local_path, bucket, key)
+        return f"s3://{bucket}/{key}"
+    
+    def deploy_sagemaker(
+        self, model_path: str, name: str,
+        instance_type: str = "ml.t2.medium",
+        role_arn: Optional[str] = None
+    ) -> Dict:
+        """Deploy to SageMaker endpoint."""
+        try:
+            import boto3
+            import sagemaker
+        except ImportError:
+            raise ImportError("boto3 and sagemaker required")
+        
+        logger.info(f"Deploying {name} to SageMaker...")
+        
+        # This is a simplified example - full implementation would need
+        # proper model packaging for SageMaker
+        return {
+            "status": "pending",
+            "message": "SageMaker deployment requires additional setup",
+            "model_path": model_path,
+            "endpoint_name": name,
+        }
+    
+    def generate_lambda_handler(self, output_path: str, model_s3_path: str) -> str:
+        """Generate AWS Lambda handler code."""
+        code = f'''"""AWS Lambda handler for model inference."""
+import json
+import boto3
+import joblib
+from io import BytesIO
+
+# Download model from S3 on cold start
+s3 = boto3.client('s3')
+bucket = "{model_s3_path.split('/')[2]}"
+key = "/".join("{model_s3_path}".split('/')[3:])
+
+response = s3.get_object(Bucket=bucket, Key=key)
+model = joblib.load(BytesIO(response['Body'].read()))
+
+def lambda_handler(event, context):
+    try:
+        body = json.loads(event.get('body', '{{}}'))
+        features = body.get('features', [])
+        
+        import numpy as np
+        predictions = model.predict(np.array(features)).tolist()
+        
+        return {{
+            'statusCode': 200,
+            'body': json.dumps({{'predictions': predictions}})
+        }}
+    except Exception as e:
+        return {{
+            'statusCode': 500,
+            'body': json.dumps({{'error': str(e)}})
+        }}
+'''
+        with open(output_path, 'w') as f:
+            f.write(code)
+        
+        return output_path
+
+
+class GCPDeployer(CloudDeployer):
+    """Google Cloud Platform deployment."""
+    
+    def upload_to_gcs(self, local_path: str, bucket: str, blob_name: str) -> str:
+        """Upload file to Google Cloud Storage."""
+        try:
+            from google.cloud import storage
+        except ImportError:
+            raise ImportError("google-cloud-storage required")
+        
+        client = storage.Client()
+        bucket_obj = client.bucket(bucket)
+        blob = bucket_obj.blob(blob_name)
+        blob.upload_from_filename(local_path)
+        
+        return f"gs://{bucket}/{blob_name}"
+    
+    def generate_cloud_run_config(self, output_dir: str, name: str, port: int = 8080) -> str:
+        """Generate Cloud Run configuration."""
+        config = f'''# Cloud Run service configuration
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+  args: ['build', '-t', 'gcr.io/$PROJECT_ID/{name}', '.']
+- name: 'gcr.io/cloud-builders/docker'
+  args: ['push', 'gcr.io/$PROJECT_ID/{name}']
+- name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
+  entrypoint: gcloud
+  args:
+  - 'run'
+  - 'deploy'
+  - '{name}'
+  - '--image'
+  - 'gcr.io/$PROJECT_ID/{name}'
+  - '--region'
+  - 'us-central1'
+  - '--platform'
+  - 'managed'
+  - '--port'
+  - '{port}'
+images:
+- 'gcr.io/$PROJECT_ID/{name}'
+'''
+        output_path = Path(output_dir) / "cloudbuild.yaml"
+        with open(output_path, 'w') as f:
+            f.write(config)
+        
+        return str(output_path)
+
+
+class AzureDeployer(CloudDeployer):
+    """Azure ML deployment."""
+    
+    def upload_to_blob(self, local_path: str, container: str, blob_name: str,
+                       connection_string: str) -> str:
+        """Upload file to Azure Blob Storage."""
+        try:
+            from azure.storage.blob import BlobServiceClient
+        except ImportError:
+            raise ImportError("azure-storage-blob required")
+        
+        blob_service = BlobServiceClient.from_connection_string(connection_string)
+        blob_client = blob_service.get_blob_client(container=container, blob=blob_name)
+        
+        with open(local_path, 'rb') as data:
+            blob_client.upload_blob(data, overwrite=True)
+        
+        return f"https://{blob_service.account_name}.blob.core.windows.net/{container}/{blob_name}"
+
+
+def get_deployer(cloud: str, config: Optional[Dict] = None) -> CloudDeployer:
+    """Get cloud deployer by name."""
+    deployers = {
+        "aws": AWSDeployer,
+        "gcp": GCPDeployer,
+        "azure": AzureDeployer,
+    }
+    
+    if cloud not in deployers:
+        raise ValueError(f"Unknown cloud: {cloud}. Available: {list(deployers.keys())}")
+    
+    return deployers[cloud](config)
+
+
+def deploy_to_cloud(
+    model_path: str, cloud: str, name: str, config: Optional[Dict] = None
+) -> Dict:
+    """Deploy model to cloud platform."""
+    deployer = get_deployer(cloud, config)
+    return deployer.deploy(model_path, name)

adamops/deployment/containerize.py

@@ -0,0 +1,262 @@
+"""
+AdamOps Containerization Module
+
+Docker and Kubernetes deployment support.
+"""
+
+from typing import Dict, List, Optional
+from pathlib import Path
+
+from adamops.utils.logging import get_logger
+from adamops.utils.helpers import ensure_dir
+
+logger = get_logger(__name__)
+
+
+DOCKERFILE_TEMPLATE = '''# Auto-generated Dockerfile for AdamOps model
+FROM python:{python_version}-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    gcc \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . .
+
+# Expose port
+EXPOSE {port}
+
+# Run application
+CMD ["python", "{entrypoint}"]
+'''
+
+REQUIREMENTS_TEMPLATE = '''# Auto-generated requirements for model serving
+numpy>=1.23.0
+pandas>=1.5.0
+scikit-learn>=1.2.0
+joblib>=1.2.0
+{framework_deps}
+'''
+
+K8S_DEPLOYMENT_TEMPLATE = '''apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {name}-deployment
+  labels:
+    app: {name}
+spec:
+  replicas: {replicas}
+  selector:
+    matchLabels:
+      app: {name}
+  template:
+    metadata:
+      labels:
+        app: {name}
+    spec:
+      containers:
+      - name: {name}
+        image: {image}
+        ports:
+        - containerPort: {port}
+        resources:
+          requests:
+            memory: "{memory}"
+            cpu: "{cpu}"
+          limits:
+            memory: "{memory_limit}"
+            cpu: "{cpu_limit}"
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: {name}-service
+spec:
+  selector:
+    app: {name}
+  ports:
+  - port: {port}
+    targetPort: {port}
+  type: {service_type}
+'''
+
+
+def generate_dockerfile(
+    output_dir: str, entrypoint: str = "app.py",
+    python_version: str = "3.10", port: int = 8000,
+    framework: str = "fastapi"
+) -> str:
+    """
+    Generate Dockerfile for model serving.
+    
+    Args:
+        output_dir: Output directory.
+        entrypoint: Python entrypoint file.
+        python_version: Python version.
+        port: Exposed port.
+        framework: 'fastapi' or 'flask'.
+    
+    Returns:
+        Path to Dockerfile.
+    """
+    output_dir = Path(output_dir)
+    ensure_dir(output_dir)
+    
+    dockerfile_content = DOCKERFILE_TEMPLATE.format(
+        python_version=python_version,
+        port=port,
+        entrypoint=entrypoint
+    )
+    
+    dockerfile_path = output_dir / "Dockerfile"
+    with open(dockerfile_path, "w") as f:
+        f.write(dockerfile_content)
+    
+    # Generate requirements
+    framework_deps = "fastapi>=0.100.0\nuvicorn>=0.22.0" if framework == "fastapi" else "flask>=2.3.0"
+    
+    requirements_content = REQUIREMENTS_TEMPLATE.format(framework_deps=framework_deps)
+    
+    requirements_path = output_dir / "requirements.txt"
+    with open(requirements_path, "w") as f:
+        f.write(requirements_content)
+    
+    logger.info(f"Generated Dockerfile at {dockerfile_path}")
+    return str(dockerfile_path)
+
+
+def generate_docker_compose(
+    output_dir: str, service_name: str = "model-api",
+    port: int = 8000, image: Optional[str] = None
+) -> str:
+    """Generate docker-compose.yml."""
+    output_dir = Path(output_dir)
+    ensure_dir(output_dir)
+    
+    content = f'''version: "3.8"
+
+services:
+  {service_name}:
+    build: .
+    ports:
+      - "{port}:{port}"
+    environment:
+      - PORT={port}
+    restart: unless-stopped
+'''
+    
+    if image:
+        content = content.replace("build: .", f"image: {image}")
+    
+    filepath = output_dir / "docker-compose.yml"
+    with open(filepath, "w") as f:
+        f.write(content)
+    
+    logger.info(f"Generated docker-compose.yml at {filepath}")
+    return str(filepath)
+
+
+def generate_k8s_manifests(
+    output_dir: str, name: str = "model-api",
+    image: str = "model-api:latest", port: int = 8000,
+    replicas: int = 2, memory: str = "512Mi", cpu: str = "250m",
+    service_type: str = "LoadBalancer"
+) -> str:
+    """
+    Generate Kubernetes deployment manifests.
+    
+    Args:
+        output_dir: Output directory.
+        name: Deployment name.
+        image: Docker image.
+        port: Container port.
+        replicas: Number of replicas.
+        memory: Memory request.
+        cpu: CPU request.
+        service_type: K8s service type.
+    
+    Returns:
+        Path to manifest file.
+    """
+    output_dir = Path(output_dir)
+    ensure_dir(output_dir)
+    
+    content = K8S_DEPLOYMENT_TEMPLATE.format(
+        name=name, image=image, port=port, replicas=replicas,
+        memory=memory, cpu=cpu, memory_limit=memory, cpu_limit=cpu,
+        service_type=service_type
+    )
+    
+    filepath = output_dir / "k8s-deployment.yaml"
+    with open(filepath, "w") as f:
+        f.write(content)
+    
+    logger.info(f"Generated K8s manifests at {filepath}")
+    return str(filepath)
+
+
+def build_docker_image(
+    context_dir: str, image_name: str, tag: str = "latest"
+) -> bool:
+    """Build Docker image (requires Docker CLI)."""
+    import subprocess
+    
+    full_tag = f"{image_name}:{tag}"
+    cmd = ["docker", "build", "-t", full_tag, context_dir]
+    
+    try:
+        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        logger.info(f"Built Docker image: {full_tag}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Docker build failed: {e.stderr}")
+        return False
+
+
+def containerize(
+    model_path: str, output_dir: str, name: str = "model-api",
+    framework: str = "fastapi", port: int = 8000, build: bool = False
+) -> Dict[str, str]:
+    """
+    Create complete containerization package.
+    
+    Returns:
+        Dict with paths to generated files.
+    """
+    from adamops.deployment.api import generate_api_code
+    
+    output_dir = Path(output_dir)
+    ensure_dir(output_dir)
+    
+    # Generate API code
+    api_path = generate_api_code(model_path, output_dir / "app.py", framework, name)
+    
+    # Copy model
+    import shutil
+    model_dest = output_dir / Path(model_path).name
+    shutil.copy(model_path, model_dest)
+    
+    # Generate Docker files
+    dockerfile = generate_dockerfile(output_dir, "app.py", port=port, framework=framework)
+    compose = generate_docker_compose(output_dir, name, port)
+    k8s = generate_k8s_manifests(output_dir, name, f"{name}:latest", port)
+    
+    result = {
+        "api": api_path,
+        "dockerfile": dockerfile,
+        "docker_compose": compose,
+        "k8s": k8s,
+        "model": str(model_dest),
+    }
+    
+    if build:
+        build_docker_image(str(output_dir), name)
+    
+    return result