octopize.deploy_tool 2.3.1__tar.gz → 2.6.0__tar.gz

{octopize_deploy_tool-2.3.1 → octopize_deploy_tool-2.6.0}/.gitignore

@@ -70,3 +70,6 @@ Thumbs.db
 !tests/fixtures/**/expected/.env
 config.*.yaml
 !config.example.yaml
+
+# TLS test fixtures created dynamically by the test suite
+tls/

{octopize_deploy_tool-2.3.1 → octopize_deploy_tool-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: octopize.deploy_tool
-Version: 2.3.1
+Version: 2.6.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
@@ -26,7 +26,6 @@ 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.6.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.3.1 → octopize_deploy_tool-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "octopize.deploy_tool"
-version = "2.3.1"
+version = "2.6.0"
 description = "Deployment configuration tool for Octopize Avatar platform"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -36,7 +36,6 @@ dependencies = [
 dev = [
     "pytest>=7.0",
     "pyright>=1.1.402",
-    "ruff>=0.1.0",
 ]
 
 [project.scripts]
@@ -98,23 +97,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"]
+extend = "../../../ruff.toml"
 
 [dependency-groups]
 dev = [

{octopize_deploy_tool-2.3.1 → octopize_deploy_tool-2.6.0}/src/octopize_avatar_deploy/__init__.py

@@ -11,7 +11,7 @@ from .version_compat import (
     validate_template_version,
 )
 
-__version__ = "2.3.1"
+__version__ = "2.6.0"
 __all__ = [
     "main",
     "DeploymentRunner",

{octopize_deploy_tool-2.3.1 → octopize_deploy_tool-2.6.0}/src/octopize_avatar_deploy/authentik_migration.py

@@ -327,7 +327,7 @@ class AuthentikClient:
                 timestamp = datetime.now(UTC).isoformat()
                 try:
                     if dry_run:
-                        print(f"[DRY RUN] {op}")
+                        print(f"[DRY RUN] {op}")  # noqa: T201
                         continue
 
                     if op.op_type == OperationType.GROUP_CREATE:
@@ -336,7 +336,7 @@ class AuthentikClient:
                             attributes=op.data["attributes"],
                         )
                         counts["groups_created"] += 1
-                        print(f"✓ Created group: {op.data['name']}")
+                        print(f"✓ Created group: {op.data['name']}")  # noqa: T201
 
                     elif op.op_type == OperationType.USER_CREATE:
                         self.create_user(
@@ -346,7 +346,7 @@ class AuthentikClient:
                             attributes=op.data["attributes"],
                         )
                         counts["users_created"] += 1
-                        print(f"✓ Created user: {op.data['username']}")
+                        print(f"✓ Created user: {op.data['username']}")  # noqa: T201
 
                     elif op.op_type == OperationType.GROUP_ASSIGN:
                         self.assign_user_to_group(
@@ -354,7 +354,7 @@ class AuthentikClient:
                             username=op.data["username"],
                         )
                         counts["assignments_made"] += 1
-                        print(f"✓ Assigned {op.data['username']} to {op.data['group_name']}")
+                        print(f"✓ Assigned {op.data['username']} to {op.data['group_name']}")  # noqa: T201
 
                     if log_file:
                         entry = LogEntry(
@@ -367,9 +367,9 @@ class AuthentikClient:
                         log_file.write(json.dumps(entry.to_dict()) + "\n")
                         log_file.flush()
 
-                except Exception as e:
+                except Exception as e:  # noqa: BLE001
                     counts["errors"] += 1
-                    print(f"✗ Error processing {op}: {e}", file=sys.stderr)
+                    print(f"✗ Error processing {op}: {e}", file=sys.stderr)  # noqa: T201
                     if log_file:
                         entry = LogEntry(
                             op_type=op.op_type.value,

{octopize_deploy_tool-2.3.1 → octopize_deploy_tool-2.6.0}/src/octopize_avatar_deploy/cli.py

@@ -78,7 +78,7 @@ def _run_deploy(
     input_gatherer: InputGatherer | None,
 ) -> None:
     """Run the deploy subcommand."""
-    from octopize_avatar_deploy.configure import DeploymentRunner
+    from octopize_avatar_deploy.configure import DeploymentRunner  # noqa: PLC0415
 
     mode = DeploymentMode(getattr(args, "mode", "production"))
     runner = DeploymentRunner(
@@ -102,7 +102,7 @@ def _run_deploy(
 
 def _parse_component_output_path(value: str) -> tuple[str, Path]:
     """Parse a COMPONENT=PATH output override from the CLI."""
-    from octopize_avatar_deploy.components import get_component
+    from octopize_avatar_deploy.components import get_component  # noqa: PLC0415
 
     component, separator, raw_path = value.partition("=")
     if not separator or not component or not raw_path:
@@ -118,7 +118,7 @@ def _parse_component_output_path(value: str) -> tuple[str, Path]:
 
 def _add_generate_env_cli_args(parser: argparse.ArgumentParser) -> None:
     """Add CLI arguments for the generate-env subcommand."""
-    from octopize_avatar_deploy.components import get_all_components
+    from octopize_avatar_deploy.components import get_all_components  # noqa: PLC0415
 
     component_names = ", ".join(get_all_components().keys())
 
@@ -189,8 +189,8 @@ def _run_generate_env(
     input_gatherer: InputGatherer | None,
 ) -> None:
     """Run the generate-env subcommand."""
-    from octopize_avatar_deploy.components import get_all_components
-    from octopize_avatar_deploy.generate_env import GenerateEnvRunner
+    from octopize_avatar_deploy.components import get_all_components  # noqa: PLC0415
+    from octopize_avatar_deploy.generate_env import GenerateEnvRunner  # noqa: PLC0415
 
     components = args.components or list(get_all_components().keys())
     output_path_overrides = {
@@ -265,7 +265,7 @@ def _add_authentik_migrate_cli_args(parser: argparse.ArgumentParser) -> None:
 
 def _run_authentik_migrate(args: argparse.Namespace) -> None:
     """Run the authentik-migrate subcommand."""
-    from octopize_avatar_deploy.authentik_migration import (
+    from octopize_avatar_deploy.authentik_migration import (  # noqa: PLC0415
         AuthentikClient,
         MigrationParser,
         OperationType,
@@ -273,67 +273,67 @@ def _run_authentik_migrate(args: argparse.Namespace) -> None:
     )
 
     if args.failed_only and not args.from_log:
-        print("⚠️  --failed-only requires --from-log", file=sys.stderr)
+        print("⚠️  --failed-only requires --from-log", file=sys.stderr)  # noqa: T201
         sys.exit(1)
 
     if args.from_log:
-        print(f"📂 Loading operations from log: {args.from_log}")
+        print(f"📂 Loading operations from log: {args.from_log}")  # noqa: T201
         if args.failed_only:
-            print("🔁 Replaying failed operations only")
+            print("🔁 Replaying failed operations only")  # noqa: T201
         operations = load_operations_from_log(args.from_log, failed_only=args.failed_only)
-        print(f"✓ Loaded {len(operations)} operations")
+        print(f"✓ Loaded {len(operations)} operations")  # noqa: T201
         # Default the output log to <stem>_retry.<ext> to avoid overwriting the source log
         if args.log == "migration_log.jsonl":
             p = Path(args.from_log)
             args.log = str(p.with_stem(p.stem + "_retry"))
     else:
         if not args.users or not args.orgs or not args.licenses:
-            print(
+            print(  # noqa: T201
                 "⚠️  --users, --orgs, and --licenses are required when not using --from-log",
                 file=sys.stderr,
             )
             sys.exit(1)
 
-        print("📖 Parsing CSV files...")
+        print("📖 Parsing CSV files...")  # noqa: T201
         migration_parser = MigrationParser(
             users_csv=args.users,
             orgs_csv=args.orgs,
             licenses_csv=args.licenses,
         )
         operations = migration_parser.parse()
-        print(f"✓ Parsed {len(operations)} operations")
+        print(f"✓ Parsed {len(operations)} operations")  # noqa: T201
 
         group_creates = sum(1 for op in operations if op.op_type == OperationType.GROUP_CREATE)
         user_creates = sum(1 for op in operations if op.op_type == OperationType.USER_CREATE)
         assignments = sum(1 for op in operations if op.op_type == OperationType.GROUP_ASSIGN)
-        print(
+        print(  # noqa: T201
             f"  - {group_creates} groups to create\n"
             f"  - {user_creates} users to create\n"
             f"  - {assignments} group assignments",
         )
 
     if args.dry_run:
-        print("\n🔍 DRY RUN MODE - Operations:")
+        print("\n🔍 DRY RUN MODE - Operations:")  # noqa: T201
         for op in operations:
-            print(f"  {op}")
+            print(f"  {op}")  # noqa: T201
         return
 
     if not args.authentik_url or not args.authentik_token:
-        print("\n⚠️  For actual execution, provide --authentik-url and --authentik-token")
-        print("Use --dry-run to see operations without executing")
+        print("\n⚠️  For actual execution, provide --authentik-url and --authentik-token")  # noqa: T201
+        print("Use --dry-run to see operations without executing")  # noqa: T201
         sys.exit(1)
 
-    print(f"\n🚀 Executing operations against {args.authentik_url}...")
-    print(f"📝 Logging to: {args.log}")
+    print(f"\n🚀 Executing operations against {args.authentik_url}...")  # noqa: T201
+    print(f"📝 Logging to: {args.log}")  # noqa: T201
     with AuthentikClient(base_url=args.authentik_url, token=args.authentik_token) as client:
         counts = client.execute_operations(operations, log_path=args.log)
 
-    print("\n📊 Migration Summary:")
-    print(f"  ✓ Groups created: {counts['groups_created']}")
-    print(f"  ✓ Users created: {counts['users_created']}")
-    print(f"  ✓ Assignments made: {counts['assignments_made']}")
+    print("\n📊 Migration Summary:")  # noqa: T201
+    print(f"  ✓ Groups created: {counts['groups_created']}")  # noqa: T201
+    print(f"  ✓ Users created: {counts['users_created']}")  # noqa: T201
+    print(f"  ✓ Assignments made: {counts['assignments_made']}")  # noqa: T201
     if counts["errors"] > 0:
-        print(f"  ✗ Errors: {counts['errors']}")
+        print(f"  ✗ Errors: {counts['errors']}")  # noqa: T201
         sys.exit(1)
 
 
@@ -391,7 +391,7 @@ def main() -> None:
     test_printer: Printer | None = None
     test_input_gatherer: InputGatherer | None = None
     if os.environ.get("AVATAR_DEPLOY_TEST_MODE") == "1":
-        from octopize_avatar_deploy.cli_test_harness import (
+        from octopize_avatar_deploy.cli_test_harness import (  # noqa: PLC0415
             get_test_input_gatherer,
             get_test_printer,
         )
@@ -409,14 +409,14 @@ def main() -> None:
         else:
             raise RuntimeError(f"Unsupported command: {args.command}")
     except KeyboardInterrupt:
-        print("\n\nConfiguration cancelled by user.")
+        print("\n\nConfiguration cancelled by user.")  # noqa: T201
         sys.exit(1)
     except RuntimeError as e:
-        print(f"\n✗ Error: {e}")
+        print(f"\n✗ Error: {e}")  # noqa: T201
         sys.exit(1)
-    except Exception as e:
-        print(f"\n✗ Error: {e}")
-        import traceback
+    except Exception as e:  # noqa: BLE001
+        print(f"\n✗ Error: {e}")  # noqa: T201
+        import traceback  # noqa: PLC0415
 
         traceback.print_exc()
         sys.exit(1)

{octopize_deploy_tool-2.3.1 → octopize_deploy_tool-2.6.0}/src/octopize_avatar_deploy/cli_test_harness.py

@@ -6,6 +6,7 @@ Allows testing the CLI with pre-configured responses instead of manual input.
 This enables automated end-to-end testing of the entire CLI workflow.
 """
 
+import json
 import os
 import sys
 from pathlib import Path
@@ -118,23 +119,19 @@ class CLITestHarness:
                 return e.code
             # If it's a string or other type, return 1
             return 1
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             if not self.silent and not self.log_file:
-                print(f"CLI test failed with exception: {e}", file=sys.stderr)
+                print(f"CLI test failed with exception: {e}", file=sys.stderr)  # noqa: T201
             return 1
 
     @staticmethod
     def serialize_responses(responses: dict[str, str | bool | list[str | bool]]) -> str:
         """Serialize responses dict to string format using JSON."""
-        import json
-
         return json.dumps(responses)
 
     @staticmethod
     def deserialize_responses(serialized: str) -> dict[str, str | bool | list[str | bool]]:
         """Deserialize responses from JSON string format."""
-        import json
-
         if not serialized:
             return {}
 

octopize_deploy_tool-2.6.0/src/octopize_avatar_deploy/configurator.py

@@ -0,0 +1,197 @@
+"""Step-based configuration orchestrator.
+
+Drives the step-based collection of deployment values through interactive
+prompts or a config YAML file.  Works entirely in-memory except for the
+optional resume-state file managed by ``DeploymentState``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from octopize_avatar_deploy.deployment_mode import DeploymentMode
+from octopize_avatar_deploy.input_gatherer import InputGatherer
+from octopize_avatar_deploy.output_spec import OutputSpec
+from octopize_avatar_deploy.printer import Printer
+from octopize_avatar_deploy.state_manager import DeploymentState
+from octopize_avatar_deploy.steps.base import DeploymentStep
+
+
+class Configurator:
+    """Step-based configuration collector.
+
+    Orchestrates deployment steps to resolve configuration values from
+    interactive prompts or a pre-loaded config file.  Returns the
+    :class:`~octopize_avatar_deploy.state_manager.DeploymentState` populated
+    with the resolved config, accumulated secrets, and any post-generation
+    render specs from step hooks.
+
+    Filesystem access is limited to:
+
+    - Reading an optional config YAML file passed to :meth:`run`.
+    - Delegating incremental persistence to the provided ``state`` object
+      (which writes to disk only when its ``state_file`` is not ``None``).
+
+    Args:
+        output_dir: Directory used for step initialisation (forwarded to each
+            step constructor).
+        defaults: Pre-loaded defaults dict (typically from ``defaults.yaml``).
+        config: Shared configuration dict mutated in-place by each step.
+        state: Resume-state object; tracks step completion, config snapshots,
+            secrets, and post-generation specs.  When constructed with
+            ``state_file=None`` the state is in-memory only and ``save()``
+            calls are no-ops.
+        step_classes: Ordered list of step classes to execute (already filtered
+            by deployment mode).
+        mode: Deployment mode; stored as ``config["deployment_mode"]``.
+        printer: Progress output sink.
+        input_gatherer: Interactive-prompt handler.
+        on_step_complete: Optional callback invoked after each step completes,
+            *in addition to* the state's own auto-save.  Useful for callers
+            that want to perform extra work (e.g. additional serialisation)
+            on each checkpoint.
+    """
+
+    def __init__(
+        self,
+        output_dir: Path,
+        defaults: dict[str, Any],
+        config: dict[str, Any],
+        state: DeploymentState,
+        step_classes: list[type[DeploymentStep]],
+        mode: DeploymentMode,
+        printer: Printer,
+        input_gatherer: InputGatherer,
+        on_step_complete: Callable[[], None] | None = None,
+    ) -> None:
+        self.output_dir = output_dir
+        self.defaults = defaults
+        self.config = config
+        self.state = state
+        self.step_classes = step_classes
+        self.mode = mode
+        self.printer = printer
+        self.input_gatherer = input_gatherer
+        self.on_step_complete = on_step_complete
+
+    def run(
+        self,
+        interactive: bool = True,
+        config_file: Path | None = None,
+    ) -> DeploymentState:
+        """Execute all steps and return the populated deployment state.
+
+        Args:
+            interactive: Whether to prompt the user for missing values.
+            config_file: Optional YAML file used to pre-populate config values.
+
+        Returns:
+            The :class:`~octopize_avatar_deploy.state_manager.DeploymentState`
+            passed at construction time, now populated with the resolved config
+            dict, accumulated secrets, and post-generation render specs.
+
+        Raises:
+            RuntimeError: If the config file cannot be loaded or parsed.
+            ValueError: If a step fails validation.
+        """
+        # ------------------------------------------------------------------ #
+        # 1. Resume-state handling
+        # ------------------------------------------------------------------ #
+        if self.state.has_started() and not self.state.is_complete():
+            if interactive:
+                self.state.print_status(self.printer)
+                self.printer.print_header("")
+                response = self.input_gatherer.prompt_yes_no(
+                    "Resume from where you left off?", default=True, key="resume.continue"
+                )
+                if not response:
+                    self.printer.print("Starting fresh configuration...")
+                    self.state.reset()
+                else:
+                    self.printer.print("Resuming from last completed step...")
+                    self.config.update(self.state.get_config())
+            else:
+                # Non-interactive: always resume automatically.
+                self.config.update(self.state.get_config())
+
+        # ------------------------------------------------------------------ #
+        # 2. Load config file
+        # ------------------------------------------------------------------ #
+        if config_file and config_file.exists():
+            self.printer.print(f"Loading configuration from {config_file}...")
+            try:
+                with open(config_file) as f:
+                    loaded_config = yaml.safe_load(f) or {}
+            except yaml.YAMLError as e:
+                raise RuntimeError(f"Failed to parse YAML config file: {e}") from e
+            except Exception as e:
+                raise RuntimeError(f"Failed to load config file: {e}") from e
+
+            self.config.update(loaded_config)
+        # ------------------------------------------------------------------ #
+        # 3. Instantiate and run steps
+        # ------------------------------------------------------------------ #
+        steps = [
+            step_class(
+                self.output_dir,
+                self.defaults,
+                self.config,
+                interactive,
+                self.printer,
+                self.input_gatherer,
+            )
+            for step_class in self.step_classes
+        ]
+
+        self.printer.print_header("Avatar Deployment Configuration")
+        self.printer.print()
+        self.printer.print("Executing configuration steps...")
+        self.printer.print()
+
+        for i, step in enumerate(steps):
+            step_name = f"step_{i}_{step.name}"
+
+            if self.state.is_step_completed(step_name):
+                self.printer.print_step(step.description, skipped=True)
+                continue
+
+            self.printer.print_step(step.description)
+            self.state.mark_step_started(step_name)
+
+            step_config = step.collect_config()
+            self.config.update(step_config)
+
+            step_secrets = step.generate_secrets()
+            self.state.update_secrets(step_secrets)
+
+            if not step.validate():
+                raise ValueError(f"Validation failed for step: {step.name}")
+
+            self.state.mark_step_completed(step_name)
+            self.state.update_config(self.config)
+
+            if self.on_step_complete:
+                self.on_step_complete()
+
+        # ------------------------------------------------------------------ #
+        # 4. Collect post-generation render specs and store in state
+        # ------------------------------------------------------------------ #
+        post_generation_specs: list[OutputSpec] = []
+
+        def _collect_spec(template_name: str, output_name: str) -> None:
+            post_generation_specs.append(OutputSpec(template_name, output_name))
+
+        for step in steps:
+            step.after_config_generation(_collect_spec)
+
+        self.state.set_post_generation_specs(post_generation_specs)
+
+        # Ensure the final config state is always flushed, even when no steps ran
+        # or the last step didn't trigger a save (e.g. early resume skip).
+        self.state.update_config(self.config)
+
+        return self.state