capo-codeartifact 0.1.0__tar.gz → 0.2.0__tar.gz

{capo_codeartifact-0.1.0/src/capo_codeartifact.egg-info → capo_codeartifact-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capo-codeartifact
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python SDK for Codeartifact.
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -18,6 +18,8 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: zapros>=0.13.0
+Provides-Extra: anyio
+Requires-Dist: anyio>=3.0; extra == "anyio"
 Provides-Extra: sso
 Requires-Dist: capo-sso>=0.2.0; extra == "sso"
 Requires-Dist: capo-sso-oidc>=0.2.0; extra == "sso"
@@ -64,8 +66,10 @@ async def main():
 
 Some operations accept a streaming request body. Pass an async iterator of `bytes` chunks, or the whole body as `bytes`, for the streaming parameter.
 
+A plain iterator can be sent only once, so if a request fails after its body was transmitted the operation is not retried. To get retries for streamed uploads, pass a `Body` instead: it wraps a source that can be reopened, and every attempt streams a fresh copy. `Body.from_path` (sync client) and `Body.async_from_path` (async client, needs `anyio`) stream a file from disk; `Body(opener)` takes any context manager that yields a `(stream, length)` pair.
+
 ```python
-from capo_codeartifact import AsynccodeartifactClient
+from capo_codeartifact import AsynccodeartifactClient, Body
 
 
 async def main():
@@ -80,6 +84,11 @@ async def main():
         # Or pass the whole body as bytes
         response = await codeartifact.publish_package_version(asset_content=b'Hello, World!')
         print(response)
+
+        # Or stream a file with Body: the file is reopened on every retry
+        # and Content-Length is taken from its size, so no content_length needed
+        response = await codeartifact.publish_package_version(asset_content=Body.async_from_path("hello.txt"))
+        print(response)
 ```
 
 ## Streaming Response

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/README.md

@@ -38,8 +38,10 @@ async def main():
 
 Some operations accept a streaming request body. Pass an async iterator of `bytes` chunks, or the whole body as `bytes`, for the streaming parameter.
 
+A plain iterator can be sent only once, so if a request fails after its body was transmitted the operation is not retried. To get retries for streamed uploads, pass a `Body` instead: it wraps a source that can be reopened, and every attempt streams a fresh copy. `Body.from_path` (sync client) and `Body.async_from_path` (async client, needs `anyio`) stream a file from disk; `Body(opener)` takes any context manager that yields a `(stream, length)` pair.
+
 ```python
-from capo_codeartifact import AsynccodeartifactClient
+from capo_codeartifact import AsynccodeartifactClient, Body
 
 
 async def main():
@@ -54,6 +56,11 @@ async def main():
         # Or pass the whole body as bytes
         response = await codeartifact.publish_package_version(asset_content=b'Hello, World!')
         print(response)
+
+        # Or stream a file with Body: the file is reopened on every retry
+        # and Content-Length is taken from its size, so no content_length needed
+        response = await codeartifact.publish_package_version(asset_content=Body.async_from_path("hello.txt"))
+        print(response)
 ```
 
 ## Streaming Response

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "capo-codeartifact"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python SDK for Codeartifact."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -23,6 +23,8 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+# Async file request bodies via Body.async_from_path
+anyio = ["anyio>=3.0"]
 # IAM Identity Center (SSO), assume-role and web-identity credentials providers
 sso = [
     "capo-sso>=0.2.0",

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/src/capo_codeartifact/__init__.py

@@ -48,6 +48,7 @@ from ._auth._providers import (
 )
 from ._auth._signers import Signer as Signer
 from ._auth._signers import SigV4Signer as SigV4Signer
+from ._body import Body as Body
 from ._services._pipeline import (
     AsyncOperationOptions as AsyncOperationOptions,
 )

capo_codeartifact-0.2.0/src/capo_codeartifact/_body.py

@@ -0,0 +1,221 @@
+"""Request body abstraction for streaming operations.
+
+Hand-written, not regenerated.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncIterator, Callable, Iterator
+from contextlib import (
+    AbstractAsyncContextManager,
+    AbstractContextManager,
+    asynccontextmanager,
+    contextmanager,
+)
+from typing import TYPE_CHECKING, Generic, TypeVar, Union, cast
+
+from ._iter import AnyIterator
+
+if TYPE_CHECKING:
+    import anyio
+else:
+    try:
+        import anyio
+    except ImportError:
+        anyio = None
+
+_CHUNK_SIZE = 64 * 1024
+
+TStream = TypeVar("TStream", Iterator[bytes], AsyncIterator[bytes])
+
+# The opener yields the fresh stream together with its length, or ``None`` when
+# no stream could be produced (an exhausted or non-rewindable source, or logic
+# that decides dynamically it cannot reopen). Pairing the length with each open
+# lets it change between rebuilds instead of being fixed for the whole body.
+_ContextManager = Union[
+    AbstractContextManager[Union[tuple[TStream, int], None]],
+    AbstractAsyncContextManager[Union[tuple[TStream, int], None]],
+]
+
+
+class Body(AnyIterator[bytes], Generic[TStream]):
+    """A replayable request body whose length travels with each open.
+
+    A plain ``Iterator[bytes]`` can be sent only once, so a failed request
+    cannot be retried. A ``Body`` instead holds an *opener* — a context manager
+    that opens a fresh stream over the same source — and rebuilds the stream
+    before every attempt, closing whatever was left of the previous one.
+
+    ``TStream`` is ``Iterator[bytes]`` for bodies built with :meth:`from_path`
+    and ``AsyncIterator[bytes]`` for :meth:`async_from_path`; the former use
+    ``rebuild()``/``close()``, the latter ``arebuild()``/``aclose()``.
+    ``build_request`` rebuilds before every attempt.
+
+    Each open produces ``(stream, length)`` together, so the length is not bound
+    to the whole body and may differ from one rebuild to the next. A rebuild is
+    also not guaranteed to succeed: the source may be exhausted or
+    non-rewindable, so the opener can yield ``None`` and :meth:`rebuild` then
+    returns ``None`` instead of a pair. Callers check the return value::
+
+        for attempt in range(max_attempts):
+            opened = body.rebuild()
+            if opened is None:
+                raise RuntimeError("body could not be rebuilt")
+            stream, length = opened
+            send(stream, length)
+
+    ``length`` also holds the current stream's length as an attribute (``None``
+    before the first rebuild). Iterating a ``Body`` reads its current stream.
+    """
+
+    def __init__(self, opener: Callable[[], _ContextManager[TStream]]) -> None:
+        self._opener = opener
+        self._cm: _ContextManager[TStream] | None = None
+        self._stream: TStream | None = None
+        self.length: int | None = None
+
+    @classmethod
+    def from_path(
+        cls, path: str | os.PathLike[str], chunk_size: int = _CHUNK_SIZE
+    ) -> Body[Iterator[bytes]]:
+        """A body that reads ``path`` in ``chunk_size`` chunks, reopening it (and re-measuring it) on every rebuild."""
+
+        @contextmanager
+        def open_() -> Iterator[tuple[Iterator[bytes], int]]:
+            with open(path, "rb") as file:
+                length = os.fstat(file.fileno()).st_size
+                yield iter(lambda: file.read(chunk_size), b""), length
+
+        return Body(open_)
+
+    @classmethod
+    def async_from_path(
+        cls, path: str | os.PathLike[str], chunk_size: int = _CHUNK_SIZE
+    ) -> Body[AsyncIterator[bytes]]:
+        """The async counterpart of :meth:`from_path`; needs ``anyio`` installed."""
+        if anyio is None:
+            dist = (__package__ or "capo").replace("_", "-")
+            raise RuntimeError(
+                "Body.async_from_path() requires the anyio package; "
+                f"reinstall with the anyio feature enabled: {dist}[anyio]"
+            )
+
+        @asynccontextmanager
+        async def open_() -> AsyncIterator[tuple[AsyncIterator[bytes], int]]:
+            async with await anyio.open_file(path, "rb") as file:
+                length = os.fstat(file.wrapped.fileno()).st_size
+
+                async def chunks() -> AsyncIterator[bytes]:
+                    while chunk := await file.read(chunk_size):
+                        yield chunk
+
+                yield chunks(), length
+
+        return Body(open_)
+
+    @property
+    def stream(self) -> TStream | None:
+        """The current open stream, or ``None`` if none is open (before the first
+        rebuild, or after a close).
+
+        ``build_request`` reuses a non-``None`` stream instead of rebuilding, so
+        the retry layer stays in control of when a fresh stream is created.
+        """
+        return self._stream
+
+    def rebuild(self: Body[Iterator[bytes]]) -> tuple[Iterator[bytes], int] | None:
+        """Reopen the stream, closing any previous one, and return ``(stream, length)``.
+
+        ``None`` if the source could not be reopened.
+        """
+        self.close()
+        cm = self._opener()
+        if not isinstance(cm, AbstractContextManager):
+            raise TypeError(
+                "this Body has an async opener; use it with the async client (arebuild/aclose)"
+            )
+        cm = cast(AbstractContextManager["tuple[Iterator[bytes], int] | None"], cm)
+        opened = cm.__enter__()
+        if opened is None:
+            cm.__exit__(None, None, None)
+            return None
+        stream, length = opened
+        self._stream, self.length, self._cm = stream, length, cm
+        return stream, length
+
+    async def arebuild(
+        self: Body[AsyncIterator[bytes]],
+    ) -> tuple[AsyncIterator[bytes], int] | None:
+        """Async :meth:`rebuild`, returning ``(stream, length)`` or ``None``."""
+        await self.aclose()
+        cm = self._opener()
+        if not isinstance(cm, AbstractAsyncContextManager):
+            raise TypeError(
+                "this Body has a sync opener; use it with the sync client (rebuild/close)"
+            )
+        cm = cast(
+            AbstractAsyncContextManager["tuple[AsyncIterator[bytes], int] | None"], cm
+        )
+        opened = await cm.__aenter__()
+        if opened is None:
+            await cm.__aexit__(None, None, None)
+            return None
+        stream, length = opened
+        self._stream, self.length, self._cm = stream, length, cm
+        return stream, length
+
+    def close(self: Body[Iterator[bytes]]) -> None:
+        cm, self._cm, self._stream, self.length = self._cm, None, None, None
+        if cm is not None:
+            cast(AbstractContextManager[object], cm).__exit__(None, None, None)
+
+    async def aclose(self: Body[AsyncIterator[bytes]]) -> None:
+        cm, self._cm, self._stream, self.length = self._cm, None, None, None
+        if cm is not None:
+            await cast(AbstractAsyncContextManager[object], cm).__aexit__(
+                None, None, None
+            )
+
+    def __next__(self) -> bytes:
+        if self._stream is None:
+            raise RuntimeError("body has no open stream; call rebuild() first")
+        return next(cast(Iterator[bytes], self._stream))
+
+    async def __anext__(self) -> bytes:
+        if self._stream is None:
+            raise RuntimeError("body has no open stream; call rebuild() first")
+        return await cast(AsyncIterator[bytes], self._stream).__anext__()
+
+
+@contextmanager
+def closing_bodies(inp: object) -> Iterator[None]:
+    """Close every :class:`Body` in a request input when the operation finishes.
+
+    The operation method wraps its whole run (request build across retries, plus
+    response handling) in this, so a ``Body``'s stream is released once — and only
+    once — the operation is done. Non-``Body`` values (bytes, plain iterators,
+    ``StaticAnyIterator``) are left untouched.
+    """
+    try:
+        yield
+    finally:
+        if isinstance(inp, dict):
+            for value in inp.values():
+                if isinstance(value, Body):
+                    cast("Body[Iterator[bytes]]", value).close()
+
+
+@asynccontextmanager
+async def aclosing_bodies(inp: object) -> AsyncIterator[None]:
+    """Async :func:`closing_bodies`, awaiting :meth:`Body.aclose`."""
+    try:
+        yield
+    finally:
+        if isinstance(inp, dict):
+            for value in inp.values():
+                if isinstance(value, Body):
+                    await cast("Body[AsyncIterator[bytes]]", value).aclose()
+
+
+__all__ = ["Body", "aclosing_bodies", "closing_bodies"]

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/src/capo_codeartifact/_operations/code_artifact_control_plane_service/publish_package_version.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+from collections.abc import AsyncIterator, Iterator
 from typing import Any, cast
 
 import zapros
@@ -10,6 +11,7 @@ from typing_extensions import Never
 
 import capo_codeartifact._auth._signers
 import capo_codeartifact._auth._sigv4
+import capo_codeartifact._body
 import capo_codeartifact._protocol.eventstream
 import capo_codeartifact.errors.access_denied_exception
 import capo_codeartifact.errors.conflict_exception
@@ -158,6 +160,86 @@ def build_request(
     if "asset_sha256" in input_:
         headers["x-amz-content-sha256"] = input_["asset_sha256"]
     body = input_["asset_content"]
+    if isinstance(body, capo_codeartifact._body.Body):
+        body = cast(capo_codeartifact._body.Body[Iterator[bytes]], body)
+        stream = body.stream
+        if stream is None:
+            rebuilt = body.rebuild()
+            if rebuilt is None:
+                raise RuntimeError("streaming body could not be rebuilt")
+            stream, _ = rebuilt
+        if "content-length" not in [header.lower() for header in headers]:
+            headers["Content-Length"] = str(body.length)
+        body = stream
+    if isinstance(body, capo_codeartifact._iter.StaticAnyIterator):
+        body = cast(bytes, body.content)
+    if not isinstance(body, bytes) and "content-length" not in [
+        header.lower() for header in headers
+    ]:
+        raise ValueError("Content-Length is required for streaming input")
+    signer = get_signer(options, auth_schemes=endpoint.properties.get("authSchemes"))
+    normalized_url = zapros.URL(url)
+    for k, v in params:
+        normalized_url.search_params.append(k, v)
+    return zapros.Request(
+        normalized_url, "POST", headers=headers, body=body, context={"signer": signer}
+    )
+
+
+async def async_build_request(
+    options: OperationOptions | AsyncOperationOptions,
+    input_: capo_codeartifact.types.publish_package_version_request.PublishPackageVersionRequest,
+) -> zapros.Request:
+    endpoint = resolve(
+        EndpointParams(
+            Region=options.region,
+            UseDualStack=options.use_dual_stack,
+            UseFIPS=options.use_fips,
+            Endpoint=options.endpoint,
+        )
+    )  # noqa: F841
+    import capo_codeartifact.types.package_format
+
+    url = endpoint.url.rstrip("/") + "/v1/package/version/publish"
+    params: list[tuple[str, str]] = []
+    if "domain" in input_:
+        params.append(("domain", input_["domain"]))
+    if "domain_owner" in input_:
+        params.append(("domain-owner", input_["domain_owner"]))
+    if "repository" in input_:
+        params.append(("repository", input_["repository"]))
+    if "format" in input_:
+        params.append(
+            (
+                "format",
+                capo_codeartifact.types.package_format.serialize_json(input_["format"]),
+            )
+        )
+    if "namespace" in input_:
+        params.append(("namespace", input_["namespace"]))
+    if "package" in input_:
+        params.append(("package", input_["package"]))
+    if "package_version" in input_:
+        params.append(("version", input_["package_version"]))
+    if "asset_name" in input_:
+        params.append(("asset", input_["asset_name"]))
+    if "unfinished" in input_:
+        params.append(("unfinished", "true" if input_["unfinished"] else "false"))
+    headers: dict[str, str] = {k: ", ".join(v) for k, v in endpoint.headers.items()}
+    if "asset_sha256" in input_:
+        headers["x-amz-content-sha256"] = input_["asset_sha256"]
+    body = input_["asset_content"]
+    if isinstance(body, capo_codeartifact._body.Body):
+        body = cast(capo_codeartifact._body.Body[AsyncIterator[bytes]], body)
+        stream = body.stream
+        if stream is None:
+            rebuilt = await body.arebuild()
+            if rebuilt is None:
+                raise RuntimeError("streaming body could not be rebuilt")
+            stream, _ = rebuilt
+        if "content-length" not in [header.lower() for header in headers]:
+            headers["Content-Length"] = str(body.length)
+        body = stream
     if isinstance(body, capo_codeartifact._iter.StaticAnyIterator):
         body = cast(bytes, body.content)
     if not isinstance(body, bytes) and "content-length" not in [
@@ -198,7 +280,9 @@ async def async_publish_package_version(
     capo_codeartifact.types.publish_package_version_result.PublishPackageVersionResult,
     zapros.Response,
 ]:
-    response = await options.client.handler.ahandle(build_request(options, input_))
+    response = await options.client.handler.ahandle(
+        await async_build_request(options, input_)
+    )
     try:
         if response.status >= 300:
             await response.aread()

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/src/capo_codeartifact/_services/_pipeline.py

@@ -2,20 +2,24 @@ from __future__ import annotations
 
 import random
 import time
-from collections.abc import Sequence
+from collections.abc import AsyncIterator, Iterator, Sequence
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Awaitable, Callable, Generic, TypeVar
+from typing import TYPE_CHECKING, Awaitable, Callable, Generic, TypeVar, cast
 
 from zapros import (
     AsyncClient,
     Client,
     ConnectionError,
+    ConnectTimeoutError,
+    PoolTimeoutError,
     Response,
     SSLError,
     TimeoutError,
 )
 
 from capo_codeartifact._async import anysleep
+from capo_codeartifact._body import Body
+from capo_codeartifact._iter import StaticAnyIterator
 from capo_codeartifact.errors import ServiceError
 
 if TYPE_CHECKING:
@@ -141,6 +145,43 @@ def _is_retryable(exc: Exception) -> bool:
     return False
 
 
+def _is_pre_transmission(exc: Exception) -> bool:
+    # True when the request body was certainly not written before the error,
+    # so the same stream can be reused as-is. A bare ConnectionError is
+    # ambiguous ("cannot be established or is lost"), so it does not qualify.
+    return isinstance(exc, (ConnectTimeoutError, PoolTimeoutError))
+
+
+def _prepare_retry(inp: object) -> bool:
+    if not isinstance(inp, dict):
+        return True
+    for value in inp.values():
+        if isinstance(value, Body):
+            value = cast(Body[Iterator[bytes]], value)
+            if value.rebuild() is None:
+                return False
+        elif isinstance(value, StaticAnyIterator):
+            continue
+        elif isinstance(value, (Iterator, AsyncIterator)):
+            return False
+    return True
+
+
+async def _aprepare_retry(inp: object) -> bool:
+    if not isinstance(inp, dict):
+        return True
+    for value in inp.values():
+        if isinstance(value, Body):
+            value = cast(Body[AsyncIterator[bytes]], value)
+            if await value.arebuild() is None:
+                return False
+        elif isinstance(value, StaticAnyIterator):
+            continue
+        elif isinstance(value, (Iterator, AsyncIterator)):
+            return False
+    return True
+
+
 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))
@@ -162,6 +203,10 @@ def retry() -> Interceptor[TInput, TOutput]:
                     raise
                 last_exc = exc
                 if attempt < max_attempts:
+                    if not _is_pre_transmission(exc) and not _prepare_retry(
+                        request.input
+                    ):
+                        raise
                     is_throttling = (
                         isinstance(exc, ServiceError) and exc.is_throttling_error
                     )
@@ -187,6 +232,10 @@ def aretry() -> AsyncInterceptor[TInput, TOutput]:
                     raise
                 last_exc = exc
                 if attempt < max_attempts:
+                    if not _is_pre_transmission(exc) and not await _aprepare_retry(
+                        request.input
+                    ):
+                        raise
                     is_throttling = (
                         isinstance(exc, ServiceError) and exc.is_throttling_error
                     )

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/src/capo_codeartifact/_services/async_codeartifact.py

@@ -18,6 +18,7 @@ from capo_codeartifact._auth._providers import (
     default_aws_credentials_chain,
 )
 from capo_codeartifact._auth._zapros_handler import AuthMiddleware
+from capo_codeartifact._body import Body, aclosing_bodies
 from capo_codeartifact._iter import ensure_async_iterator
 from capo_codeartifact._pagination import resolve_path as _resolve_path
 from capo_codeartifact._services._aws_config import aaws_config
@@ -3190,7 +3191,7 @@ class AsynccodeartifactClient:
         format: "capo_codeartifact.types.package_format.PackageFormat",
         package: "capo_codeartifact.types.package_name.PackageName",
         package_version: "capo_codeartifact.types.package_version.PackageVersion",
-        asset_content: AsyncIterator[bytes] | bytes,
+        asset_content: Body[AsyncIterator[bytes]] | AsyncIterator[bytes] | bytes,
         asset_name: "capo_codeartifact.types.asset_name.AssetName",
         asset_sha256: "capo_codeartifact.types.sha256.SHA256",
         *,
@@ -3262,13 +3263,14 @@ class AsynccodeartifactClient:
         if unfinished is not None:
             input_["unfinished"] = unfinished
 
-        response = await aexecute_pipeline(
-            AsyncOperationRequest(input=input_, options=options_),
-            handler=_handler,
-            interceptors=list(interceptors_),
-        )
-        await response.response.aclose()
-        return response.output
+        async with aclosing_bodies(input_):
+            response = await aexecute_pipeline(
+                AsyncOperationRequest(input=input_, options=options_),
+                handler=_handler,
+                interceptors=list(interceptors_),
+            )
+            await response.response.aclose()
+            return response.output
 
     async def put_domain_permissions_policy(
         self,

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/src/capo_codeartifact/_services/codeartifact.py

@@ -18,6 +18,7 @@ from capo_codeartifact._auth._providers import (
     default_aws_credentials_chain,
 )
 from capo_codeartifact._auth._zapros_handler import AuthMiddleware
+from capo_codeartifact._body import Body, closing_bodies
 from capo_codeartifact._iter import ensure_sync_iterator
 from capo_codeartifact._pagination import resolve_path as _resolve_path
 from capo_codeartifact._services._aws_config import aws_config
@@ -3152,7 +3153,7 @@ class codeartifactClient:
         format: "capo_codeartifact.types.package_format.PackageFormat",
         package: "capo_codeartifact.types.package_name.PackageName",
         package_version: "capo_codeartifact.types.package_version.PackageVersion",
-        asset_content: Iterator[bytes] | bytes,
+        asset_content: Body[Iterator[bytes]] | Iterator[bytes] | bytes,
         asset_name: "capo_codeartifact.types.asset_name.AssetName",
         asset_sha256: "capo_codeartifact.types.sha256.SHA256",
         *,
@@ -3223,13 +3224,14 @@ class codeartifactClient:
         if unfinished is not None:
             input_["unfinished"] = unfinished
 
-        response = execute_pipeline(
-            OperationRequest(input=input_, options=options_),
-            handler=_handler,
-            interceptors=list(interceptors_),
-        )
-        response.response.close()
-        return response.output
+        with closing_bodies(input_):
+            response = execute_pipeline(
+                OperationRequest(input=input_, options=options_),
+                handler=_handler,
+                interceptors=list(interceptors_),
+            )
+            response.response.close()
+            return response.output
 
     def put_domain_permissions_policy(
         self,

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0/src/capo_codeartifact.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capo-codeartifact
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python SDK for Codeartifact.
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -18,6 +18,8 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: zapros>=0.13.0
+Provides-Extra: anyio
+Requires-Dist: anyio>=3.0; extra == "anyio"
 Provides-Extra: sso
 Requires-Dist: capo-sso>=0.2.0; extra == "sso"
 Requires-Dist: capo-sso-oidc>=0.2.0; extra == "sso"
@@ -64,8 +66,10 @@ async def main():
 
 Some operations accept a streaming request body. Pass an async iterator of `bytes` chunks, or the whole body as `bytes`, for the streaming parameter.
 
+A plain iterator can be sent only once, so if a request fails after its body was transmitted the operation is not retried. To get retries for streamed uploads, pass a `Body` instead: it wraps a source that can be reopened, and every attempt streams a fresh copy. `Body.from_path` (sync client) and `Body.async_from_path` (async client, needs `anyio`) stream a file from disk; `Body(opener)` takes any context manager that yields a `(stream, length)` pair.
+
 ```python
-from capo_codeartifact import AsynccodeartifactClient
+from capo_codeartifact import AsynccodeartifactClient, Body
 
 
 async def main():
@@ -80,6 +84,11 @@ async def main():
         # Or pass the whole body as bytes
         response = await codeartifact.publish_package_version(asset_content=b'Hello, World!')
         print(response)
+
+        # Or stream a file with Body: the file is reopened on every retry
+        # and Content-Length is taken from its size, so no content_length needed
+        response = await codeartifact.publish_package_version(asset_content=Body.async_from_path("hello.txt"))
+        print(response)
 ```
 
 ## Streaming Response

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/src/capo_codeartifact.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 src/capo_codeartifact/__init__.py
 src/capo_codeartifact/_async.py
+src/capo_codeartifact/_body.py
 src/capo_codeartifact/_iter.py
 src/capo_codeartifact/_pagination.py
 src/capo_codeartifact/py.typed
@@ -295,4 +296,5 @@ src/capo_codeartifact/types/upstream_repository_list.py
 src/capo_codeartifact/types/validation_exception_reason.py
 src/capo_codeartifact/types/_prelude/blob.py
 src/capo_codeartifact/types/_prelude/timestamp.py
+tests/test_body.py
 tests/test_sigv4.py

{capo_codeartifact-0.1.0 → capo_codeartifact-0.2.0}/src/capo_codeartifact.egg-info/requires.txt

@@ -1,5 +1,8 @@
 zapros>=0.13.0
 
+[anyio]
+anyio>=3.0
+
 [sso]
 capo-sso>=0.2.0
 capo-sso-oidc>=0.2.0