octopize.deploy_tool 2.4.0__tar.gz → 2.7.0__tar.gz

{octopize_deploy_tool-2.4.0 → octopize_deploy_tool-2.7.0}/.gitignore

@@ -67,6 +67,9 @@ Thumbs.db
 .avatar-templates
 .deployment_state.yaml
 .env
-!tests/fixtures/**/expected/.env
+!tests/fixtures/**/.env
 config.*.yaml
 !config.example.yaml
+.deployment_states/*
+# TLS test fixtures created dynamically by the test suite
+tls/

{octopize_deploy_tool-2.4.0 → octopize_deploy_tool-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: octopize.deploy_tool
-Version: 2.4.0
+Version: 2.7.0
 Summary: Deployment configuration tool for Octopize Avatar platform
 Project-URL: Homepage, https://octopize.io
 Project-URL: Documentation, https://docs.octopize.io/docs/deploying/self-hosted
@@ -21,12 +21,9 @@ Requires-Python: >=3.13
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: pandas>=3.0.0
+Requires-Dist: python-on-whales>=0.76.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0.0
-Provides-Extra: dev
-Requires-Dist: pyright>=1.1.402; extra == 'dev'
-Requires-Dist: pytest>=7.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Octopize Avatar Deployment Tool

octopize_deploy_tool-2.7.0/infra/deployment/deployment-tool/src/octopize_avatar_deploy/steps/user.py

@@ -0,0 +1,20 @@
+"""User authentication configuration step."""
+
+from typing import Any
+
+from .base import DeploymentStep
+
+
+class UserStep(DeploymentStep):
+    """Handles user authentication configuration."""
+
+    name = "user"
+    description = "Configure user authentication settings"
+
+    def collect_config(self) -> dict[str, Any]:
+        """Collect user authentication configuration."""
+        return {}
+
+    def generate_secrets(self) -> dict[str, str]:
+        """Generate user-related secrets."""
+        return {}

{octopize_deploy_tool-2.4.0 → octopize_deploy_tool-2.7.0}/pyproject.toml

@@ -4,14 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "octopize.deploy_tool"
-version = "2.4.0"
+version = "2.7.0"
 description = "Deployment configuration tool for Octopize Avatar platform"
 readme = "README.md"
 requires-python = ">=3.13"
 license = { text = "MIT" }
-authors = [
-    { name = "Octopize", email = "contact@octopize.io" }
-]
+authors = [{ name = "Octopize", email = "contact@octopize.io" }]
 keywords = ["octopize", "avatar", "deployment", "configuration"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -30,13 +28,18 @@ dependencies = [
     "rich>=13.0.0",
     "httpx>=0.28.0",
     "pandas>=3.0.0",
+    "python-on-whales>=0.76.0",
 ]
 
-[project.optional-dependencies]
+[dependency-groups]
 dev = [
-    "pytest>=7.0",
+    "pytest>=9",
+    "mypy>=1.20.0",
     "pyright>=1.1.402",
-    "ruff>=0.1.0",
+    "types-pyyaml>=6.0.12.20241230",
+    "pandas-stubs>=3.0.0",
+    "pytest-httpx>=0.36.0",
+    "pytest-cov>=7.1.0",
 ]
 
 [project.scripts]
@@ -55,36 +58,30 @@ packages = ["src/octopize_avatar_deploy"]
 "src" = ""
 
 [tool.hatch.build.targets.sdist]
-include = [
-    "src/",
-    "tests/",
-    "README.md",
-    "pyproject.toml",
-]
+include = ["src/", "tests/", "README.md", "pyproject.toml"]
 
 [tool.pytest.ini_options]
 # Test discovery
-testpaths = ["tests"]
-python_files = ["test_*.py"]
-python_classes = ["Test*"]
-python_functions = ["test_*"]
+testpaths = "tests"
+filterwarnings = ["error"]
+# Recommended by pytest
+pythonpath = "src"
 
 # Output options
 addopts = [
-    "-v",                          # Verbose output
-    "--strict-markers",            # Error on unknown markers
-    "--tb=short",                  # Short traceback format
-    "--color=yes",                 # Colored output
-    "-ra",                         # Show summary of all test results
+    # Recommended by pytest
+    # https://docs.pytest.org/en/stable/explanation/goodpractices.html#tests-outside-application-code
+
+    "--import-mode=importlib",
+    "--strict-markers",        # Error on unknown markers
+    "--tb=short",              # Short traceback format
+    "--color=yes",             # Colored output
+    "-ra",                     # Show summary of all test results
 ]
 
 [tool.coverage.run]
 source = ["src/octopize_avatar_deploy"]
-omit = [
-    "*/tests/*",
-    "*/__pycache__/*",
-    "*/.venv/*",
-]
+omit = ["*/tests/*", "*/__pycache__/*", "*/.venv/*"]
 
 [tool.coverage.report]
 exclude_lines = [
@@ -98,32 +95,7 @@ exclude_lines = [
 ]
 
 [tool.ruff]
-target-version = "py313"
-line-length = 100
-
-[tool.ruff.lint]
-extend-select = [
-    "E",   # pycodestyle errors
-    "W",   # pycodestyle warnings
-    "F",   # pyflakes
-    "I",   # isort
-    "B",   # flake8-bugbear
-    "C4",  # flake8-comprehensions
-    "UP",  # pyupgrade
-]
-
-
-[tool.ruff.lint.isort]
-known-first-party = ["octopize_avatar_deploy"]
-
-[dependency-groups]
-dev = [
-    "mypy>=1.20.0",
-    "pyright>=1.1.402",
-    "types-pyyaml>=6.0.12.20241230",
-    "pandas-stubs>=3.0.0",
-    "pytest-httpx>=0.36.0",
-]
+extend = "../../../ruff.toml"
 
 [tool.pyright]
 include = ["src/octopize_avatar_deploy"]

{octopize_deploy_tool-2.4.0 → octopize_deploy_tool-2.7.0}/src/octopize_avatar_deploy/__init__.py

@@ -1,6 +1,5 @@
 """Octopize Avatar Deployment Tool."""
 
-from .cli import main
 from .configure import DeploymentConfigurator, DeploymentRunner
 from .printer import ConsolePrinter, Printer, SilentPrinter
 from .version_compat import (
@@ -11,9 +10,8 @@ from .version_compat import (
     validate_template_version,
 )
 
-__version__ = "2.4.0"
+__version__ = "2.7.0"
 __all__ = [
-    "main",
     "DeploymentRunner",
     "DeploymentConfigurator",
     "Printer",

octopize_deploy_tool-2.7.0/src/octopize_avatar_deploy/application/__init__.py

@@ -0,0 +1 @@
+"""Application sub-package for deployment tool refactor (Phase 1)."""

octopize_deploy_tool-2.7.0/src/octopize_avatar_deploy/application/apply_command.py

@@ -0,0 +1,137 @@
+"""ApplyCommand: the Phase 1 application entry point for the apply sub-command.
+
+``apply`` copies a fully rendered ``generated/`` directory from a versioned
+state slot into ``generated_files/`` (the directory consumed by Docker Compose)
+and updates the ``currently_deployed`` symlink so the active version is always
+traceable.
+
+The operation is idempotent: applying the same version twice produces the same
+``generated_files/`` content and symlink target.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from octopize_avatar_deploy.application.deployment_paths import DeploymentPaths
+from octopize_avatar_deploy.application.ports import DirectoryCopier, SymlinkUpdater
+from octopize_avatar_deploy.domain.version_id import VersionId
+
+
+class ApplyError(Exception):
+    """Raised when apply fails due to an operator-fixable problem.
+
+    Covers missing ``--version`` argument, references to versions whose
+    ``generated/`` directory does not yet exist (i.e. ``render`` was never run
+    for that version), or any filesystem error that maps to an operator action.
+
+    Distinct from plain ``ValueError`` or ``FileNotFoundError``, which indicate
+    programming-contract violations (bugs in the tool) and should surface with a
+    full traceback.
+    """
+
+
+@dataclass
+class ApplyCommandArgs:
+    """Arguments for the apply command.
+
+    ``version`` must be provided (e.g. ``"v1"``).
+    """
+
+    app_root: Path
+    version: str  # explicit version label, e.g. "v1"
+
+
+@dataclass
+class ApplyCommandResult:
+    """Result returned by :meth:`ApplyCommand.run`."""
+
+    version: VersionId
+    output_dir: Path
+    symlink_target: Path
+
+
+class ApplyCommand:
+    """Orchestrate the apply use case.
+
+    Copies ``.deployment_states/vX/generated/`` into ``generated_files/`` and
+    updates the ``currently_deployed`` symlink.
+
+    All side effects (directory copy and symlink update) are injected as ports
+    so the full use case can be exercised in tests with in-memory doubles.
+
+    Args:
+        directory_copier: Port that performs the full recursive copy from the
+            versioned ``generated/`` directory to ``generated_files/``.
+        symlink_updater: Port that creates or replaces the
+            ``currently_deployed`` symlink.
+    """
+
+    def __init__(
+        self,
+        *,
+        directory_copier: DirectoryCopier,
+        symlink_updater: SymlinkUpdater,
+    ) -> None:
+        self._directory_copier = directory_copier
+        self._symlink_updater = symlink_updater
+
+    def run(self, args: ApplyCommandArgs) -> ApplyCommandResult:
+        """Execute the apply use case end-to-end.
+
+        Flow:
+
+        1. Validate argument combinations.
+        2. Parse the target version label.
+        3. Confirm that ``render`` has been run for this version (the
+           ``generated/`` directory exists).
+        4. Copy ``.deployment_states/vX/generated/`` → ``generated_files/``
+           (full recursive copy — not a symlink — so operator edits in
+           ``generated_files/`` never affect the versioned reference).
+        5. Update ``.deployment_states/currently_deployed`` symlink → ``vX``.
+        6. Return a result.
+
+        Args:
+            args: Apply command arguments.
+
+        Returns:
+            :class:`ApplyCommandResult` with the resolved version, the
+            ``generated_files/`` output directory, and the symlink target path.
+
+        Raises:
+            ApplyError: For any operator-fixable problem: a version whose
+                ``generated/`` directory does not exist, or a missing version
+                argument.
+        """
+        try:
+            return self._run(args)
+        except ApplyError:
+            raise
+        except (ValueError, FileNotFoundError) as exc:
+            raise ApplyError(str(exc)) from exc
+
+    def _run(self, args: ApplyCommandArgs) -> ApplyCommandResult:
+        """Internal implementation called by :meth:`run`."""
+        # 1. Parse version.
+        version = VersionId.parse(args.version)
+        paths = DeploymentPaths(app_root=args.app_root, version=version)
+
+        # 2. Verify that render has been run (generated/ must exist).
+        if not self._directory_copier.source_exists(paths.generated_dir):
+            raise ApplyError(
+                f"Version {version.label!r} has not been rendered yet. "
+                f"Run 'render --version {version.label}' first."
+            )
+
+        # 3. Copy generated/ → generated_files/.
+        self._directory_copier.copy(paths.generated_dir, paths.generated_files_dir)
+
+        # 4. Update currently_deployed symlink.
+        self._symlink_updater.update(paths.currently_deployed_symlink, paths.version_dir)
+
+        return ApplyCommandResult(
+            version=version,
+            output_dir=paths.generated_files_dir,
+            symlink_target=paths.version_dir,
+        )