capo-codecatalyst 0.1.0__py3-none-any.whl

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/_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/_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/_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/_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
+        )