capo-keyspacesstreams 0.1.0__py3-none-any.whl

capo_keyspacesstreams/_services/_aws_config.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import configparser
+import functools
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TypeVar
+
+from capo_keyspacesstreams._services._pipeline import (
+    AsyncInterceptor,
+    AsyncNextFn,
+    AsyncOperationRequest,
+    AsyncOperationResponse,
+    Interceptor,
+    NextFn,
+    OperationRequest,
+    OperationResponse,
+)
+
+ENDPOINT_ENV_VAR = "AWS_ENDPOINT_URL_KEYSPACES_STREAMS"
+SERVICE_ID = "keyspaces_streams"
+TInput = TypeVar("TInput")
+TOutput = TypeVar("TOutput")
+
+
+@dataclass(frozen=True)
+class AwsSettings:
+    region: str | None
+    endpoint: str | None
+    use_fips: bool
+    use_dual_stack: bool
+    max_attempts: int
+
+
+def _env_bool(name: str) -> bool | None:
+    val = os.environ.get(name)
+    if val is None:
+        return None
+    return val.strip().lower() in ("true", "1")
+
+
+def _profile_bool(section: dict[str, str], key: str) -> bool | None:
+    val = section.get(key)
+    if val is None:
+        return None
+    return val.strip().lower() in ("true", "1")
+
+
+def config_file() -> Path:
+    raw_cfg = os.environ.get("AWS_CONFIG_FILE")
+    return Path(raw_cfg).expanduser() if raw_cfg else Path.home() / ".aws" / "config"
+
+
+def active_profile() -> str:
+    return (
+        os.environ.get("AWS_PROFILE")
+        or os.environ.get("AWS_DEFAULT_PROFILE")
+        or "default"
+    )
+
+
+def _load_profile(
+    profile: str | None = None,
+) -> tuple[dict[str, str], dict[str, dict[str, str]]]:
+    profile = profile or active_profile()
+    cfg_file = config_file()
+    merged: dict[str, str] = {}
+    services: dict[str, dict[str, str]] = {}
+    if cfg_file.is_file():
+        cfg = configparser.ConfigParser(interpolation=None)
+        cfg.read(cfg_file)
+        key = "default" if profile == "default" else f"profile {profile}"
+        if cfg.has_section(key):
+            merged.update(dict(cfg.items(key)))
+        services_name = merged.get("services")
+        if services_name and cfg.has_section(f"services {services_name}"):
+            raw = dict(cfg.items(f"services {services_name}"))
+            for svc, block in raw.items():
+                parsed: dict[str, str] = {}
+                for line in block.splitlines():
+                    stripped = line.strip()
+                    if "=" in stripped:
+                        k, _, val = stripped.partition("=")
+                        parsed[k.strip()] = val.strip()
+                services[svc] = parsed
+    return merged, services
+
+
+@functools.cache
+def load_aws_settings() -> AwsSettings:
+    profile, services = _load_profile()
+    region = os.environ.get("AWS_REGION") or profile.get("region")
+    endpoint = (
+        os.environ.get(ENDPOINT_ENV_VAR)
+        or os.environ.get("AWS_ENDPOINT_URL")
+        or services.get(SERVICE_ID, {}).get("endpoint_url")
+        or profile.get("endpoint_url")
+    )
+    use_fips: bool | None = _env_bool("AWS_USE_FIPS_ENDPOINT")
+    if use_fips is None:
+        use_fips = _profile_bool(profile, "use_fips_endpoint")
+    if use_fips is None:
+        use_fips = False
+    use_dual_stack: bool | None = _env_bool("AWS_USE_DUALSTACK_ENDPOINT")
+    if use_dual_stack is None:
+        use_dual_stack = _profile_bool(profile, "use_dualstack_endpoint")
+    if use_dual_stack is None:
+        use_dual_stack = False
+    max_attempts_raw = os.environ.get("AWS_MAX_ATTEMPTS") or profile.get("max_attempts")
+    max_attempts = int(max_attempts_raw) if max_attempts_raw else 3
+    return AwsSettings(
+        region=region,
+        endpoint=endpoint,
+        use_fips=use_fips,
+        use_dual_stack=use_dual_stack,
+        max_attempts=max_attempts,
+    )
+
+
+def aws_config() -> Interceptor[TInput, TOutput]:
+    def interceptor(
+        request: OperationRequest[TInput], next: NextFn[TInput, TOutput]
+    ) -> OperationResponse[TOutput]:
+        settings = load_aws_settings()
+        options = request.options
+        if options.region is None:
+            options.region = settings.region
+        if options.endpoint is None:
+            options.endpoint = settings.endpoint
+        if options.use_fips is None:
+            options.use_fips = settings.use_fips
+        if options.retry_max_attempts is None:
+            options.retry_max_attempts = settings.max_attempts
+        return next(request)
+
+    return interceptor
+
+
+def aaws_config() -> AsyncInterceptor[TInput, TOutput]:
+    async def interceptor(
+        request: AsyncOperationRequest[TInput], next: AsyncNextFn[TInput, TOutput]
+    ) -> AsyncOperationResponse[TOutput]:
+        settings = load_aws_settings()
+        options = request.options
+        if options.region is None:
+            options.region = settings.region
+        if options.endpoint is None:
+            options.endpoint = settings.endpoint
+        if options.use_fips is None:
+            options.use_fips = settings.use_fips
+        if options.retry_max_attempts is None:
+            options.retry_max_attempts = settings.max_attempts
+        return await next(request)
+
+    return interceptor

capo_keyspacesstreams/_services/_pipeline.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import random
+import time
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Awaitable, Callable, Generic, TypeVar
+
+from zapros import (
+    AsyncClient,
+    Client,
+    ConnectionError,
+    Response,
+    SSLError,
+    TimeoutError,
+)
+
+from capo_keyspacesstreams._async import anysleep
+from capo_keyspacesstreams.errors import ServiceError
+
+if TYPE_CHECKING:
+    from capo_keyspacesstreams._auth._identity import Credentials
+    from capo_keyspacesstreams._auth._providers import IdentityProvider
+
+TInput = TypeVar("TInput")
+TOutput = TypeVar("TOutput")
+
+
+@dataclass
+class OperationOptions:
+    client: Client
+    use_fips: bool | None = None
+    endpoint: str | None = None
+    region: str | None = None
+    retry_max_attempts: int | None = None
+    credentials_provider: IdentityProvider[Credentials] | None = None
+
+
+@dataclass
+class AsyncOperationOptions:
+    client: AsyncClient
+    use_fips: bool | None = None
+    endpoint: str | None = None
+    region: str | None = None
+    retry_max_attempts: int | None = None
+    credentials_provider: IdentityProvider[Credentials] | None = None
+
+
+@dataclass
+class OperationRequest(Generic[TInput]):
+    input: TInput
+    options: OperationOptions
+
+
+@dataclass
+class AsyncOperationRequest(Generic[TInput]):
+    input: TInput
+    options: AsyncOperationOptions
+
+
+@dataclass
+class OperationResponse(Generic[TOutput]):
+    output: TOutput
+    response: Response
+
+
+@dataclass
+class AsyncOperationResponse(Generic[TOutput]):
+    output: TOutput
+    response: Response
+
+
+NextFn = Callable[
+    [OperationRequest[TInput]],
+    OperationResponse[TOutput],
+]
+
+AsyncNextFn = Callable[
+    [AsyncOperationRequest[TInput]],
+    Awaitable[AsyncOperationResponse[TOutput]],
+]
+
+Interceptor = Callable[
+    [OperationRequest[TInput], NextFn[TInput, TOutput]],
+    OperationResponse[TOutput],
+]
+
+AsyncInterceptor = Callable[
+    [AsyncOperationRequest[TInput], AsyncNextFn[TInput, TOutput]],
+    Awaitable[AsyncOperationResponse[TOutput]],
+]
+
+
+def execute_pipeline(
+    request: OperationRequest[TInput],
+    handler: NextFn[TInput, TOutput],
+    interceptors: Sequence[Interceptor[TInput, TOutput]],
+) -> OperationResponse[TOutput]:
+    def make_chain(index: int) -> NextFn[TInput, TOutput]:
+        if index < len(interceptors):
+            interceptor = interceptors[index]
+
+            def next_fn(req: OperationRequest[TInput]) -> OperationResponse[TOutput]:
+                return interceptor(req, make_chain(index + 1))
+
+            return next_fn
+        return handler
+
+    return make_chain(0)(request)
+
+
+async def aexecute_pipeline(
+    request: AsyncOperationRequest[TInput],
+    handler: AsyncNextFn[TInput, TOutput],
+    interceptors: Sequence[AsyncInterceptor[TInput, TOutput]],
+) -> AsyncOperationResponse[TOutput]:
+    def make_chain(index: int) -> AsyncNextFn[TInput, TOutput]:
+        if index < len(interceptors):
+            interceptor = interceptors[index]
+
+            async def next_fn(
+                req: AsyncOperationRequest[TInput],
+            ) -> AsyncOperationResponse[TOutput]:
+                return await interceptor(req, make_chain(index + 1))
+
+            return next_fn
+        return handler
+
+    return await make_chain(0)(request)
+
+
+def _is_retryable(exc: Exception) -> bool:
+    if isinstance(exc, ServiceError):
+        return exc.is_retryable
+    if isinstance(exc, SSLError):
+        return False
+    if isinstance(exc, (ConnectionError, TimeoutError)):
+        return True
+    return False
+
+
+def _retry_delay(attempt: int, is_throttling: bool) -> float:
+    base = 1.0 if is_throttling else 0.5
+    delay = base * (2.0 ** min(attempt - 1, 10))
+    delay = min(20.0, delay)
+    return random.uniform(0.0, delay)
+
+
+def retry() -> Interceptor[TInput, TOutput]:
+    def interceptor(
+        request: OperationRequest[TInput], next: NextFn[TInput, TOutput]
+    ) -> OperationResponse[TOutput]:
+        max_attempts = request.options.retry_max_attempts or 3
+        last_exc: Exception | None = None
+        for attempt in range(1, max_attempts + 1):
+            try:
+                return next(request)
+            except Exception as exc:
+                if not _is_retryable(exc):
+                    raise
+                last_exc = exc
+                if attempt < max_attempts:
+                    is_throttling = (
+                        isinstance(exc, ServiceError) and exc.is_throttling_error
+                    )
+                    time.sleep(_retry_delay(attempt, is_throttling))
+
+        assert last_exc
+        raise last_exc
+
+    return interceptor
+
+
+def aretry() -> AsyncInterceptor[TInput, TOutput]:
+    async def interceptor(
+        request: AsyncOperationRequest[TInput], next: AsyncNextFn[TInput, TOutput]
+    ) -> AsyncOperationResponse[TOutput]:
+        max_attempts = request.options.retry_max_attempts or 3
+        last_exc: Exception | None = None
+        for attempt in range(1, max_attempts + 1):
+            try:
+                return await next(request)
+            except Exception as exc:
+                if not _is_retryable(exc):
+                    raise
+                last_exc = exc
+                if attempt < max_attempts:
+                    is_throttling = (
+                        isinstance(exc, ServiceError) and exc.is_throttling_error
+                    )
+                    await anysleep(_retry_delay(attempt, is_throttling))
+
+        assert last_exc
+        raise last_exc
+
+    return interceptor