aissemble-inference-deploy 1.5.0rc3__py3-none-any.whl

aissemble_inference_deploy/generators/base.py

@@ -0,0 +1,239 @@
+###
+# #%L
+# aiSSEMBLE::Open Inference Protocol::Deploy
+# %%
+# Copyright (C) 2024 Booz Allen Hamilton Inc.
+# %%
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# #L%
+###
+"""
+Base generator class for deployment config generation.
+"""
+
+import json
+import sys
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, PackageLoader, TemplateNotFound, select_autoescape
+
+
+@dataclass
+class ModelInfo:
+    """Information about a model discovered in the project."""
+
+    name: str
+    path: Path
+    settings: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def runtime(self) -> str | None:
+        """Get the runtime implementation class."""
+        return self.settings.get("implementation")
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        """Get model parameters."""
+        return self.settings.get("parameters", {})
+
+
+class Generator(ABC):
+    """Abstract base class for deployment config generators."""
+
+    # Name used in CLI (e.g., 'local', 'docker', 'kubernetes')
+    name: str = ""
+
+    def __init__(self, project_dir: Path, output_dir: Path | None = None):
+        """
+        Initialize the generator.
+
+        Args:
+            project_dir: Root directory of the user's project
+            output_dir: Where to write generated configs (default: project_dir/deploy)
+        """
+        self.project_dir = project_dir.resolve()
+        self.output_dir = (output_dir or project_dir / "deploy").resolve()
+        self.jinja_env = Environment(
+            loader=PackageLoader("aissemble_inference_deploy", "templates"),
+            autoescape=select_autoescape(),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def get_image_name(self) -> str:
+        """
+        Get the Docker image name for this project.
+
+        Derives the image name from the project directory name,
+        ensuring consistency between Docker and Kubernetes deployments.
+
+        Returns:
+            Image name (e.g., 'aissemble-summarization-example')
+        """
+        return self.project_dir.name
+
+    def detect_models(
+        self, models_dir: Path | None = None, max_depth: int = 5
+    ) -> list[ModelInfo]:
+        """
+        Discover models in the project.
+
+        Args:
+            models_dir: Directory to search for models (default: project_dir/models)
+            max_depth: Maximum directory depth to search (prevents resource exhaustion)
+
+        Returns:
+            List of discovered ModelInfo objects
+        """
+        models_dir = models_dir or self.project_dir / "models"
+        models = []
+
+        if not models_dir.exists():
+            return models
+
+        # Use rglob with depth check to prevent abuse
+        for model_settings_path in models_dir.rglob("model-settings.json"):
+            # Check depth relative to models_dir
+            try:
+                rel_path = model_settings_path.relative_to(models_dir)
+                if len(rel_path.parts) > max_depth + 1:  # +1 for the file itself
+                    continue
+            except ValueError:
+                # Path is outside models_dir somehow, skip it
+                continue
+
+            model_dir = model_settings_path.parent
+            model_name = model_dir.name
+
+            # Skip the root models directory if it has a settings.json
+            if model_dir == models_dir:
+                continue
+
+            try:
+                settings_text = model_settings_path.read_text(encoding="utf-8")
+                settings = json.loads(settings_text)
+            except json.JSONDecodeError as e:
+                print(
+                    f"Warning: Invalid JSON in {model_settings_path}: {e}",
+                    file=sys.stderr,
+                )
+                settings = {}
+            except OSError as e:
+                print(
+                    f"Warning: Cannot read {model_settings_path}: {e}",
+                    file=sys.stderr,
+                )
+                settings = {}
+
+            models.append(
+                ModelInfo(
+                    name=model_name,
+                    path=model_dir,
+                    settings=settings,
+                )
+            )
+
+        return models
+
+    @abstractmethod
+    def generate(self, models: list[ModelInfo] | None = None) -> list[Path]:
+        """
+        Generate deployment configs.
+
+        Args:
+            models: Models to generate configs for (auto-detected if None)
+
+        Returns:
+            List of paths to generated files
+        """
+        pass
+
+    def render_template(self, template_name: str, context: dict[str, Any]) -> str:
+        """
+        Render a Jinja2 template with the given context.
+
+        Args:
+            template_name: Name of the template file
+            context: Template variables
+
+        Returns:
+            Rendered template content
+
+        Raises:
+            TemplateNotFound: If template doesn't exist
+        """
+        try:
+            template = self.jinja_env.get_template(template_name)
+            return template.render(**context)
+        except TemplateNotFound:
+            raise TemplateNotFound(
+                f"Template '{template_name}' not found. Check that the generator has the correct templates."
+            )
+
+    def write_file(self, path: Path, content: str, executable: bool = False) -> Path:
+        """
+        Write content to a file, creating directories as needed.
+
+        Args:
+            path: Path to write to (must be within output_dir)
+            content: Content to write
+            executable: Whether to make the file executable
+
+        Returns:
+            The path that was written to
+
+        Raises:
+            ValueError: If path is outside output_dir (path traversal protection)
+        """
+        # Ensure path is within output_dir (prevent path traversal attacks)
+        try:
+            resolved_path = path.resolve()
+            resolved_output = self.output_dir.resolve()
+            resolved_path.relative_to(resolved_output)
+        except ValueError:
+            raise ValueError(
+                f"Cannot write file outside output directory. "
+                f"Attempted: {path}, Output dir: {self.output_dir}"
+            )
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+        if executable:
+            path.chmod(0o755)
+        return path
+
+    def extract_runtime_packages(self, models: list[ModelInfo]) -> list[str]:
+        """
+        Extract PyPI package names from model runtime implementations.
+
+        Args:
+            models: List of models to extract packages from
+
+        Returns:
+            List of PyPI package specifiers (e.g., ["aissemble-inference-sumy>=1.0"])
+        """
+        packages = set()
+        packages.add("mlserver>=1.6.0")
+
+        for model in models:
+            if model.runtime and "." in model.runtime:
+                # Extract package name from "aissemble_inference_sumy.SumyRuntime"
+                module_name = model.runtime.split(".")[0]
+                # Convert underscores to hyphens for PyPI package names
+                package_name = module_name.replace("_", "-")
+                packages.add(package_name)
+
+        return sorted(packages)

aissemble_inference_deploy/generators/docker.py

@@ -0,0 +1,307 @@
+###
+# #%L
+# aiSSEMBLE::Open Inference Protocol::Deploy
+# %%
+# Copyright (C) 2024 Booz Allen Hamilton Inc.
+# %%
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# #L%
+###
+"""
+Docker deployment generator.
+
+Generates Dockerfile and docker-compose.yml for containerized MLServer deployment.
+
+For dev versions: Uses uv-monorepo-dependency-tool to build wheels with pinned
+dependencies, including all transitive local path dependencies.
+
+For release versions: Generates requirements.txt to install from PyPI.
+"""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import tomlkit
+
+from .base import Generator, ModelInfo
+
+
+class DockerGenerator(Generator):
+    """Generator for Docker deployment configurations."""
+
+    name = "docker"
+
+    def generate(self, models: list[ModelInfo] | None = None) -> list[Path]:
+        """
+        Generate Docker deployment configs.
+
+        Args:
+            models: Models to generate configs for (auto-detected if None)
+
+        Returns:
+            List of paths to generated files
+        """
+        if models is None:
+            models = self.detect_models()
+
+        generated_files = []
+        target_dir = self.output_dir / "docker"
+
+        # Extract runtime packages for documentation and requirements
+        runtime_packages = self.extract_runtime_packages(models)
+
+        # Check if this is a dev version
+        is_dev = self._is_dev_version()
+
+        if is_dev:
+            # Build wheels for local testing
+            wheels_dir = target_dir / "wheels"
+            wheel_files = self._build_all_wheels(wheels_dir)
+            generated_files.extend(wheel_files)
+            use_wheels = True
+        else:
+            # Generate requirements.txt for PyPI install
+            requirements_content = "\n".join(runtime_packages) + "\n"
+            requirements_path = self.write_file(
+                target_dir / "requirements.txt", requirements_content
+            )
+            generated_files.append(requirements_path)
+            use_wheels = False
+
+        # Generate Dockerfile
+        dockerfile_content = self.render_template(
+            "docker/Dockerfile.j2",
+            {
+                "python_version": "3.11",
+                "use_wheels": use_wheels,
+            },
+        )
+        dockerfile_path = self.write_file(target_dir / "Dockerfile", dockerfile_content)
+        generated_files.append(dockerfile_path)
+
+        # Generate docker-compose.yml
+        image_name = self.get_image_name()
+        compose_content = self.render_template(
+            "docker/docker-compose.yml.j2",
+            {
+                "image_name": image_name,
+                "http_port": 8080,
+                "grpc_port": 8081,
+                "models": models,
+            },
+        )
+        compose_path = self.write_file(
+            target_dir / "docker-compose.yml", compose_content
+        )
+        generated_files.append(compose_path)
+
+        # Generate .dockerignore
+        dockerignore_content = self.render_template(
+            "docker/.dockerignore.j2",
+            {},
+        )
+        dockerignore_path = self.write_file(
+            target_dir / ".dockerignore", dockerignore_content
+        )
+        generated_files.append(dockerignore_path)
+
+        # Generate README
+        readme_content = self.render_template(
+            "docker/README.md.j2",
+            {
+                "models": models,
+                "runtime_packages": runtime_packages,
+                "http_port": 8080,
+                "grpc_port": 8081,
+                "use_wheels": use_wheels,
+            },
+        )
+        readme_path = self.write_file(target_dir / "README.md", readme_content)
+        generated_files.append(readme_path)
+
+        return generated_files
+
+    def _is_dev_version(self) -> bool:
+        """
+        Check if the project version is a dev version.
+
+        Returns:
+            True if version contains '.dev', False otherwise
+        """
+        pyproject_path = self.project_dir / "pyproject.toml"
+        if not pyproject_path.exists():
+            return False
+
+        content = pyproject_path.read_text(encoding="utf-8")
+        doc = tomlkit.parse(content)
+
+        version = doc.get("project", {}).get("version", "")
+        return ".dev" in version
+
+    def _build_all_wheels(self, wheels_dir: Path) -> list[Path]:
+        """
+        Build wheels for this project and all local path dependencies.
+
+        Recursively finds and builds all monorepo packages that this project
+        depends on, ensuring Docker has all required wheels.
+
+        Args:
+            wheels_dir: Directory to copy built wheels to
+
+        Returns:
+            List of paths to copied wheel files
+        """
+        if shutil.which("uv") is None:
+            raise RuntimeError(
+                "uv is not installed or not in PATH. "
+                "Install uv: https://docs.astral.sh/uv/getting-started/installation/"
+            )
+
+        wheels_dir.mkdir(parents=True, exist_ok=True)
+
+        # Find all projects to build (this project + path dependencies)
+        projects_to_build = self._find_all_path_dependencies(self.project_dir)
+
+        print(
+            f"  Building wheels for {len(projects_to_build)} project(s) (dev mode)...",
+            file=sys.stderr,
+        )
+
+        copied_wheels = []
+        for project_path in projects_to_build:
+            wheel_path = self._build_single_wheel(project_path, wheels_dir)
+            if wheel_path:
+                copied_wheels.append(wheel_path)
+
+        if not copied_wheels:
+            raise RuntimeError(
+                "No wheel files were built. "
+                "Check that uv-monorepo-dependency-tool completed successfully."
+            )
+
+        print(f"  Built {len(copied_wheels)} wheel(s) to {wheels_dir}", file=sys.stderr)
+        return copied_wheels
+
+    def _find_all_path_dependencies(self, start_dir: Path) -> list[Path]:
+        """
+        Recursively find all local path dependencies.
+
+        Args:
+            start_dir: Starting project directory
+
+        Returns:
+            List of project directories to build (including start_dir)
+        """
+        visited = set()
+        to_visit = [start_dir.resolve()]
+        result = []
+
+        while to_visit:
+            current = to_visit.pop(0)
+            if current in visited:
+                continue
+            visited.add(current)
+            result.append(current)
+
+            # Find path dependencies in this project
+            path_deps = self._get_path_dependencies(current)
+            for dep_path in path_deps:
+                resolved = (current / dep_path).resolve()
+                if resolved.exists() and resolved not in visited:
+                    to_visit.append(resolved)
+
+        return result
+
+    def _get_path_dependencies(self, project_dir: Path) -> list[str]:
+        """
+        Extract path dependencies from a project's pyproject.toml.
+
+        Args:
+            project_dir: Project directory containing pyproject.toml
+
+        Returns:
+            List of relative path strings to dependencies
+        """
+        pyproject_path = project_dir / "pyproject.toml"
+        if not pyproject_path.exists():
+            return []
+
+        content = pyproject_path.read_text(encoding="utf-8")
+        doc = tomlkit.parse(content)
+
+        # Look for [tool.uv.sources] section
+        sources = doc.get("tool", {}).get("uv", {}).get("sources", {})
+
+        paths = []
+        for _name, source in sources.items():
+            if isinstance(source, dict) and "path" in source:
+                paths.append(source["path"])
+
+        return paths
+
+    def _build_single_wheel(self, project_dir: Path, wheels_dir: Path) -> Path | None:
+        """
+        Build a wheel for a single project using uv-monorepo-dependency-tool.
+
+        Args:
+            project_dir: Project directory to build
+            wheels_dir: Directory to copy the wheel to
+
+        Returns:
+            Path to the copied wheel file, or None if build failed
+        """
+        project_name = project_dir.name
+        print(f"    Building {project_name}...", file=sys.stderr)
+
+        result = subprocess.run(
+            [
+                "uv",
+                "tool",
+                "run",
+                "uv-monorepo-dependency-tool",
+                "build-rewrite-path-deps",
+                "--version-pinning-strategy=mixed",
+            ],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            print(
+                f"    Warning: Failed to build {project_name}: {result.stderr}",
+                file=sys.stderr,
+            )
+            return None
+
+        # Find and copy the built wheel
+        dist_dir = project_dir / "dist"
+        if not dist_dir.exists():
+            print(
+                f"    Warning: No dist/ directory for {project_name}", file=sys.stderr
+            )
+            return None
+
+        # Get the most recent wheel
+        wheels = sorted(dist_dir.glob("*.whl"), key=lambda p: p.stat().st_mtime)
+        if not wheels:
+            print(f"    Warning: No wheel found for {project_name}", file=sys.stderr)
+            return None
+
+        wheel_file = wheels[-1]  # Most recent
+        dest_path = wheels_dir / wheel_file.name
+        shutil.copy2(wheel_file, dest_path)
+        print(f"      Copied {wheel_file.name}", file=sys.stderr)
+        return dest_path

aissemble_inference_deploy/generators/kserve.py

@@ -0,0 +1,89 @@
+###
+# #%L
+# aiSSEMBLE::Open Inference Protocol::Deploy
+# %%
+# Copyright (C) 2024 Booz Allen Hamilton Inc.
+# %%
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# #L%
+###
+"""
+KServe deployment generator.
+
+Generates KServe InferenceService configurations for deploying MLServer-based models.
+Produces a ServingRuntime (shared runtime configuration) and InferenceService
+(model deployment) following the DRY principle.
+"""
+
+from pathlib import Path
+
+from .base import Generator, ModelInfo
+
+
+class KServeGenerator(Generator):
+    """Generator for KServe InferenceService deployments."""
+
+    name = "kserve"
+
+    def generate(self, models: list[ModelInfo] | None = None) -> list[Path]:
+        """
+        Generate KServe deployment configs (ServingRuntime + InferenceService).
+
+        Args:
+            models: Models to generate configs for (auto-detected if None)
+
+        Returns:
+            List of paths to generated files
+        """
+        if models is None:
+            models = self.detect_models()
+
+        generated_files = []
+        target_dir = self.output_dir / "kserve"
+
+        # Extract runtime packages for documentation
+        runtime_packages = self.extract_runtime_packages(models)
+
+        # Get image name (consistent with Docker generator)
+        image_name = self.get_image_name()
+
+        # Common template context
+        context = {
+            "models": models,
+            "runtime_packages": runtime_packages,
+            "image_name": image_name,
+            "app_name": image_name,
+            "http_port": 8080,
+            "grpc_port": 8081,
+        }
+
+        # Generate ServingRuntime (shared runtime configuration)
+        runtime_content = self.render_template(
+            "kserve/serving-runtime.yaml.j2", context
+        )
+        runtime_path = self.write_file(
+            target_dir / "serving-runtime.yaml", runtime_content
+        )
+        generated_files.append(runtime_path)
+
+        # Generate InferenceService (references the ServingRuntime)
+        isvc_content = self.render_template("kserve/inference-service.yaml.j2", context)
+        isvc_path = self.write_file(target_dir / "inference-service.yaml", isvc_content)
+        generated_files.append(isvc_path)
+
+        # Generate README
+        readme_content = self.render_template("kserve/README.md.j2", context)
+        readme_path = self.write_file(target_dir / "README.md", readme_content)
+        generated_files.append(readme_path)
+
+        return generated_files