morphml 1.0.0__py3-none-any.whl

morphml/__init__.py

@@ -0,0 +1,14 @@
+"""
+MorphML: Production-grade Neural Architecture Search
+
+A comprehensive framework for automated neural architecture search with
+distributed optimization, meta-learning, and multi-objective capabilities.
+
+Author: Eshan Roy <eshanized@proton.me>
+Organization: TONMOY INFRASTRUCTURE & VISION
+Repository: https://github.com/TIVerse/MorphML
+"""
+
+from morphml.version import __version__
+
+__all__ = ["__version__"]

morphml/api/__init__.py

@@ -0,0 +1,26 @@
+"""REST API for MorphML.
+
+Provides programmatic access to MorphML functionality via HTTP endpoints.
+
+Example:
+    # Start server
+    morphml api --port 8000
+
+    # Or programmatically
+    from morphml.api import create_app
+    app = create_app()
+"""
+
+from morphml.api.app import create_app
+from morphml.api.models import (
+    ArchitectureResponse,
+    ExperimentCreate,
+    ExperimentResponse,
+)
+
+__all__ = [
+    "create_app",
+    "ExperimentCreate",
+    "ExperimentResponse",
+    "ArchitectureResponse",
+]

morphml/api/app.py

@@ -0,0 +1,326 @@
+"""FastAPI application for MorphML REST API.
+
+This module provides the main FastAPI application with all endpoints.
+"""
+
+import uuid
+from datetime import datetime
+from typing import List, Optional
+
+try:
+    from fastapi import FastAPI, HTTPException, status
+    from fastapi.middleware.cors import CORSMiddleware
+
+    FASTAPI_AVAILABLE = True
+except ImportError:
+    FASTAPI_AVAILABLE = False
+    FastAPI = None
+
+from morphml.api.models import (
+    ArchitectureResponse,
+    ExperimentCreate,
+    ExperimentResponse,
+    HealthResponse,
+    OptimizerInfo,
+)
+from morphml.logging_config import get_logger
+from morphml.version import __version__
+
+logger = get_logger(__name__)
+
+# In-memory storage (replace with database in production)
+experiments_db = {}
+architectures_db = {}
+
+
+def create_app() -> FastAPI:
+    """
+    Create and configure FastAPI application.
+
+    Returns:
+        Configured FastAPI app
+
+    Example:
+        >>> app = create_app()
+        >>> # Run with: uvicorn morphml.api.app:app --reload
+    """
+    if not FASTAPI_AVAILABLE:
+        raise ImportError(
+            "FastAPI is required for the REST API. "
+            "Install with: pip install 'morphml[api]' or pip install fastapi uvicorn"
+        )
+
+    app = FastAPI(
+        title="MorphML API",
+        description="REST API for Neural Architecture Search with MorphML",
+        version=__version__,
+        docs_url="/docs",
+        redoc_url="/redoc",
+    )
+
+    # CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Configure appropriately for production
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Health check endpoint
+    @app.get("/health", response_model=HealthResponse, tags=["Health"])
+    async def health_check():
+        """Check API health status."""
+        return HealthResponse(status="healthy", version=__version__, timestamp=datetime.now())
+
+    # Experiment endpoints
+    @app.post(
+        "/api/v1/experiments",
+        response_model=ExperimentResponse,
+        status_code=status.HTTP_201_CREATED,
+        tags=["Experiments"],
+    )
+    async def create_experiment(experiment: ExperimentCreate):
+        """
+        Create a new NAS experiment.
+
+        Args:
+            experiment: Experiment configuration
+
+        Returns:
+            Created experiment details
+        """
+        experiment_id = f"exp_{uuid.uuid4().hex[:8]}"
+
+        exp_data = ExperimentResponse(
+            id=experiment_id,
+            name=experiment.name,
+            status="pending",
+            created_at=datetime.now(),
+            best_fitness=None,
+            generations_completed=0,
+            total_generations=experiment.optimizer_config.get("num_generations", 50),
+        )
+
+        experiments_db[experiment_id] = {"response": exp_data, "config": experiment.dict()}
+
+        logger.info(f"Created experiment: {experiment_id}")
+        return exp_data
+
+    @app.get("/api/v1/experiments", response_model=List[ExperimentResponse], tags=["Experiments"])
+    async def list_experiments(
+        status_filter: Optional[str] = None, limit: int = 100, offset: int = 0
+    ):
+        """
+        List all experiments.
+
+        Args:
+            status_filter: Filter by status (pending, running, completed, failed)
+            limit: Maximum number of results
+            offset: Offset for pagination
+
+        Returns:
+            List of experiments
+        """
+        experiments = [exp["response"] for exp in experiments_db.values()]
+
+        if status_filter:
+            experiments = [exp for exp in experiments if exp.status == status_filter]
+
+        return experiments[offset : offset + limit]
+
+    @app.get(
+        "/api/v1/experiments/{experiment_id}",
+        response_model=ExperimentResponse,
+        tags=["Experiments"],
+    )
+    async def get_experiment(experiment_id: str):
+        """
+        Get experiment details.
+
+        Args:
+            experiment_id: Experiment ID
+
+        Returns:
+            Experiment details
+        """
+        if experiment_id not in experiments_db:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Experiment {experiment_id} not found",
+            )
+
+        return experiments_db[experiment_id]["response"]
+
+    @app.post(
+        "/api/v1/experiments/{experiment_id}/start",
+        response_model=ExperimentResponse,
+        tags=["Experiments"],
+    )
+    async def start_experiment(experiment_id: str):
+        """
+        Start an experiment.
+
+        Args:
+            experiment_id: Experiment ID
+
+        Returns:
+            Updated experiment details
+        """
+        if experiment_id not in experiments_db:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Experiment {experiment_id} not found",
+            )
+
+        exp_data = experiments_db[experiment_id]["response"]
+        exp_data.status = "running"
+        exp_data.started_at = datetime.now()
+
+        logger.info(f"Started experiment: {experiment_id}")
+        return exp_data
+
+    @app.post(
+        "/api/v1/experiments/{experiment_id}/stop",
+        response_model=ExperimentResponse,
+        tags=["Experiments"],
+    )
+    async def stop_experiment(experiment_id: str):
+        """
+        Stop a running experiment.
+
+        Args:
+            experiment_id: Experiment ID
+
+        Returns:
+            Updated experiment details
+        """
+        if experiment_id not in experiments_db:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Experiment {experiment_id} not found",
+            )
+
+        exp_data = experiments_db[experiment_id]["response"]
+        if exp_data.status == "running":
+            exp_data.status = "stopped"
+            exp_data.completed_at = datetime.now()
+
+        logger.info(f"Stopped experiment: {experiment_id}")
+        return exp_data
+
+    @app.delete(
+        "/api/v1/experiments/{experiment_id}",
+        status_code=status.HTTP_204_NO_CONTENT,
+        tags=["Experiments"],
+    )
+    async def delete_experiment(experiment_id: str):
+        """
+        Delete an experiment.
+
+        Args:
+            experiment_id: Experiment ID
+        """
+        if experiment_id not in experiments_db:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Experiment {experiment_id} not found",
+            )
+
+        del experiments_db[experiment_id]
+        logger.info(f"Deleted experiment: {experiment_id}")
+
+    # Architecture endpoints
+    @app.get(
+        "/api/v1/architectures", response_model=List[ArchitectureResponse], tags=["Architectures"]
+    )
+    async def list_architectures(
+        experiment_id: Optional[str] = None, limit: int = 100, offset: int = 0
+    ):
+        """
+        List architectures.
+
+        Args:
+            experiment_id: Filter by experiment ID
+            limit: Maximum number of results
+            offset: Offset for pagination
+
+        Returns:
+            List of architectures
+        """
+        architectures = list(architectures_db.values())
+
+        if experiment_id:
+            architectures = [arch for arch in architectures if arch.experiment_id == experiment_id]
+
+        return architectures[offset : offset + limit]
+
+    @app.get(
+        "/api/v1/architectures/{architecture_id}",
+        response_model=ArchitectureResponse,
+        tags=["Architectures"],
+    )
+    async def get_architecture(architecture_id: str):
+        """
+        Get architecture details.
+
+        Args:
+            architecture_id: Architecture ID
+
+        Returns:
+            Architecture details
+        """
+        if architecture_id not in architectures_db:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Architecture {architecture_id} not found",
+            )
+
+        return architectures_db[architecture_id]
+
+    # Optimizer info endpoint
+    @app.get("/api/v1/optimizers", response_model=List[OptimizerInfo], tags=["Optimizers"])
+    async def list_optimizers():
+        """
+        List available optimizers.
+
+        Returns:
+            List of optimizer information
+        """
+        return [
+            OptimizerInfo(
+                name="GeneticAlgorithm",
+                type="evolutionary",
+                description="Genetic algorithm for neural architecture search",
+                parameters={
+                    "population_size": {"type": "int", "default": 20},
+                    "num_generations": {"type": "int", "default": 50},
+                    "mutation_rate": {"type": "float", "default": 0.2},
+                    "crossover_rate": {"type": "float", "default": 0.8},
+                },
+            ),
+            OptimizerInfo(
+                name="RandomSearch",
+                type="random",
+                description="Random search baseline",
+                parameters={
+                    "num_samples": {"type": "int", "default": 100},
+                },
+            ),
+            OptimizerInfo(
+                name="HillClimbing",
+                type="local_search",
+                description="Hill climbing local search",
+                parameters={
+                    "max_iterations": {"type": "int", "default": 100},
+                    "patience": {"type": "int", "default": 10},
+                },
+            ),
+        ]
+
+    logger.info("FastAPI application created")
+    return app
+
+
+# Create app instance for uvicorn
+app = create_app() if FASTAPI_AVAILABLE else None

morphml/api/auth.py

@@ -0,0 +1,193 @@
+"""Authentication utilities for MorphML API.
+
+Provides JWT-based authentication for the REST API.
+
+Example:
+    >>> from morphml.api.auth import create_access_token, verify_token
+    >>> token = create_access_token({"sub": "user@example.com"})
+    >>> payload = verify_token(token)
+"""
+
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional
+
+try:
+    from jose import JWTError, jwt
+    from passlib.context import CryptContext
+
+    JOSE_AVAILABLE = True
+except ImportError:
+    JOSE_AVAILABLE = False
+    jwt = None
+    CryptContext = None
+
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+# Configuration
+SECRET_KEY = "your-secret-key-change-in-production"  # Change this!
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+# Password hashing
+if JOSE_AVAILABLE:
+    pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+else:
+    pwd_context = None
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """
+    Verify a password against its hash.
+
+    Args:
+        plain_password: Plain text password
+        hashed_password: Hashed password
+
+    Returns:
+        True if password matches
+    """
+    if not JOSE_AVAILABLE:
+        raise ImportError("python-jose and passlib required for authentication")
+
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+    """
+    Hash a password.
+
+    Args:
+        password: Plain text password
+
+    Returns:
+        Hashed password
+    """
+    if not JOSE_AVAILABLE:
+        raise ImportError("python-jose and passlib required for authentication")
+
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
+    """
+    Create JWT access token.
+
+    Args:
+        data: Data to encode in token
+        expires_delta: Optional expiration time
+
+    Returns:
+        JWT token string
+
+    Example:
+        >>> token = create_access_token({"sub": "user@example.com"})
+    """
+    if not JOSE_AVAILABLE:
+        raise ImportError("python-jose required for authentication")
+
+    to_encode = data.copy()
+
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+
+    to_encode.update({"exp": expire})
+
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+    return encoded_jwt
+
+
+def verify_token(token: str) -> Optional[Dict[str, Any]]:
+    """
+    Verify and decode JWT token.
+
+    Args:
+        token: JWT token string
+
+    Returns:
+        Decoded payload or None if invalid
+
+    Example:
+        >>> payload = verify_token(token)
+        >>> if payload:
+        ...     user_email = payload.get("sub")
+    """
+    if not JOSE_AVAILABLE:
+        raise ImportError("python-jose required for authentication")
+
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        return payload
+    except JWTError as e:
+        logger.warning(f"Token verification failed: {e}")
+        return None
+
+
+# Simple in-memory user store (replace with database in production)
+fake_users_db = {
+    "admin@morphml.com": {
+        "username": "admin@morphml.com",
+        "full_name": "Admin User",
+        "email": "admin@morphml.com",
+        "hashed_password": "$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW",  # "secret"
+        "disabled": False,
+    }
+}
+
+
+def authenticate_user(username: str, password: str) -> Optional[Dict[str, Any]]:
+    """
+    Authenticate user with username and password.
+
+    Args:
+        username: Username (email)
+        password: Plain text password
+
+    Returns:
+        User dict if authenticated, None otherwise
+    """
+    user = fake_users_db.get(username)
+
+    if not user:
+        return None
+
+    if not verify_password(password, user["hashed_password"]):
+        return None
+
+    return user
+
+
+def create_user(username: str, password: str, full_name: str = "") -> Dict[str, Any]:
+    """
+    Create a new user.
+
+    Args:
+        username: Username (email)
+        password: Plain text password
+        full_name: Full name
+
+    Returns:
+        Created user dict
+    """
+    if username in fake_users_db:
+        raise ValueError(f"User {username} already exists")
+
+    hashed_password = get_password_hash(password)
+
+    user = {
+        "username": username,
+        "full_name": full_name,
+        "email": username,
+        "hashed_password": hashed_password,
+        "disabled": False,
+    }
+
+    fake_users_db[username] = user
+
+    logger.info(f"Created user: {username}")
+
+    return user