capo-codecatalyst 0.1.0__tar.gz

capo_codecatalyst-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Karen Petrosyan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

capo_codecatalyst-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: capo-codecatalyst
+Version: 0.1.0
+Summary: Python SDK for Codecatalyst.
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: zapros>=0.13.0
+Dynamic: license-file
+
+# Getting Started
+
+## Installation
+
+```
+pip install capo-codecatalyst
+```
+
+## Usage
+
+```python
+from capo_codecatalyst import AsyncCodeCatalystClient
+
+
+async def main():
+    async with AsyncCodeCatalystClient() as code_catalyst:
+        # Example: call the get_user_details operation
+        response = await code_catalyst.get_user_details()
+        print(response["user_id"])
+```
+
+## Error Handling
+
+The SDK raises exceptions for errors returned by the API. Catch them to handle failures gracefully.
+
+```python
+from capo_codecatalyst import AsyncCodeCatalystClient
+from capo_codecatalyst.error import AccessDeniedException
+
+
+async def main():
+    async with AsyncCodeCatalystClient() as code_catalyst:
+        try:
+            await code_catalyst.get_user_details()
+        except AccessDeniedException as e:
+            print(f"Error: {e}")
+            print(e.data)  # additional error data
+```
+
+## Retrying
+
+The SDK retries failed operations automatically. Retry behaviour follows the Smithy specification: errors are retried based on their `is_retryable` and `is_throttling_error` attributes. Throttling errors use a longer base delay. Network-level failures (connection errors and timeouts) are also retried. Non-retryable errors, such as client errors without the `@retryable` trait, are raised immediately without further attempts.
+
+The number of attempts defaults to 3 and can be changed at the client level via `retry_max_attempts`, or per call via `config_overrides`.
+
+```python
+from capo_codecatalyst import AsyncCodeCatalystClient
+
+
+async def main():
+    async with AsyncCodeCatalystClient() as code_catalyst:
+        # Default: 3 attempts for every operation
+        response = await code_catalyst.get_user_details()
+
+        # Override per operation
+        response = await code_catalyst.get_user_details(config_overrides={"retry_max_attempts": 5})
+
+        # Disable retries for this call
+        response = await code_catalyst.get_user_details(config_overrides={"retry_max_attempts": 1})
+```

capo_codecatalyst-0.1.0/README.md

@@ -0,0 +1,60 @@
+# Getting Started
+
+## Installation
+
+```
+pip install capo-codecatalyst
+```
+
+## Usage
+
+```python
+from capo_codecatalyst import AsyncCodeCatalystClient
+
+
+async def main():
+    async with AsyncCodeCatalystClient() as code_catalyst:
+        # Example: call the get_user_details operation
+        response = await code_catalyst.get_user_details()
+        print(response["user_id"])
+```
+
+## Error Handling
+
+The SDK raises exceptions for errors returned by the API. Catch them to handle failures gracefully.
+
+```python
+from capo_codecatalyst import AsyncCodeCatalystClient
+from capo_codecatalyst.error import AccessDeniedException
+
+
+async def main():
+    async with AsyncCodeCatalystClient() as code_catalyst:
+        try:
+            await code_catalyst.get_user_details()
+        except AccessDeniedException as e:
+            print(f"Error: {e}")
+            print(e.data)  # additional error data
+```
+
+## Retrying
+
+The SDK retries failed operations automatically. Retry behaviour follows the Smithy specification: errors are retried based on their `is_retryable` and `is_throttling_error` attributes. Throttling errors use a longer base delay. Network-level failures (connection errors and timeouts) are also retried. Non-retryable errors, such as client errors without the `@retryable` trait, are raised immediately without further attempts.
+
+The number of attempts defaults to 3 and can be changed at the client level via `retry_max_attempts`, or per call via `config_overrides`.
+
+```python
+from capo_codecatalyst import AsyncCodeCatalystClient
+
+
+async def main():
+    async with AsyncCodeCatalystClient() as code_catalyst:
+        # Default: 3 attempts for every operation
+        response = await code_catalyst.get_user_details()
+
+        # Override per operation
+        response = await code_catalyst.get_user_details(config_overrides={"retry_max_attempts": 5})
+
+        # Disable retries for this call
+        response = await code_catalyst.get_user_details(config_overrides={"retry_max_attempts": 1})
+```

capo_codecatalyst-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "capo-codecatalyst"
+version = "0.1.0"
+description = "Python SDK for Codecatalyst."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Code Generators",
+    "Typing :: Typed",
+]
+dependencies = [
+    "zapros>=0.13.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[tool.ty.environment]
+python-version = "3.14"
+root = ["./src"]
+
+[tool.ty.src]
+include = ["src", "tests"]
+
+[tool.ty.rules]
+missing-typed-dict-key = "ignore"
+unused-type-ignore-comment = "ignore"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = ["E501", "E741"]
+
+[dependency-groups]
+dev = [
+    "inline-snapshot>=0.33.0",
+    # TODO: fix for 0.0.69
+    "ty==0.0.68",
+    "pytest>=9.0.3",
+    "ruff>=0.15.14",
+    "trio",
+]

capo_codecatalyst-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

capo_codecatalyst-0.1.0/src/capo_codecatalyst/__init__.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from . import _iter as _iter
+from . import _protocol as _protocol
+from ._auth._identity import BearerToken as BearerToken
+from ._auth._identity import Identity as Identity
+from ._auth._providers import (
+    BearerTokenProvider as BearerTokenProvider,
+)
+from ._auth._providers import (
+    CachedProvider as CachedProvider,
+)
+from ._auth._providers import (
+    ChainedProvider as ChainedProvider,
+)
+from ._auth._providers import (
+    IdentityNotFound as IdentityNotFound,
+)
+from ._auth._providers import (
+    IdentityProvider as IdentityProvider,
+)
+from ._auth._providers import (
+    SsoTokenCacheProvider as SsoTokenCacheProvider,
+)
+from ._auth._providers import (
+    StaticBearerTokenProvider as StaticBearerTokenProvider,
+)
+from ._auth._signers import HttpBearerSigner as HttpBearerSigner
+from ._auth._signers import Signer as Signer
+from ._services._pipeline import (
+    AsyncOperationOptions as AsyncOperationOptions,
+)
+from ._services._pipeline import (
+    AsyncOperationRequest as AsyncOperationRequest,
+)
+from ._services._pipeline import (
+    AsyncOperationResponse as AsyncOperationResponse,
+)
+from ._services._pipeline import (
+    OperationOptions as OperationOptions,
+)
+from ._services._pipeline import (
+    OperationRequest as OperationRequest,
+)
+from ._services._pipeline import (
+    OperationResponse as OperationResponse,
+)
+from ._services.async_code_catalyst import (
+    AsyncCodeCatalystClient as AsyncCodeCatalystClient,
+)
+from ._services.code_catalyst import CodeCatalystClient as CodeCatalystClient

capo_codecatalyst-0.1.0/src/capo_codecatalyst/_async.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import trio
+else:
+    try:
+        import trio
+    except ImportError:
+        trio = None
+
+
+def in_trio_run() -> bool:
+    if trio is None:
+        return False
+    return trio.lowlevel.in_trio_run()
+
+
+async def anysleep(delay: float) -> None:
+    if in_trio_run():
+        await trio.sleep(delay)
+    else:
+        await asyncio.sleep(delay)

capo_codecatalyst-0.1.0/src/capo_codecatalyst/_auth/_identity.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TypedDict
+
+from typing_extensions import NotRequired
+
+
+class Identity(TypedDict):
+    expiration: NotRequired[datetime | None]
+
+
+class BearerToken(Identity):
+    token: str

capo_codecatalyst-0.1.0/src/capo_codecatalyst/_auth/_providers.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import json
+from abc import abstractmethod
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Generic, TypeVar
+
+from capo_codecatalyst._auth._identity import (
+    BearerToken,
+    Identity,
+)
+
+
+class IdentityNotFound(Exception):
+    """Raised when a provider cannot resolve an identity. Chain continues."""
+
+
+IdentityT = TypeVar("IdentityT", bound="Identity")
+
+
+class IdentityProvider(Generic[IdentityT]):
+    @abstractmethod
+    def resolve_identity(self) -> IdentityT:
+        raise NotImplementedError
+
+    async def aresolve_identity(self) -> IdentityT:
+        # default: no network I/O, reuse the sync resolution
+        return self.resolve_identity()
+
+
+class ChainedProvider(IdentityProvider[IdentityT]):
+    """Try each provider in order; first non-`IdentityNotFound` wins."""
+
+    def __init__(self, *providers: IdentityProvider[IdentityT]) -> None:
+        if not providers:
+            raise ValueError("ChainedProvider requires at least one provider")
+        self._providers = providers
+
+    def resolve_identity(self) -> IdentityT:
+        errors: list[str] = []
+        for p in self._providers:
+            try:
+                return p.resolve_identity()
+            except IdentityNotFound as e:
+                errors.append(f"{type(p).__name__}: {e}")
+        raise IdentityNotFound("no provider succeeded: " + "; ".join(errors))
+
+    async def aresolve_identity(self) -> IdentityT:
+        errors: list[str] = []
+        for p in self._providers:
+            try:
+                return await p.aresolve_identity()
+            except IdentityNotFound as e:
+                errors.append(f"{type(p).__name__}: {e}")
+        raise IdentityNotFound("no provider succeeded: " + "; ".join(errors))
+
+
+class CachedProvider(IdentityProvider[IdentityT]):
+    """Cache an identity until its `expiration` (minus skew) elapses."""
+
+    _SKEW_SECONDS = 60
+
+    def __init__(self, inner: IdentityProvider[IdentityT]) -> None:
+        self._inner = inner
+        self._cached: IdentityT | None = None
+
+    def resolve_identity(self) -> IdentityT:
+        if self._cached is not None and not self._expired(self._cached):
+            return self._cached
+        self._cached = self._inner.resolve_identity()
+        return self._cached
+
+    async def aresolve_identity(self) -> IdentityT:
+        if self._cached is not None and not self._expired(self._cached):
+            return self._cached
+        self._cached = await self._inner.aresolve_identity()
+        return self._cached
+
+    @classmethod
+    def _expired(cls, ident: Identity) -> bool:
+        exp = ident.get("expiration")
+        if exp is None:
+            return False
+        return (exp - datetime.now(timezone.utc)).total_seconds() <= cls._SKEW_SECONDS
+
+
+class BearerTokenProvider(IdentityProvider[BearerToken]):
+    """Base class for providers that resolve a `BearerToken`."""
+
+    @abstractmethod
+    def resolve_identity(self) -> BearerToken:
+        raise NotImplementedError
+
+
+class StaticBearerTokenProvider(BearerTokenProvider):
+    def __init__(self, token: str) -> None:
+        self._token: BearerToken = {"token": token}
+
+    def resolve_identity(self) -> BearerToken:
+        return self._token
+
+
+class SsoTokenCacheProvider(BearerTokenProvider):
+    """Read a token cached by `aws sso login` from ~/.aws/sso/cache/."""
+
+    def __init__(
+        self, cache_dir: Path | None = None, session_name: str | None = None
+    ) -> None:
+        self._cache_dir = cache_dir or (Path.home() / ".aws" / "sso" / "cache")
+        self._session_name = session_name
+
+    def resolve_identity(self) -> BearerToken:
+        if not self._cache_dir.is_dir():
+            raise IdentityNotFound(f"SSO cache dir missing: {self._cache_dir}")
+
+        entry = self._select_entry()
+        if entry is None:
+            raise IdentityNotFound("no usable SSO cache entry")
+
+        token = entry.get("accessToken")
+        if not isinstance(token, str) or not token:
+            raise IdentityNotFound("SSO cache entry has no accessToken")
+
+        out: BearerToken = {"token": token}
+        exp = entry.get("expiresAt")
+        if isinstance(exp, str):
+            out["expiration"] = _parse_iso8601(exp)
+        return out
+
+    def _select_entry(self) -> dict[str, object] | None:
+        candidates: list[tuple[float, dict[str, object]]] = []
+        for path in self._cache_dir.glob("*.json"):
+            try:
+                data: dict[str, object] = json.loads(path.read_text())
+            except (OSError, json.JSONDecodeError):
+                continue
+            if self._session_name and data.get("sessionName") != self._session_name:
+                continue
+            if "accessToken" not in data:
+                continue
+            candidates.append((path.stat().st_mtime, data))
+        if not candidates:
+            return None
+        return max(candidates, key=lambda x: x[0])[1]
+
+
+def _parse_iso8601(value: str) -> datetime:
+    # tolerate trailing 'Z'
+    return datetime.fromisoformat(value.replace("Z", "+00:00"))
+
+
+def default_bearer_token_provider() -> IdentityProvider[BearerToken]:
+    return CachedProvider(SsoTokenCacheProvider())

capo_codecatalyst-0.1.0/src/capo_codecatalyst/_auth/_signers.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from zapros import Request
+
+from capo_codecatalyst._auth._identity import BearerToken, Identity
+from capo_codecatalyst._auth._providers import IdentityProvider
+
+IdentityT = TypeVar("IdentityT", bound="Identity")
+
+
+class Signer(ABC, Generic[IdentityT]):
+    """Per-request request signer. Holds an IdentityProvider plus static config."""
+
+    def __init__(self, provider: IdentityProvider[IdentityT]) -> None:
+        self.provider = provider
+
+    @abstractmethod
+    async def asign(self, req: Request) -> Request: ...
+    @abstractmethod
+    def sign(self, req: Request) -> Request: ...
+
+
+class HttpBearerSigner(Signer[BearerToken]):
+    """smithy.api#httpBearerAuth — RFC 6750 ``Authorization: Bearer <token>``."""
+
+    async def asign(self, req: Request) -> Request:
+        t = await self.provider.aresolve_identity()
+        headers = req.headers.copy()
+        headers["Authorization"] = f"Bearer {t['token']}"
+        return Request(
+            req.url, req.method, headers, body=req.body or b"", context=req.context
+        )
+
+    def sign(self, req: Request) -> Request:
+        t = self.provider.resolve_identity()
+        headers = req.headers.copy()
+        headers["Authorization"] = f"Bearer {t['token']}"
+        return Request(
+            req.url, req.method, headers, body=req.body or b"", context=req.context
+        )