capo-codecatalyst 0.1.0__py3-none-any.whl

capo_codecatalyst/_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_codecatalyst._services._pipeline import (
+    AsyncInterceptor,
+    AsyncNextFn,
+    AsyncOperationRequest,
+    AsyncOperationResponse,
+    Interceptor,
+    NextFn,
+    OperationRequest,
+    OperationResponse,
+)
+
+ENDPOINT_ENV_VAR = "AWS_ENDPOINT_URL_CODE_CATALYST"
+SERVICE_ID = "code_catalyst"
+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_codecatalyst/_services/_pipeline.py

@@ -0,0 +1,195 @@
+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_codecatalyst._async import anysleep
+from capo_codecatalyst.errors import ServiceError
+
+if TYPE_CHECKING:
+    from capo_codecatalyst._auth._providers import BearerTokenProvider
+
+TInput = TypeVar("TInput")
+TOutput = TypeVar("TOutput")
+
+
+@dataclass
+class OperationOptions:
+    client: Client
+    use_fips: bool | None = None
+    region: str | None = None
+    endpoint: str | None = None
+    retry_max_attempts: int | None = None
+    bearer_provider: BearerTokenProvider | None = None
+
+
+@dataclass
+class AsyncOperationOptions:
+    client: AsyncClient
+    use_fips: bool | None = None
+    region: str | None = None
+    endpoint: str | None = None
+    retry_max_attempts: int | None = None
+    bearer_provider: BearerTokenProvider | 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

capo_codecatalyst/_services/async_code_catalyst.py

@@ -0,0 +1,214 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#CodeCatalyst``."""
+
+import warnings
+from typing import TYPE_CHECKING, Any, Iterable, Optional
+
+from typing_extensions import Self, TypedDict
+from zapros import AsyncBaseHandler, AsyncClient
+
+import capo_codecatalyst._auth._signers
+import capo_codecatalyst._auth._sigv4
+from capo_codecatalyst._auth._providers import (
+    BearerTokenProvider,
+    StaticBearerTokenProvider,
+)
+from capo_codecatalyst._auth._zapros_handler import AuthMiddleware
+from capo_codecatalyst._resources.code_catalyst.access_token import AsyncAccessToken
+from capo_codecatalyst._resources.code_catalyst.space import AsyncSpace
+from capo_codecatalyst._services._aws_config import aaws_config
+from capo_codecatalyst._services._pipeline import (
+    AsyncInterceptor,
+    AsyncOperationOptions,
+    AsyncOperationRequest,
+    AsyncOperationResponse,
+    aexecute_pipeline,
+    aretry,
+)
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.get_user_details_request
+    import capo_codecatalyst.types.get_user_details_response
+    import capo_codecatalyst.types.verify_session_response
+
+
+class AsyncCodeCatalystClientConfig(TypedDict, total=False, closed=True):
+    operation_interceptors: Iterable[AsyncInterceptor[Any, Any]]
+    retry_max_attempts: int | None
+    use_fips: bool | None
+    region: str | None
+    endpoint: str | None
+    bearer_provider: BearerTokenProvider | None
+
+
+class AsyncCodeCatalystClient:
+    """A client for the ``CodeCatalyst`` service.
+
+    Args:
+        http_handler: HTTP handler for sending requests. If not provided, creates a default handler.
+        operation_interceptors: Interceptors that wrap every operation call. If not provided, defaults to an empty list.
+        retry_max_attempts: Maximum number of times to retry a failed operation. Defaults to 3.
+        use_fips: The value of the ``AWS::UseFIPS`` endpoint parameter.
+        region: The value of the ``AWS::Region`` endpoint parameter.
+        endpoint: The value of the ``SDK::Endpoint`` endpoint parameter.
+        bearer: Bearer token for authentication.
+        bearer_provider: Provider that resolves bearer tokens. Takes precedence over ``bearer``.
+    """
+
+    def __init__(
+        self,
+        http_handler: AsyncBaseHandler | None = None,
+        operation_interceptors: Iterable[AsyncInterceptor[Any, Any]] | None = None,
+        retry_max_attempts: int | None = None,
+        use_fips: bool | None = None,
+        region: str | None = None,
+        endpoint: str | None = None,
+        bearer: str | None = None,
+        bearer_provider: BearerTokenProvider | None = None,
+    ):
+        self._client = AsyncClient(http_handler).wrap_with_middleware(
+            lambda next: AuthMiddleware(next)
+        )
+        if bearer is not None and bearer_provider is not None:
+            warnings.warn(
+                "Both bearer and bearer_provider given; provider takes precedence"
+            )
+        if bearer_provider is None and bearer is not None:
+            bearer_provider = StaticBearerTokenProvider(bearer)
+        self._config = AsyncCodeCatalystClientConfig(
+            {
+                "operation_interceptors": operation_interceptors or [],
+                "retry_max_attempts": retry_max_attempts,
+                "use_fips": use_fips,
+                "region": region,
+                "endpoint": endpoint,
+                "bearer_provider": bearer_provider,
+            }
+        )
+
+        # resources
+        self.access_token = AsyncAccessToken(self)
+        self.space = AsyncSpace(self)
+
+    def operation_options(
+        self, config_overrides: Optional[AsyncCodeCatalystClientConfig] = None
+    ) -> tuple[Iterable[AsyncInterceptor[Any, Any]], AsyncOperationOptions]:
+        overrides: AsyncCodeCatalystClientConfig = config_overrides or {}
+        interceptors_: list[AsyncInterceptor[Any, Any]] = [
+            *overrides.get(
+                "operation_interceptors", self._config.get("operation_interceptors", [])
+            ),
+            aaws_config(),
+            aretry(),
+        ]
+        options_: AsyncOperationOptions = AsyncOperationOptions(
+            client=self._client,
+            retry_max_attempts=overrides.get(
+                "retry_max_attempts", self._config.get("retry_max_attempts")
+            ),
+            use_fips=overrides.get("use_fips", self._config.get("use_fips")),
+            region=overrides.get("region", self._config.get("region")),
+            endpoint=overrides.get("endpoint", self._config.get("endpoint")),
+            bearer_provider=overrides.get(
+                "bearer_provider", self._config.get("bearer_provider")
+            ),
+        )
+        return interceptors_, options_
+
+    async def get_user_details(
+        self,
+        *,
+        config_overrides: Optional[AsyncCodeCatalystClientConfig] = None,
+        id: Optional[str] = None,
+        user_name: Optional[str] = None,
+    ) -> "capo_codecatalyst.types.get_user_details_response.GetUserDetailsResponse":
+        """<p>Returns information about a user. </p>
+
+        Args:
+            id: <p>The system-generated unique ID of the user. </p>
+            user_name: <p>The name of the user as displayed in Amazon CodeCatalyst.</p>
+
+        Raises:
+            capo_codecatalyst.errors.access_denied_exception.AccessDeniedException: <p>The request was denied because you don't have sufficient access to perform this action. Verify that you are a member of a role that allows this action.</p>
+            capo_codecatalyst.errors.conflict_exception.ConflictException: <p>The request was denied because the requested operation would cause a conflict with the current state of a service resource associated with the request. Another user might have updated the resource. Reload, make sure you have the latest data, and then try again.</p>
+            capo_codecatalyst.errors.resource_not_found_exception.ResourceNotFoundException: <p>The request was denied because the specified resource was not found. Verify that the spelling is correct and that you have access to the resource.</p>
+            capo_codecatalyst.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request was denied because one or more resources has reached its limits for the tier the space belongs to. Either reduce the number of resources, or change the tier if applicable.</p>
+            capo_codecatalyst.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
+            capo_codecatalyst.errors.validation_exception.ValidationException: <p>The request was denied because an input failed to satisfy the constraints specified by the service. Check the spelling and input requirements, and then try again.</p>
+            capo_codecatalyst.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        async def _handler(
+            req: "AsyncOperationRequest[capo_codecatalyst.types.get_user_details_request.GetUserDetailsRequest]",
+        ) -> AsyncOperationResponse[
+            "capo_codecatalyst.types.get_user_details_response.GetUserDetailsResponse"
+        ]:
+            import capo_codecatalyst._operations.code_catalyst.get_user_details
+
+            (
+                output,
+                http_response,
+            ) = await capo_codecatalyst._operations.code_catalyst.get_user_details.async_get_user_details(
+                req.options, req.input
+            )
+            return AsyncOperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+        input_: capo_codecatalyst.types.get_user_details_request.GetUserDetailsRequest = {}
+        if id is not None:
+            input_["id"] = id
+        if user_name is not None:
+            input_["user_name"] = user_name
+
+        response = await aexecute_pipeline(
+            AsyncOperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        await response.response.aclose()
+        return response.output
+
+    async def verify_session(
+        self, *, config_overrides: Optional[AsyncCodeCatalystClientConfig] = None
+    ) -> "capo_codecatalyst.types.verify_session_response.VerifySessionResponse":
+        """<p>Verifies whether the calling user has a valid Amazon CodeCatalyst login and session. If successful, this returns the ID of the user in Amazon CodeCatalyst.</p>
+
+        Raises:
+            capo_codecatalyst.errors.access_denied_exception.AccessDeniedException: <p>The request was denied because you don't have sufficient access to perform this action. Verify that you are a member of a role that allows this action.</p>
+            capo_codecatalyst.errors.conflict_exception.ConflictException: <p>The request was denied because the requested operation would cause a conflict with the current state of a service resource associated with the request. Another user might have updated the resource. Reload, make sure you have the latest data, and then try again.</p>
+            capo_codecatalyst.errors.resource_not_found_exception.ResourceNotFoundException: <p>The request was denied because the specified resource was not found. Verify that the spelling is correct and that you have access to the resource.</p>
+            capo_codecatalyst.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request was denied because one or more resources has reached its limits for the tier the space belongs to. Either reduce the number of resources, or change the tier if applicable.</p>
+            capo_codecatalyst.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
+            capo_codecatalyst.errors.validation_exception.ValidationException: <p>The request was denied because an input failed to satisfy the constraints specified by the service. Check the spelling and input requirements, and then try again.</p>
+            capo_codecatalyst.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        async def _handler(
+            req: "AsyncOperationRequest[None]",
+        ) -> AsyncOperationResponse[
+            "capo_codecatalyst.types.verify_session_response.VerifySessionResponse"
+        ]:
+            import capo_codecatalyst._operations.code_catalyst.verify_session
+
+            (
+                output,
+                http_response,
+            ) = await capo_codecatalyst._operations.code_catalyst.verify_session.async_verify_session(
+                req.options
+            )
+            return AsyncOperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+
+        response = await aexecute_pipeline(
+            AsyncOperationRequest(input=None, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        await response.response.aclose()
+        return response.output
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any):
+        await self._client.aclose()