capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/types/update_package_versions_status_result.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#UpdatePackageVersionsStatusResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_version_error_map
+    import capo_codeartifact.types.successful_package_version_info_map
+
+
+class UpdatePackageVersionsStatusResult(TypedDict, closed=True):
+    successful_versions: NotRequired[
+        "capo_codeartifact.types.successful_package_version_info_map.SuccessfulPackageVersionInfoMap"
+    ]
+    """<p> A list of <code>PackageVersionError</code> objects, one for each package version with a status that failed to update. </p>"""
+    failed_versions: NotRequired[
+        "capo_codeartifact.types.package_version_error_map.PackageVersionErrorMap"
+    ]
+    """<p> A list of <code>SuccessfulPackageVersionInfo</code> objects, one for each package version with a status that successfully updated. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpdatePackageVersionsStatusResult) -> dict:
+    out: dict = {}
+    if "successful_versions" in value:
+        import capo_codeartifact.types.successful_package_version_info_map
+
+        out["successfulVersions"] = (
+            capo_codeartifact.types.successful_package_version_info_map.serialize_json(
+                value["successful_versions"]
+            )
+        )
+    if "failed_versions" in value:
+        import capo_codeartifact.types.package_version_error_map
+
+        out["failedVersions"] = (
+            capo_codeartifact.types.package_version_error_map.serialize_json(
+                value["failed_versions"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> UpdatePackageVersionsStatusResult:
+    out: UpdatePackageVersionsStatusResult = {}  # type: ignore[typeddict-item]
+    if data.get("successfulVersions") is not None:
+        import capo_codeartifact.types.successful_package_version_info_map
+
+        out["successful_versions"] = (
+            capo_codeartifact.types.successful_package_version_info_map.deserialize_json(
+                data["successfulVersions"]
+            )
+        )
+    if data.get("failedVersions") is not None:
+        import capo_codeartifact.types.package_version_error_map
+
+        out["failed_versions"] = (
+            capo_codeartifact.types.package_version_error_map.deserialize_json(
+                data["failedVersions"]
+            )
+        )
+    return out

capo_codeartifact/types/update_repository_request.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#UpdateRepositoryRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.description
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.repository_name
+    import capo_codeartifact.types.upstream_repository_list
+
+
+class UpdateRepositoryRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain associated with the repository to update. </p>"""
+    domain_owner: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p> The 12-digit account number of the Amazon Web Services account that owns the domain. It does not include dashes or spaces. </p>"""
+    repository: "capo_codeartifact.types.repository_name.RepositoryName"
+    """<p> The name of the repository to update. </p>"""
+    description: NotRequired["capo_codeartifact.types.description.Description"]
+    """<p> An updated repository description. </p>"""
+    upstreams: NotRequired[
+        "capo_codeartifact.types.upstream_repository_list.UpstreamRepositoryList"
+    ]
+    r"""<p> A list of upstream repositories to associate with the repository. The order of the upstream repositories in the list determines their priority order when CodeArtifact looks for a requested package version. For more information, see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/ug/repos-upstream.html\">Working with upstream repositories</a>. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpdateRepositoryRequest) -> dict:
+    out: dict = {}
+    if "description" in value:
+        out["description"] = value["description"]
+    if "upstreams" in value:
+        import capo_codeartifact.types.upstream_repository_list
+
+        out["upstreams"] = (
+            capo_codeartifact.types.upstream_repository_list.serialize_json(
+                value["upstreams"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> UpdateRepositoryRequest:
+    out: UpdateRepositoryRequest = {}  # type: ignore[typeddict-item]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("upstreams") is not None:
+        import capo_codeartifact.types.upstream_repository_list
+
+        out["upstreams"] = (
+            capo_codeartifact.types.upstream_repository_list.deserialize_json(
+                data["upstreams"]
+            )
+        )
+    return out

capo_codeartifact/types/update_repository_result.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#UpdateRepositoryResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.repository_description
+
+
+class UpdateRepositoryResult(TypedDict, closed=True):
+    repository: NotRequired[
+        "capo_codeartifact.types.repository_description.RepositoryDescription"
+    ]
+    """<p> The updated repository. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpdateRepositoryResult) -> dict:
+    out: dict = {}
+    if "repository" in value:
+        import capo_codeartifact.types.repository_description
+
+        out["repository"] = (
+            capo_codeartifact.types.repository_description.serialize_json(
+                value["repository"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> UpdateRepositoryResult:
+    out: UpdateRepositoryResult = {}  # type: ignore[typeddict-item]
+    if data.get("repository") is not None:
+        import capo_codeartifact.types.repository_description
+
+        out["repository"] = (
+            capo_codeartifact.types.repository_description.deserialize_json(
+                data["repository"]
+            )
+        )
+    return out

capo_codeartifact/types/upstream_repository.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#UpstreamRepository``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codeartifact.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.repository_name
+
+
+class UpstreamRepository(TypedDict, closed=True):
+    repository_name: "capo_codeartifact.types.repository_name.RepositoryName"
+    """<p> The name of an upstream repository. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpstreamRepository) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> UpstreamRepository:
+    out: UpstreamRepository = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("UpstreamRepository.repository_name required")
+    return out

capo_codeartifact/types/upstream_repository_info.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#UpstreamRepositoryInfo``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.repository_name
+
+
+class UpstreamRepositoryInfo(TypedDict, closed=True):
+    repository_name: NotRequired[
+        "capo_codeartifact.types.repository_name.RepositoryName"
+    ]
+    """<p> The name of an upstream repository. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpstreamRepositoryInfo) -> dict:
+    out: dict = {}
+    if "repository_name" in value:
+        out["repositoryName"] = value["repository_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> UpstreamRepositoryInfo:
+    out: UpstreamRepositoryInfo = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    return out

capo_codeartifact/types/upstream_repository_info_list.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#UpstreamRepositoryInfoList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.upstream_repository_info
+
+UpstreamRepositoryInfoList: TypeAlias = list[
+    "capo_codeartifact.types.upstream_repository_info.UpstreamRepositoryInfo"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpstreamRepositoryInfoList) -> list:
+    import capo_codeartifact.types.upstream_repository_info
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_codeartifact.types.upstream_repository_info.serialize_json(item)
+        )
+    return out
+
+
+def deserialize_json(data: list) -> UpstreamRepositoryInfoList:
+    import capo_codeartifact.types.upstream_repository_info
+
+    out: UpstreamRepositoryInfoList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codeartifact.types.upstream_repository_info.deserialize_json(item)
+        )
+    return out

capo_codeartifact/types/upstream_repository_list.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#UpstreamRepositoryList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.upstream_repository
+
+UpstreamRepositoryList: TypeAlias = list[
+    "capo_codeartifact.types.upstream_repository.UpstreamRepository"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UpstreamRepositoryList) -> list:
+    import capo_codeartifact.types.upstream_repository
+
+    out: list = []
+    for item in value:
+        out.append(capo_codeartifact.types.upstream_repository.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> UpstreamRepositoryList:
+    import capo_codeartifact.types.upstream_repository
+
+    out: UpstreamRepositoryList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_codeartifact.types.upstream_repository.deserialize_json(item))
+    return out

capo_codeartifact/types/validation_exception_reason.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ValidationExceptionReason``."""
+
+from typing import Literal, TypeAlias, cast
+
+ValidationExceptionReason: TypeAlias = Literal[
+    "CANNOT_PARSE",
+    "ENCRYPTION_KEY_ERROR",
+    "FIELD_VALIDATION_FAILED",
+    "UNKNOWN_OPERATION",
+    "OTHER",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ValidationExceptionReason) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ValidationExceptionReason:
+    return cast(ValidationExceptionReason, data)

capo_codeartifact-0.1.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: capo-codeartifact
+Version: 0.1.0
+Summary: Python SDK for Codeartifact.
+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
+Provides-Extra: sso
+Requires-Dist: capo-sso>=0.2.0; extra == "sso"
+Requires-Dist: capo-sso-oidc>=0.2.0; extra == "sso"
+Requires-Dist: capo-sts>=0.3.0; extra == "sso"
+Dynamic: license-file
+
+# Getting Started
+
+## Installation
+
+```
+pip install capo-codeartifact
+```
+
+## Usage
+
+```python
+from capo_codeartifact import AsynccodeartifactClient
+
+
+async def main():
+    async with AsynccodeartifactClient() as codeartifact:
+        # Example: call the associate_external_connection operation
+        response = await codeartifact.associate_external_connection()
+        print(response["repository"])
+```
+
+## Pagination
+
+Some operations in this SDK support pagination. If the operation supports pagination it will have an `iter_` prefixed method that returns an async iterator.
+
+```python
+from capo_codeartifact import AsynccodeartifactClient
+
+
+async def main():
+    async with AsynccodeartifactClient() as codeartifact:
+        # Example: paginate over list_allowed_repositories_for_group
+        async for item in codeartifact.iter_list_allowed_repositories_for_group():
+            print(item)
+```
+
+## Streaming Request
+
+Some operations accept a streaming request body. Pass an async iterator of `bytes` chunks, or the whole body as `bytes`, for the streaming parameter.
+
+```python
+from capo_codeartifact import AsynccodeartifactClient
+
+
+async def main():
+    async with AsynccodeartifactClient() as codeartifact:
+        # Example: call publish_package_version with a streaming request body
+        async def chunks():
+            yield b'Hello, World!'
+
+        response = await codeartifact.publish_package_version(asset_content=chunks())
+        print(response)
+
+        # Or pass the whole body as bytes
+        response = await codeartifact.publish_package_version(asset_content=b'Hello, World!')
+        print(response)
+```
+
+## Streaming Response
+
+Some operations return a streaming response body. Use the operation as an async context manager and iterate over the response field to read chunks.
+
+```python
+from capo_codeartifact import AsynccodeartifactClient
+
+
+async def main():
+    async with AsynccodeartifactClient() as codeartifact:
+        # Example: call get_package_version_asset and read the streaming response
+        async with codeartifact.get_package_version_asset() as response:
+            async for chunk in response["asset"]:
+                print(chunk)
+```
+
+## Error Handling
+
+The SDK raises exceptions for errors returned by the API. Catch them to handle failures gracefully.
+
+```python
+from capo_codeartifact import AsynccodeartifactClient
+from capo_codeartifact.error import AccessDeniedException
+
+
+async def main():
+    async with AsynccodeartifactClient() as codeartifact:
+        try:
+            await codeartifact.associate_external_connection()
+        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_codeartifact import AsynccodeartifactClient
+
+
+async def main():
+    async with AsynccodeartifactClient() as codeartifact:
+        # Default: 3 attempts for every operation
+        response = await codeartifact.associate_external_connection()
+
+        # Override per operation
+        response = await codeartifact.associate_external_connection(config_overrides={"retry_max_attempts": 5})
+
+        # Disable retries for this call
+        response = await codeartifact.associate_external_connection(config_overrides={"retry_max_attempts": 1})
+```