fogies 0.0.0.dev4__tar.gz → 0.0.0.dev5__tar.gz

{fogies-0.0.0.dev4 → fogies-0.0.0.dev5}/PKG-INFO

@@ -1,16 +1,19 @@
 Metadata-Version: 2.4
 Name: fogies
-Version: 0.0.0.dev4
+Version: 0.0.0.dev5
 Summary: 
 Author: James Fogarty
 Author-email: jayfo@users.noreply.github.com
 Requires-Python: >=3.14,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: boto3 (>=1.42.68,<2.0.0)
 Requires-Dist: filelock (>=3.25.2,<4.0.0)
-Requires-Dist: ollama (>=0.6.1,<0.7.0)
+Requires-Dist: ollama (>=0.6.2,<0.7.0)
 Requires-Dist: psutil (>=7.2.2,<8.0.0)
 Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: tenacity (>=9.1.4,<10.0.0)
+Requires-Dist: tomli-w (>=1.2.0,<2.0.0)
 Description-Content-Type: text/markdown
 
 # pyfogies

{fogies-0.0.0.dev4 → fogies-0.0.0.dev5}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "fogies"
 # Version follows semantic versioning <https://semver.org/>.
-version = "0.0.0-dev.4"
+version = "0.0.0-dev.5"
 description = ""
 authors = [
     {name = "James Fogarty",email = "jayfo@users.noreply.github.com"}
@@ -12,39 +12,49 @@ requires-python = ">=3.14,<4.0"
 [tool.poetry]
 packages = [
     {include = "fogies", from = "src"},
-    {include = "fogies_paths.py", from = "."},
 ]
 include = [
     {path = "src/fogies/py.typed", format = ["sdist", "wheel"]},
 ]
 
 [tool.poetry.dependencies]
-pydantic = "^2.12.5"
-ollama = "^0.6.1"
+# ^ allows all minor and patch releases.
+#   Example: ^1.2.3 will match 1.x.x versions >=1.2.3 and <2.0.0.
+# ~ allows only patch releases.
+#   Example: ~1.2.3 will match versions >=1.2.3 and <1.3.0.
+boto3 = "^1.42.68"
 filelock = "^3.25.2"
+ollama = "^0.6.2"
 psutil = "^7.2.2"
+pydantic = "^2.12.5"
+tenacity = "^9.1.4"
+tomli-w = "^1.2.0"
 
 [tool.poetry.group.dev.dependencies]
 # ^ allows all minor and patch releases.
-#   Example: ^1.2.3 will match 1.x.x versions >=1.2.3 but <2.0.0.
+#   Example: ^1.2.3 will match 1.x.x versions >=1.2.3 and <2.0.0.
 # ~ allows only patch releases.
-#   Example: ~1.2.3 will match versions >=1.2.3 but <1.3.0.
+#   Example: ~1.2.3 will match versions >=1.2.3 and <1.3.0.
 basedpyright = "^1.36.1"
-black = "~25.12.0" # Black does not semver.
-boto3 = "^1.42.68"
-boto3-stubs-full = "^1.42.68"
+black = "~26.5.1" # Black does not semver.
+boto3-stubs = {version = "^1.43.60", extras = ["s3"]}
 invoke = "^2.2.1"
-isort = "^7.0.0"
+isort = "^8.0.1"
 poetry = "^2.2.1"
 pytest = "^9.0.2"
+requests = "~2.33.0"
 semver = "^3.0.4"
+types-requests = "~2.33.0.20260712"
 
 [tool.basedpyright]
 typeCheckingMode = "recommended"
 pythonVersion = "3.14"
-include = ["fogies_paths.py", "src", "tasks", "tests"]
+include = ["src", "tasks", "tests"]
 allowedUntypedLibraries = ["invoke"]
 
+[tool.black]
+target-version = ["py314"]
+
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"

fogies-0.0.0.dev5/src/fogies/retry.py

@@ -0,0 +1,102 @@
+"""Shared retry policies built on tenacity.
+
+Call sites should use one of the named profiles below rather than inventing
+timeout/interval/attempt values locally. Add a new profile here if a case
+genuinely needs different numbers.
+
+Pass *log_path* to a profile to append a line for each retried failure. This
+is for retries whose cause isn't already well understood and is worth
+investigating; well-understood retries (e.g. polling for a resource to come
+up) don't need it. Nothing is written, and no file is created, unless a
+retry actually happens.
+"""
+
+import pathlib
+from collections.abc import Callable
+from datetime import datetime
+from typing import TypeVar
+
+import tenacity
+
+_T = TypeVar("_T")
+
+
+def _log_retry(log_path: pathlib.Path) -> Callable[[tenacity.RetryCallState], None]:
+    def log_it(retry_state: tenacity.RetryCallState) -> None:
+        outcome = retry_state.outcome
+        assert outcome is not None and outcome.failed
+        exception = outcome.exception()
+        assert exception is not None
+        line = "{} attempt {} raised {}: {}\n".format(
+            datetime.now().isoformat(timespec="seconds"),
+            retry_state.attempt_number,
+            type(exception).__name__,
+            exception,
+        )
+        with log_path.open("a", encoding="utf-8") as f:
+            _ = f.write(line)
+
+    return log_it
+
+
+def readiness_poll(
+    *,
+    exceptions: type[BaseException] | tuple[type[BaseException], ...],
+    timeout: float,
+    poll_interval: float,
+    reraise: bool = True,
+) -> tenacity.Retrying:
+    """Retry policy for polling until a resource becomes ready or *timeout* elapses.
+
+    Retries only on *exceptions*; any other exception propagates immediately.
+    On giving up, re-raises the last *exceptions* instance unless *reraise* is
+    False, in which case a `tenacity.RetryError` is raised instead.
+    """
+    return tenacity.Retrying(
+        retry=tenacity.retry_if_exception_type(exceptions),
+        wait=tenacity.wait_fixed(poll_interval),
+        stop=tenacity.stop_after_delay(timeout),
+        reraise=reraise,
+    )
+
+
+def readiness_poll_short(
+    *,
+    exceptions: type[BaseException] | tuple[type[BaseException], ...],
+    reraise: bool = True,
+) -> tenacity.Retrying:
+    """Readiness poll profile for something expected ready within seconds."""
+    return readiness_poll(
+        exceptions=exceptions,
+        timeout=10.0,
+        poll_interval=0.1,
+        reraise=reraise,
+    )
+
+
+def readiness_poll_long(
+    *,
+    exceptions: type[BaseException] | tuple[type[BaseException], ...],
+    reraise: bool = True,
+) -> tenacity.Retrying:
+    """Readiness poll profile for something that can take minutes to become ready."""
+    return readiness_poll(
+        exceptions=exceptions,
+        timeout=300.0,
+        poll_interval=5.0,
+        reraise=reraise,
+    )
+
+
+def retry_transient(
+    *,
+    exceptions: type[BaseException] | tuple[type[BaseException], ...],
+    log_path: pathlib.Path | None = None,
+) -> Callable[[Callable[[], _T]], Callable[[], _T]]:
+    """Retry profile for a flaky one-off operation, with no backoff."""
+    return tenacity.retry(
+        retry=tenacity.retry_if_exception_type(exceptions),
+        stop=tenacity.stop_after_attempt(5),
+        reraise=True,
+        before_sleep=_log_retry(log_path) if log_path is not None else None,
+    )

fogies-0.0.0.dev5/src/fogies/tasks/format.py

@@ -0,0 +1,65 @@
+"""
+Tasks for applying code formatting.
+"""
+
+import pathlib
+from typing import Callable, cast
+
+from invoke.context import Context
+from invoke.tasks import Task, task
+
+from fogies.tools.command import CommandParams
+from fogies.tools.terraform import terraform
+
+
+def get_task_format(
+    *,
+    fmt_black: bool = False,
+    fmt_isort: bool = False,
+    fmt_terraform: bool = False,
+    terraform_binary_cache_path: pathlib.Path | None = None,
+) -> Task[Callable[[Context], None]]:
+    if fmt_terraform and terraform_binary_cache_path is None:
+        raise ValueError(
+            "terraform_binary_cache_path is required when fmt_terraform is set"
+        )
+    if not (fmt_black or fmt_isort or fmt_terraform):
+        raise ValueError("At least one fmt flag must be set.")
+
+    @task(name="format")  # pyright: ignore[reportUntypedFunctionDecorator]
+    def task_format(context: Context) -> None:
+        """
+        Apply code formatting.
+        """
+        # isort before black: black should see the post-sort import layout.
+        if fmt_isort:
+            _ = context.run(
+                command=" ".join(
+                    [
+                        "isort",
+                        ".",
+                    ]
+                ),
+                echo=True,
+            )
+
+        if fmt_black:
+            _ = context.run(
+                command=" ".join(
+                    [
+                        "black",
+                        ".",
+                    ]
+                ),
+                echo=True,
+            )
+
+        if fmt_terraform:
+            assert terraform_binary_cache_path is not None
+            with terraform(binary_cache_path=terraform_binary_cache_path) as tf:
+                _ = tf.format(
+                    command_params=CommandParams(context=context),
+                    path=pathlib.Path("."),
+                )
+
+    return cast(Task[Callable[[Context], None]], task_format)

{fogies-0.0.0.dev4 → fogies-0.0.0.dev5}/src/fogies/tasks/poetry.py

@@ -36,17 +36,24 @@ def get_task_publish(*, path_secrets_poetry: Path) -> Task[Callable[[Context], N
         """
         Publish package to PyPI.
         """
+        if not path_secrets_poetry.exists():
+            raise FileNotFoundError(
+                "Poetry secrets file '{}' does not exist.\nSee provided template.".format(
+                    path_secrets_poetry
+                )
+            )
+
         with path_secrets_poetry.open("rb") as handle:
             secrets_poetry = tomllib.load(handle)
 
-        api_key: str = cast(str, secrets_poetry["api"]["api_key"])
+        api_key: str = cast(str, secrets_poetry["pypi"]["api_key"])
 
         _ = context.run(
             command=" ".join(
                 [
                     "poetry",
                     "publish",
-                    "--username {}".format("__token__"),
+                    "--username __token__",
                     "--password {}".format(api_key),
                 ]
             ),
@@ -56,7 +63,7 @@ def get_task_publish(*, path_secrets_poetry: Path) -> Task[Callable[[Context], N
     return cast(Task[Callable[[Context], None]], task_publish)
 
 
-def get_collection(path_secrets_poetry: Path) -> Collection:
+def get_collection(*, path_secrets_poetry: Path) -> Collection:
     """
     Get a collection of tasks.
     """

fogies-0.0.0.dev5/src/fogies/tasks/terraform.py

@@ -0,0 +1,173 @@
+"""Generic tasks for applying and destroying a Terraform configuration."""
+
+import pathlib
+from contextlib import ExitStack
+from typing import Callable, cast
+
+from invoke.context import Context
+from invoke.tasks import Task, task
+
+from fogies.terraform.backend import BackendConfig
+from fogies.tools.aws_environ import AwsEnvironContextManager
+from fogies.tools.command import CommandParams
+from fogies.tools.terraform import (
+    ApplyParams,
+    DestroyParams,
+    InitParams,
+    TfbackendContextManager,
+    TfvarsContextManager,
+    terraform,
+)
+
+
+def get_task_apply(
+    *,
+    binary_cache_path: pathlib.Path,
+    module_path: pathlib.Path,
+    aws_environ: AwsEnvironContextManager | None = None,
+    backend: BackendConfig | None = None,
+    backend_status_path: pathlib.Path | None = None,
+    tfbackend: TfbackendContextManager | None = None,
+    tfvars: TfvarsContextManager | None = None,
+    default_init: bool = True,
+    default_init_upgrade: bool = False,
+    default_init_reconfigure: bool = False,
+    default_apply_auto_approve: bool = False,
+) -> Task[Callable[[Context, bool, bool, bool, bool], None]]:
+    if backend is not None and tfbackend is None:
+        raise ValueError("tfbackend is required when backend is set")
+    if (backend_status_path is None) != (backend is None):
+        raise ValueError("backend_status_path and backend must be provided together")
+
+    @task(name="apply")  # pyright: ignore[reportUntypedFunctionDecorator]
+    def task_apply(
+        context: Context,
+        init: bool = default_init,
+        init_upgrade: bool = default_init_upgrade,
+        init_reconfigure: bool = default_init_reconfigure,
+        apply_auto_approve: bool = default_apply_auto_approve,
+    ) -> None:
+        """
+        Apply a Terraform configuration.
+
+        Flags:
+          --init                Run terraform init before apply (downloads providers, sets up backend).
+          --init-upgrade        Pass -upgrade to init; checks for newer provider versions within constraints.
+          --init-reconfigure    Pass -reconfigure to init; re-initializes backend from scratch.
+          --apply-auto-approve  Skip Terraform's interactive confirmation prompt.
+
+        --init-upgrade and --init-reconfigure require --init.
+        """
+        if init_upgrade and not init:
+            raise ValueError("--init-upgrade requires --init")
+        if init_reconfigure and not init:
+            raise ValueError("--init-reconfigure requires --init")
+
+        command_params = CommandParams(context=context)
+        init_params = (
+            InitParams(upgrade=init_upgrade, reconfigure=init_reconfigure)
+            if init
+            else None
+        )
+
+        with ExitStack() as stack:
+            if aws_environ is not None:
+                _ = stack.enter_context(aws_environ)
+
+            tfbackend_path = stack.enter_context(tfbackend) if tfbackend else None
+            tfvars_path = stack.enter_context(tfvars) if tfvars else None
+
+            _ = stack.enter_context(
+                terraform(
+                    binary_cache_path=binary_cache_path,
+                    command_params=command_params,
+                    module_path=module_path,
+                    backend=backend,
+                    backend_status_path=backend_status_path,
+                    tfbackend_path=tfbackend_path,
+                    tfvars_path=tfvars_path,
+                    init_on_entry=init,
+                    init_params=init_params,
+                    apply_on_entry=True,
+                    apply_params=ApplyParams(auto_approve=apply_auto_approve),
+                    destroy_on_exit=False,
+                )
+            )
+
+    return cast(Task[Callable[[Context, bool, bool, bool, bool], None]], task_apply)
+
+
+def get_task_destroy(
+    *,
+    binary_cache_path: pathlib.Path,
+    module_path: pathlib.Path,
+    aws_environ: AwsEnvironContextManager | None = None,
+    backend: BackendConfig | None = None,
+    backend_status_path: pathlib.Path | None = None,
+    tfbackend: TfbackendContextManager | None = None,
+    tfvars: TfvarsContextManager | None = None,
+    default_init: bool = True,
+    default_init_upgrade: bool = False,
+    default_init_reconfigure: bool = False,
+    default_destroy_auto_approve: bool = False,
+) -> Task[Callable[[Context, bool, bool, bool, bool], None]]:
+    if backend is not None and tfbackend is None:
+        raise ValueError("tfbackend is required when backend is set")
+    if (backend_status_path is None) != (backend is None):
+        raise ValueError("backend_status_path and backend must be provided together")
+
+    @task(name="destroy")  # pyright: ignore[reportUntypedFunctionDecorator]
+    def task_destroy(
+        context: Context,
+        init: bool = default_init,
+        init_upgrade: bool = default_init_upgrade,
+        init_reconfigure: bool = default_init_reconfigure,
+        destroy_auto_approve: bool = default_destroy_auto_approve,
+    ) -> None:
+        """
+        Destroy a Terraform configuration.
+
+        Flags:
+          --init                 Run terraform init before destroy (downloads providers, sets up backend).
+          --init-upgrade         Pass -upgrade to init; checks for newer provider versions within constraints.
+          --init-reconfigure     Pass -reconfigure to init; re-initializes backend from scratch.
+          --destroy-auto-approve Skip Terraform's interactive confirmation prompt.
+
+        --init-upgrade and --init-reconfigure require --init.
+        """
+        if init_upgrade and not init:
+            raise ValueError("--init-upgrade requires --init")
+        if init_reconfigure and not init:
+            raise ValueError("--init-reconfigure requires --init")
+
+        command_params = CommandParams(context=context)
+        init_params = (
+            InitParams(upgrade=init_upgrade, reconfigure=init_reconfigure)
+            if init
+            else None
+        )
+
+        with ExitStack() as stack:
+            if aws_environ is not None:
+                _ = stack.enter_context(aws_environ)
+
+            tfbackend_path = stack.enter_context(tfbackend) if tfbackend else None
+            tfvars_path = stack.enter_context(tfvars) if tfvars else None
+
+            _ = stack.enter_context(
+                terraform(
+                    binary_cache_path=binary_cache_path,
+                    command_params=command_params,
+                    module_path=module_path,
+                    backend=backend,
+                    backend_status_path=backend_status_path,
+                    tfbackend_path=tfbackend_path,
+                    tfvars_path=tfvars_path,
+                    init_on_entry=init,
+                    init_params=init_params,
+                    destroy_on_exit=True,
+                    destroy_params=DestroyParams(auto_approve=destroy_auto_approve),
+                )
+            )
+
+    return cast(Task[Callable[[Context, bool, bool, bool, bool], None]], task_destroy)

fogies-0.0.0.dev5/src/fogies/tasks/terraform_backend.py

@@ -0,0 +1,180 @@
+"""Tasks for applying and destroying a Terraform backend configuration."""
+
+import pathlib
+from collections.abc import Callable
+from contextlib import ExitStack
+from typing import cast
+
+from invoke.context import Context
+from invoke.tasks import Task, task
+
+from fogies.terraform.backend import BackendOutput
+from fogies.tools.aws_environ import AwsEnvironContextManager
+from fogies.tools.command import CommandParams
+from fogies.tools.terraform import (
+    ApplyParams,
+    DestroyParams,
+    InitParams,
+    TerraformOutputModel,
+    TfvarsContextManager,
+)
+from fogies.tools.terraform_backend import terraform_backend
+
+
+def get_task_backend_apply(
+    *,
+    binary_cache_path: pathlib.Path,
+    module_path: pathlib.Path,
+    aws_environ: AwsEnvironContextManager | None = None,
+    backend_status_path: pathlib.Path,
+    tfbackend_path: pathlib.Path | None = None,
+    tfvars: TfvarsContextManager | None = None,
+    output_model: type[TerraformOutputModel],
+    output_model_get_backend: Callable[[TerraformOutputModel], BackendOutput],
+    default_init: bool = True,
+    default_init_upgrade: bool = False,
+    default_init_reconfigure: bool = False,
+    default_apply_auto_approve: bool = False,
+    default_output: bool = False,
+) -> Task[Callable[[Context, bool, bool, bool, bool, bool], None]]:
+    @task(name="apply")  # pyright: ignore[reportUntypedFunctionDecorator]
+    def task_apply(
+        context: Context,
+        init: bool = default_init,
+        init_upgrade: bool = default_init_upgrade,
+        init_reconfigure: bool = default_init_reconfigure,
+        apply_auto_approve: bool = default_apply_auto_approve,
+        output: bool = default_output,
+    ) -> None:
+        """
+        Apply a Terraform backend configuration, and record it as applied.
+
+        Flags:
+          --init                Run terraform init before apply (downloads providers, sets up backend).
+          --init-upgrade        Pass -upgrade to init; checks for newer provider versions within constraints.
+          --init-reconfigure    Pass -reconfigure to init; re-initializes backend from scratch.
+          --apply-auto-approve  Skip Terraform's interactive confirmation prompt.
+          --output              Print terraform output as JSON after apply.
+
+        --init-upgrade and --init-reconfigure require --init.
+        """
+        if init_upgrade and not init:
+            raise ValueError("--init-upgrade requires --init")
+        if init_reconfigure and not init:
+            raise ValueError("--init-reconfigure requires --init")
+
+        command_params = CommandParams(context=context)
+        init_params = (
+            InitParams(upgrade=init_upgrade, reconfigure=init_reconfigure)
+            if init
+            else None
+        )
+
+        with ExitStack() as stack:
+            if aws_environ is not None:
+                _ = stack.enter_context(aws_environ)
+
+            tfvars_path = stack.enter_context(tfvars) if tfvars else None
+
+            output_result = stack.enter_context(
+                terraform_backend(
+                    binary_cache_path=binary_cache_path,
+                    command_params=command_params,
+                    module_path=module_path,
+                    backend_status_path=backend_status_path,
+                    tfbackend_path=tfbackend_path,
+                    tfvars_path=tfvars_path,
+                    init_on_entry=init,
+                    init_params=init_params,
+                    apply_on_entry=True,
+                    apply_params=ApplyParams(auto_approve=apply_auto_approve),
+                    destroy_on_exit=False,
+                    output_model=output_model,
+                    output_model_get_backend=output_model_get_backend,
+                )
+            )
+
+            if output:
+                print(output_model_get_backend(output_result).model_dump_json(indent=2))
+
+    return cast(
+        Task[Callable[[Context, bool, bool, bool, bool, bool], None]], task_apply
+    )
+
+
+def get_task_backend_destroy(
+    *,
+    binary_cache_path: pathlib.Path,
+    module_path: pathlib.Path,
+    aws_environ: AwsEnvironContextManager | None = None,
+    backend_status_path: pathlib.Path,
+    tfbackend_path: pathlib.Path | None = None,
+    tfvars: TfvarsContextManager | None = None,
+    output_model: type[TerraformOutputModel],
+    output_model_get_backend: Callable[[TerraformOutputModel], BackendOutput],
+    default_init: bool = True,
+    default_init_upgrade: bool = False,
+    default_init_reconfigure: bool = False,
+    default_destroy_auto_approve: bool = False,
+) -> Task[Callable[[Context, bool, bool, bool, bool], None]]:
+    @task(name="destroy")  # pyright: ignore[reportUntypedFunctionDecorator]
+    def task_destroy(
+        context: Context,
+        init: bool = default_init,
+        init_upgrade: bool = default_init_upgrade,
+        init_reconfigure: bool = default_init_reconfigure,
+        destroy_auto_approve: bool = default_destroy_auto_approve,
+    ) -> None:
+        """
+        Destroy a Terraform backend configuration, and record it as destroyed.
+
+        Reads the backend module's own output, verifies every state it
+        declares is empty of resources, then clears the bucket's state
+        objects before destroying it. Refuses (raises) if any declared state
+        still has resources, regardless of how this task is invoked.
+
+        Flags:
+          --init                 Run terraform init before destroy (downloads providers, sets up backend).
+          --init-upgrade         Pass -upgrade to init; checks for newer provider versions within constraints.
+          --init-reconfigure     Pass -reconfigure to init; re-initializes backend from scratch.
+          --destroy-auto-approve Skip Terraform's interactive confirmation prompt.
+
+        --init-upgrade and --init-reconfigure require --init.
+        """
+        if init_upgrade and not init:
+            raise ValueError("--init-upgrade requires --init")
+        if init_reconfigure and not init:
+            raise ValueError("--init-reconfigure requires --init")
+
+        command_params = CommandParams(context=context)
+        init_params = (
+            InitParams(upgrade=init_upgrade, reconfigure=init_reconfigure)
+            if init
+            else None
+        )
+
+        with ExitStack() as stack:
+            if aws_environ is not None:
+                _ = stack.enter_context(aws_environ)
+
+            tfvars_path = stack.enter_context(tfvars) if tfvars else None
+
+            _ = stack.enter_context(
+                terraform_backend(
+                    binary_cache_path=binary_cache_path,
+                    command_params=command_params,
+                    module_path=module_path,
+                    backend_status_path=backend_status_path,
+                    tfbackend_path=tfbackend_path,
+                    tfvars_path=tfvars_path,
+                    init_on_entry=init,
+                    init_params=init_params,
+                    apply_on_entry=False,
+                    destroy_on_exit=True,
+                    destroy_params=DestroyParams(auto_approve=destroy_auto_approve),
+                    output_model=output_model,
+                    output_model_get_backend=output_model_get_backend,
+                )
+            )
+
+    return cast(Task[Callable[[Context, bool, bool, bool, bool], None]], task_destroy)

{fogies-0.0.0.dev4 → fogies-0.0.0.dev5}/src/fogies/tasks/test.py

@@ -10,7 +10,7 @@ from invoke.context import Context
 from invoke.tasks import Task, task
 
 
-def get_task_test(path_tests: str | None = None) -> Task[Callable[[Context], None]]:
+def get_task_test(*, path_tests: str | None = None) -> Task[Callable[[Context], None]]:
     @task(name="test")  # pyright: ignore[reportUntypedFunctionDecorator]
     def task_test(context: Context) -> None:
         """

fogies-0.0.0.dev5/src/fogies/terraform/alb.py

@@ -0,0 +1,22 @@
+"""Pydantic models for Terraform ALB module variables and output."""
+
+from pydantic import BaseModel
+
+
+class AlbVars(BaseModel):
+    region: str
+    name: str
+    subnet_ids: list[str]
+    security_group_ids: list[str]
+    self_signed_certificate: bool = False
+    certificate_arn: str | None = None
+    tags: dict[str, str] = {}
+
+
+class AlbOutput(BaseModel):
+    alb_arn: str
+    alb_dns_name: str
+    alb_zone_id: str
+    listener_http_arn: str
+    listener_https_arn: str
+    certificate_pem: str | None