ynab-api-cli 0.1.0__py3-none-any.whl

ynab_api_cli/distribution.py

@@ -0,0 +1,123 @@
+"""Build archive checks and isolated installation smoke verification."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import zipfile
+from pathlib import Path
+
+from ynab_api_cli.config import ConfigStore
+from ynab_api_cli.contract import Contract
+from ynab_api_cli.exceptions import AppError
+
+
+class DistributionCheck:
+    """Verify wheels, source archives, and a clean uv tool installation."""
+
+    @classmethod
+    def main(cls) -> None:
+        """Run the release check from the project root."""
+        cls().run(Path(__file__).resolve().parents[2])
+
+    def run(self, root: Path) -> None:
+        """Inspect built artifacts and exercise the independently installed CLI."""
+        wheel = next((root / "dist").glob("*.whl"))
+        source = next((root / "dist").glob("*.tar.gz"))
+        with zipfile.ZipFile(wheel) as archive:
+            names = archive.namelist()
+            required = {
+                "ynab_api_cli/resources/openapi.yaml",
+                "ynab_api_cli/resources/catalog.json",
+                "ynab_api_cli/resources/skill/SKILL.md",
+                "ynab_api_cli/py.typed",
+            }
+            if not required <= set(names):
+                raise AppError("Wheel is missing required contract or skill resources.")
+        with tarfile.open(source) as archive:
+            if not any(
+                name.endswith("/skills/ynab-api-cli/SKILL.md")
+                for name in archive.getnames()
+            ):
+                raise AppError("Source archive is missing the supplementary skill.")
+        uv = shutil.which("uv")
+        if uv is None:
+            raise AppError("uv is required for clean installation verification.")
+        with tempfile.TemporaryDirectory() as temporary:
+            workspace = Path(temporary)
+            environment = dict(os.environ)
+            environment.update(
+                {
+                    "UV_TOOL_DIR": str(workspace / "tools"),
+                    "UV_TOOL_BIN_DIR": str(workspace / "bin"),
+                    "XDG_CONFIG_HOME": str(workspace / "config"),
+                }
+            )
+            subprocess.run(  # noqa: S603 - resolved uv and local wheel, no shell.
+                [
+                    uv,
+                    "tool",
+                    "install",
+                    "--python",
+                    sys.executable,
+                    "--no-managed-python",
+                    str(wheel),
+                ],
+                env=environment,
+                cwd=workspace,
+                check=True,
+            )
+            executable = (
+                workspace
+                / "bin"
+                / ("ynab-api-cli.exe" if os.name == "nt" else "ynab-api-cli")
+            )
+            store = ConfigStore(workspace / "config/ynab-api-cli")
+            store.configure("synthetic-install-test")
+            for argv in (
+                ["--help"],
+                ["discover"],
+                ["inspect", "getUser"],
+                ["doctor", "--offline"],
+                ["skill", "export", str(workspace / "exported-skill")],
+            ):
+                result = subprocess.run(  # noqa: S603 - fixed installed CLI smoke commands.
+                    [str(executable), *argv],
+                    env=environment,
+                    cwd=workspace,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                if argv[0] == "discover" and len(
+                    json.loads(result.stdout)["operations"]
+                ) != len(Contract().catalog):
+                    raise AppError("Installed CLI operation inventory mismatch.")
+        release = root / "dist" / (wheel.name.split("-py3-")[0] + "-release.zip")
+        with zipfile.ZipFile(release, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+            for artifact in (wheel, source, root / "README.md"):
+                archive.write(artifact, artifact.name)
+            for directory in ("skills", "docs"):
+                for path in (root / directory).rglob("*"):
+                    if path.is_file():
+                        archive.write(path, str(path.relative_to(root)))
+        sys.stdout.write(
+            json.dumps(
+                {
+                    "wheel": wheel.name,
+                    "source": source.name,
+                    "release": release.name,
+                    "clean_install": "passed",
+                }
+            )
+            + "\n"
+        )
+
+
+if __name__ == "__main__":
+    DistributionCheck.main()

ynab_api_cli/exceptions.py

@@ -0,0 +1,7 @@
+"""Safe application failures whose messages never contain credentials."""
+
+from __future__ import annotations
+
+
+class AppError(Exception):
+    """Expected configuration, validation, or HTTP failure."""

ynab_api_cli/generated/__init__.py

@@ -0,0 +1,3 @@
+"""Generated REST client declarations."""
+
+from __future__ import annotations

ynab_api_cli/generated/api/__init__.py

@@ -0,0 +1,3 @@
+"""Generated endpoint declarations."""
+
+from __future__ import annotations

ynab_api_cli/generated/api/accounts/__init__.py

@@ -0,0 +1,3 @@
+"""Generated endpoint declarations."""
+
+from __future__ import annotations

ynab_api_cli/generated/api/accounts/create_account.py

@@ -0,0 +1,54 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.account_response import AccountResponse
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.post_account_wrapper import PostAccountWrapper
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import RequestValues, Response
+
+
+class Endpoint:
+    """Typed createAccount operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        body: PostAccountWrapper,
+    ) -> Response[AccountResponse | ErrorResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "createAccount",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                },
+                query={},
+                body=body,
+            ),
+        )
+        if raw.status == HTTPStatus.CREATED:
+            parsed = AccountResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[AccountResponse | ErrorResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            body=TypeAdapter[PostAccountWrapper](PostAccountWrapper).validate_python(
+                request.body
+            ),
+        )

ynab_api_cli/generated/api/accounts/get_account_by_id.py

@@ -0,0 +1,53 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+from uuid import UUID
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.account_response import AccountResponse
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response
+
+
+class Endpoint:
+    """Typed getAccountById operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        account_id: UUID,
+    ) -> Response[AccountResponse | ErrorResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getAccountById",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "account_id": account_id,
+                },
+                query={},
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = AccountResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[AccountResponse | ErrorResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            account_id=request.value("path", "account_id", TypeAdapter[UUID](UUID)),
+        )

ynab_api_cli/generated/api/accounts/get_accounts.py

@@ -0,0 +1,57 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.accounts_response import AccountsResponse
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response, Unset
+
+
+class Endpoint:
+    """Typed getAccounts operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        last_knowledge_of_server: int | Unset = UNSET,
+    ) -> Response[AccountsResponse | ErrorResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getAccounts",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                },
+                query={
+                    "last_knowledge_of_server": last_knowledge_of_server,
+                },
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = AccountsResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[AccountsResponse | ErrorResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            last_knowledge_of_server=request.value(
+                "query",
+                "last_knowledge_of_server",
+                TypeAdapter[int | Unset](int | Unset),
+            ),
+        )

ynab_api_cli/generated/api/categories/__init__.py

@@ -0,0 +1,3 @@
+"""Generated endpoint declarations."""
+
+from __future__ import annotations

ynab_api_cli/generated/api/categories/create_category.py

@@ -0,0 +1,54 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.post_category_wrapper import PostCategoryWrapper
+from ynab_api_cli.generated.models.save_category_response import SaveCategoryResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import RequestValues, Response
+
+
+class Endpoint:
+    """Typed createCategory operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        body: PostCategoryWrapper,
+    ) -> Response[ErrorResponse | SaveCategoryResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "createCategory",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                },
+                query={},
+                body=body,
+            ),
+        )
+        if raw.status == HTTPStatus.CREATED:
+            parsed = SaveCategoryResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | SaveCategoryResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            body=TypeAdapter[PostCategoryWrapper](PostCategoryWrapper).validate_python(
+                request.body
+            ),
+        )

ynab_api_cli/generated/api/categories/create_category_group.py

@@ -0,0 +1,58 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.post_category_group_wrapper import (
+    PostCategoryGroupWrapper,
+)
+from ynab_api_cli.generated.models.save_category_group_response import (
+    SaveCategoryGroupResponse,
+)
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import RequestValues, Response
+
+
+class Endpoint:
+    """Typed createCategoryGroup operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        body: PostCategoryGroupWrapper,
+    ) -> Response[ErrorResponse | SaveCategoryGroupResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "createCategoryGroup",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                },
+                query={},
+                body=body,
+            ),
+        )
+        if raw.status == HTTPStatus.CREATED:
+            parsed = SaveCategoryGroupResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | SaveCategoryGroupResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            body=TypeAdapter[PostCategoryGroupWrapper](
+                PostCategoryGroupWrapper
+            ).validate_python(request.body),
+        )

ynab_api_cli/generated/api/categories/get_categories.py

@@ -0,0 +1,57 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.categories_response import CategoriesResponse
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response, Unset
+
+
+class Endpoint:
+    """Typed getCategories operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        last_knowledge_of_server: int | Unset = UNSET,
+    ) -> Response[CategoriesResponse | ErrorResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getCategories",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                },
+                query={
+                    "last_knowledge_of_server": last_knowledge_of_server,
+                },
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = CategoriesResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[CategoriesResponse | ErrorResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            last_knowledge_of_server=request.value(
+                "query",
+                "last_knowledge_of_server",
+                TypeAdapter[int | Unset](int | Unset),
+            ),
+        )

ynab_api_cli/generated/api/categories/get_category_by_id.py

@@ -0,0 +1,52 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.category_response import CategoryResponse
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response
+
+
+class Endpoint:
+    """Typed getCategoryById operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        category_id: str,
+    ) -> Response[CategoryResponse | ErrorResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getCategoryById",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "category_id": category_id,
+                },
+                query={},
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = CategoryResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[CategoryResponse | ErrorResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            category_id=request.value("path", "category_id", TypeAdapter[str](str)),
+        )

ynab_api_cli/generated/api/categories/get_month_category_by_id.py

@@ -0,0 +1,58 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+import datetime
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.category_response import CategoryResponse
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response
+
+
+class Endpoint:
+    """Typed getMonthCategoryById operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        month: datetime.date,
+        category_id: str,
+    ) -> Response[CategoryResponse | ErrorResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getMonthCategoryById",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "month": month,
+                    "category_id": category_id,
+                },
+                query={},
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = CategoryResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[CategoryResponse | ErrorResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            month=request.value(
+                "path", "month", TypeAdapter[datetime.date](datetime.date)
+            ),
+            category_id=request.value("path", "category_id", TypeAdapter[str](str)),
+        )

ynab_api_cli/generated/api/categories/update_category.py

@@ -0,0 +1,57 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.patch_category_wrapper import PatchCategoryWrapper
+from ynab_api_cli.generated.models.save_category_response import SaveCategoryResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import RequestValues, Response
+
+
+class Endpoint:
+    """Typed updateCategory operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        category_id: str,
+        body: PatchCategoryWrapper,
+    ) -> Response[ErrorResponse | SaveCategoryResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "updateCategory",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "category_id": category_id,
+                },
+                query={},
+                body=body,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = SaveCategoryResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | SaveCategoryResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            category_id=request.value("path", "category_id", TypeAdapter[str](str)),
+            body=TypeAdapter[PatchCategoryWrapper](
+                PatchCategoryWrapper
+            ).validate_python(request.body),
+        )