cecli-dev 1.1.0rc4__tar.gz → 1.2.0rc1__tar.gz

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.1.0rc4
+Version: 1.2.0rc1
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -27,7 +27,7 @@ Requires-Dist: watchfiles>=1.1.0
 Requires-Dist: charset-normalizer>=3.4.7
 Requires-Dist: GitPython>=3.1.45
 Requires-Dist: pathspec>=0.12.1
-Requires-Dist: litellm!=1.82.7,!=1.82.8,>=1.80.11
+Requires-Dist: requests>=2.32.0
 Requires-Dist: mcp>=1.24.0
 Requires-Dist: socksio>=1.0.0
 Requires-Dist: truststore
@@ -56,7 +56,6 @@ Requires-Dist: marisa-trie>=1.0
 Requires-Dist: ngram>=4.0.3
 Requires-Dist: rapidfuzz>=3.0
 Requires-Dist: rustworkx>=0.15.0
-Requires-Dist: scipy>=1.15.3
 Requires-Dist: orjson>=3.11.6
 Requires-Dist: py-cymbal>=0.2.1
 Requires-Dist: importlib-metadata>=7.2.1
@@ -95,9 +94,12 @@ Provides-Extra: playwright
 Requires-Dist: playwright; extra == "playwright"
 Dynamic: license-file
 
-## Why `cecli`?
+<p align="center">
+  <img src="cecli/website/assets/cecli-temp-logo-dark.svg" alt="cecli logo" width="300" height="96">
+</p>
 
-`cecli` (probably pronounced like "Cecily") is yet another cli agent crafted for extensibility and customization. Originally a fork of the [Aider](https://cecli.dev/) AI pair programming tool, we aim to make agentic coding as maximally effective as it can be based on the incredible capabilities of large language models.
+
+`cecli` is yet another cli agent crafted for extensibility and customization. For folks who like seeing under the hood, welcome to the fold. Made for nerds, geeks, and the extremely curious.
 
 
 ### Links

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/README.md

@@ -1,6 +1,9 @@
-## Why `cecli`?
+<p align="center">
+  <img src="cecli/website/assets/cecli-temp-logo-dark.svg" alt="cecli logo" width="300" height="96">
+</p>
 
-`cecli` (probably pronounced like "Cecily") is yet another cli agent crafted for extensibility and customization. Originally a fork of the [Aider](https://cecli.dev/) AI pair programming tool, we aim to make agentic coding as maximally effective as it can be based on the incredible capabilities of large language models.
+
+`cecli` is yet another cli agent crafted for extensibility and customization. For folks who like seeing under the hood, welcome to the fold. Made for nerds, geeks, and the extremely curious.
 
 
 ### Links

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "1.0.5.dev"
+__version__ = "1.2.0.dev"
 safe_version = __version__
 
 try:

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.0rc4'
-__version_tuple__ = version_tuple = (1, 1, 0, 'rc4')
+__version__ = version = '1.2.0rc1'
+__version_tuple__ = version_tuple = (1, 2, 0, 'rc1')
 
-__commit_id__ = commit_id = 'gc405e1f0a'
+__commit_id__ = commit_id = 'g040092f96'

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/coders/base_coder.py

@@ -3060,7 +3060,7 @@ class Coder(metaclass=UsageMeta):
 
     async def _execute_mcp_tools(self, server, tool_calls):
         """Execute MCP tools via LiteLLM."""
-        import httpx
+        from cecli.http import httpx
 
         tool_responses = []
         try:
@@ -3491,9 +3491,9 @@ class Coder(metaclass=UsageMeta):
         msg = response_dict["choices"][0]["message"]
 
         if self.partial_response_tool_calls:
-            msg["tool_calls"] = self.partial_response_tool_calls
+            msg["tool_calls"] = [_tool_call_to_dict(tc) for tc in self.partial_response_tool_calls]
         elif self.partial_response_function_call:
-            msg["function_call"] = self.partial_response_function_call
+            msg["function_call"] = _function_call_to_dict(self.partial_response_function_call)
 
         if "reasoning_content" not in msg:
             msg["reasoning_content"] = self.partial_response_reasoning_content
@@ -3611,7 +3611,7 @@ class Coder(metaclass=UsageMeta):
             return prompts.added_files.format(fnames=", ".join(added_fnames))
 
     async def send(self, messages, model=None, functions=None, tools=None):
-        from litellm.types.utils import ModelResponse
+        ModelResponse = litellm.types.utils.ModelResponse
 
         self.interrupt_event.clear()
         self.got_reasoning_content = False
@@ -3745,7 +3745,7 @@ class Coder(metaclass=UsageMeta):
                     self.io.ai_output(json.dumps(args, indent=4))
 
     async def show_send_output(self, completion):
-        from litellm.types.utils import ModelResponse
+        ModelResponse = litellm.types.utils.ModelResponse
 
         if self.verbose:
             print(completion)
@@ -4008,6 +4008,15 @@ class Coder(metaclass=UsageMeta):
                         for key, value in psf.items():
                             if isinstance(value, list):
                                 message_provider_specific_fields.setdefault(key, []).extend(value)
+                            elif (
+                                key in message_provider_specific_fields
+                                and isinstance(message_provider_specific_fields[key], dict)
+                                and isinstance(value, dict)
+                            ):
+                                # Merge dict-valued metadata (e.g. gemini per-call
+                                # function_call_signatures) so parallel tool calls
+                                # each keep their own signature across chunks.
+                                message_provider_specific_fields[key].update(value)
                             elif value is not None:
                                 message_provider_specific_fields[key] = value
             except (AttributeError, IndexError):
@@ -4101,7 +4110,8 @@ class Coder(metaclass=UsageMeta):
         parallel call is preserved, correctly ordered, and keeps its
         provider-specific fields (e.g. thought signatures) attached.
         """
-        from litellm.types.utils import ChatCompletionMessageToolCall, Function
+        ChatCompletionMessageToolCall = litellm.types.utils.ChatCompletionMessageToolCall
+        Function = litellm.types.utils.Function
 
         tool_calls_dict = {}
 
@@ -4632,7 +4642,12 @@ class Coder(metaclass=UsageMeta):
     def parse_partial_args(self):
         # dump(self.partial_response_function_call)
 
-        data = self.partial_response_function_call.get("arguments")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            data = function_call.get("arguments")
+        else:
+            data = getattr(function_call, "arguments", None)
+
         if not data:
             return
 
@@ -4910,3 +4925,25 @@ class Coder(metaclass=UsageMeta):
         else:
             # Append the command to the prefix with a space
             return f"{command_prefix} {command}"
+
+
+def _tool_call_to_dict(tc):
+    """Normalize a tool call (dict or litellm-shaped object) to a wire-format dict."""
+    if isinstance(tc, dict):
+        return tc
+
+    if hasattr(tc, "to_dict"):
+        return tc.to_dict()
+
+    return tc
+
+
+def _function_call_to_dict(function_call):
+    """Normalize a function call (dict or litellm-shaped Function) to a dict."""
+    if isinstance(function_call, dict):
+        return function_call
+
+    if hasattr(function_call, "to_dict"):
+        return function_call.to_dict()
+
+    return function_call

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/coders/copypaste_coder.py

@@ -259,11 +259,11 @@ def get_copy_paste_coder_class(edit_format, main_model):
             ],
             created=int(time.time()),
             model=model.name,
-            usage={
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": total_tokens,
-            },
+            usage=litellm.Usage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=total_tokens,
+            ),
         )
 
         kwargs = dict(model=model.name, messages=messages, stream=False)

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/coders/editblock_func_coder.py

@@ -92,7 +92,11 @@ class EditBlockFunctionCoder(Coder):
         return res
 
     async def _update_files(self):
-        name = self.partial_response_function_call.get("name")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            name = function_call.get("name")
+        else:
+            name = getattr(function_call, "name", None)
 
         if name and name != "replace_lines":
             raise ValueError(f'Unknown function_call name="{name}", use name="replace_lines"')

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/coders/wholefile_func_coder.py

@@ -113,7 +113,11 @@ class WholeFileFunctionCoder(Coder):
         return "\n".join(show_diff)
 
     async def _update_files(self):
-        name = self.partial_response_function_call.get("name")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            name = function_call.get("name")
+        else:
+            name = getattr(function_call, "name", None)
         if name and name != "write_file":
             raise ValueError(f'Unknown function_call name="{name}", use name="write_file"')
 

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/exceptions.py

@@ -62,7 +62,7 @@ class LiteLLMExceptions:
         self._load()
 
     def _load(self, strict=False):
-        import litellm
+        from cecli.llm import litellm
 
         for var in dir(litellm):
             if var.endswith("Error"):
@@ -83,7 +83,7 @@ class LiteLLMExceptions:
 
     def get_ex_info(self, ex):
         """Return the ExInfo for a given exception instance"""
-        import litellm
+        from cecli.llm import litellm
 
         if ex.__class__ is litellm.APIConnectionError:
             if "google.auth" in str(ex):

{cecli_dev-1.1.0rc4 → cecli_dev-1.2.0rc1}/cecli/helpers/leak_detect.py

@@ -275,61 +275,81 @@ class MemorySnapshot:
 
     # ── Report ──
 
-    def print_report(self) -> None:
-        """Print a human-readable memory report to stdout."""
-        print("=" * 70)
-        print("MemorySnapshot Report")
-        print(f"  Objects scanned : {len(self._all_objects):,}")
+    def print_report(self, out: Optional[Any] = None) -> None:
+        """Print a human-readable memory report to *out* (defaults to sys.stdout).
+
+        Passing a file-like object (e.g. ``io.StringIO``) allows callers to
+        capture the report as text instead of writing to the terminal.
+        """
+        if out is None:
+            out = sys.stdout
+
+        print("=" * 70, file=out)
+        print("MemorySnapshot Report", file=out)
+        print(f"  Objects scanned : {len(self._all_objects):,}", file=out)
         print(
-            f"  Deep sizes      : {'yes (pympler)' if self._has_pympler else 'no (sys.getsizeof)'}"
+            f"  Deep sizes      : {'yes (pympler)' if self._has_pympler else 'no (sys.getsizeof)'}",
+            file=out,
         )
-        print(f"  Guppy available  : {'yes' if self._has_guppy else 'no'}")
-        print("=" * 70)
+        print(f"  Guppy available  : {'yes' if self._has_guppy else 'no'}", file=out)
+        print("=" * 70, file=out)
 
         # 1. Largest objects
-        print("\n>> TOP 15 LARGEST OBJECTS (any type)")
-        print("  " + "-" * 60)
+        print("\n>> TOP 15 LARGEST OBJECTS (any type)", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_objects(15):
-            print(f"  {item.size_kb:>10.1f} KB  {item.type_name:<15s}  {item.repr_str}")
+            print(
+                f"  {item.size_kb:>10.1f} KB  {item.type_name:<15s}  {item.repr_str}",
+                file=out,
+            )
 
         # 2. Largest dicts
-        print("\n>> LARGEST DICTS")
-        print("  " + "-" * 60)
+        print("\n>> LARGEST DICTS", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_dicts(5):
             d = item.obj
             keys_preview = list(d.keys())[:5] if isinstance(d, dict) else []
-            print(f"  {item.size_kb:>10.1f} KB  dict[{len(d)} keys]  keys={keys_preview!r}")
+            print(
+                f"  {item.size_kb:>10.1f} KB  dict[{len(d)} keys]  keys={keys_preview!r}",
+                file=out,
+            )
 
         # 3. Largest lists
-        print("\n>> LARGEST LISTS")
-        print("  " + "-" * 60)
+        print("\n>> LARGEST LISTS", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_lists(5):
             lst = item.obj
             first = lst[0] if lst else "empty"
-            print(f"  {item.size_kb:>10.1f} KB  list[{len(lst)} items]  first={first!r}")
+            print(
+                f"  {item.size_kb:>10.1f} KB  list[{len(lst)} items]  first={first!r}",
+                file=out,
+            )
 
         # 4. Largest class instances
-        print("\n>> LARGEST CLASS INSTANCES (custom)")
-        print("  " + "-" * 60)
+        print("\n>> LARGEST CLASS INSTANCES (custom)", file=out)
+        print("  " + "-" * 60, file=out)
         for item in self.largest_class_instances(n=10):
-            print(f"  {item.size_kb:>10.1f} KB  {item.type_name}")
+            print(f"  {item.size_kb:>10.1f} KB  {item.type_name}", file=out)
 
         # 5. Type summary
-        print("\n>> TYPE SUMMARY (total size per type)")
-        print("  " + "-" * 60)
+        print("\n>> TYPE SUMMARY (total size per type)", file=out)
+        print("  " + "-" * 60, file=out)
         for ts in self.type_summary(12):
-            print(f"  {ts.total_size_kb:>10.1f} KB  ({ts.count:>7,} objs)  {ts.type_name}")
+            print(
+                f"  {ts.total_size_kb:>10.1f} KB  ({ts.count:>7,} objs)  {ts.type_name}",
+                file=out,
+            )
 
         # 6. Guppy summary if available
         if self._has_guppy:
-            print("\n>> GUPPY HEAP SUMMARY")
-            print("  " + "-" * 60)
+            print("\n>> GUPPY HEAP SUMMARY", file=out)
+            print("  " + "-" * 60, file=out)
             summary = self.guppy_summary()
             if summary:
                 for line in summary.split("\n"):
-                    print(f"  {line}")
+                    print(f"  {line}", file=out)
 
-        print()
+        print(file=out)
 
     # ── Internal helpers ──
 

cecli_dev-1.2.0rc1/cecli/helpers/llms/__init__.py

@@ -0,0 +1,35 @@
+"""LiteLLM-free LLM communication stack for cecli.
+
+The ``cecli.helpers.llms`` package replaces the litellm-backed call path with a
+small, lazy-loading dispatcher that mirrors the structure of
+``cecli/helpers/model_config/``:
+
+- :mod:`cecli.helpers.llms.config` - provider defaults + model config resolution
+- :mod:`cecli.helpers.llms.domains` - one module per API family (chat,
+  responses, messages, gemini)
+- :mod:`cecli.helpers.llms.providers` - per-provider custom logic (auth,
+  headers, response repair) with an extensible :class:`ProviderAdapter` base
+- :mod:`cecli.helpers.llms.formatters` - sectional per-domain formatters
+  (reasoning, thinking)
+- :mod:`cecli.helpers.llms.pipeline` - the ``acompletion()`` dispatcher
+
+Public API: :func:`acompletion`, :func:`resolve_model_config`,
+:func:`get_api_key`.
+"""
+
+from __future__ import annotations
+
+from .config import get_api_key, resolve_model_config
+from .pipeline import acompletion
+from .runtime import set_verify_ssl
+from .types import CompletionChunk, CompletionResponse, ToolCall
+
+__all__ = [
+    "acompletion",
+    "resolve_model_config",
+    "get_api_key",
+    "CompletionResponse",
+    "CompletionChunk",
+    "ToolCall",
+    "set_verify_ssl",
+]

cecli_dev-1.2.0rc1/cecli/helpers/llms/aws_sigv4.py

@@ -0,0 +1,220 @@
+"""Self-contained AWS Signature Version 4 request signing (stdlib only).
+
+Reimplements the subset of botocore's ``SigV4Auth`` that cecli needs for the
+Bedrock / Bedrock Mantle providers, so ``boto3`` is not a runtime dependency.
+The signing-header filter mirrors litellm's
+``BaseAWSLLM._filter_headers_for_aws_signature``: only ``host``,
+``content-type``, ``date``, ``x-amz-*`` and ``x-amzn-*`` headers participate in
+canonicalization (forwarded client headers stay unsigned).
+
+Verified against the AWS SigV4 test vector from the official docs (IAM
+``ListUsers`` example) in ``tests/helpers/test_llms_aws_sigv4.py``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import urllib.parse
+from datetime import datetime, timezone
+from typing import Dict, Optional
+
+#: Headers AWS SigV4 includes in the canonical request / signed headers.
+_SIGNABLE_HEADERS = {
+    "host",
+    "content-type",
+    "date",
+    "x-amz-date",
+    "x-amz-security-token",
+    "x-amz-content-sha256",
+    "x-amz-algorithm",
+    "x-amz-credential",
+    "x-amz-signedheaders",
+    "x-amz-signature",
+}
+
+
+class AWSCredentials:
+    """Minimal AWS credential holder (access key / secret / optional session token)."""
+
+    def __init__(
+        self,
+        access_key: str,
+        secret_key: str,
+        session_token: Optional[str] = None,
+        expiry: Optional[datetime] = None,
+    ) -> None:
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.session_token = session_token
+        self.expiry = expiry
+
+    @classmethod
+    def from_env(cls) -> Optional["AWSCredentials"]:
+        """Build credentials from the standard AWS environment variables."""
+        import os
+
+        access_key = os.environ.get("AWS_ACCESS_KEY_ID")
+        secret_key = os.environ.get("AWS_SECRET_ACCESS_KEY")
+        if not access_key or not secret_key:
+            return None
+        return cls(
+            access_key=access_key,
+            secret_key=secret_key,
+            session_token=os.environ.get("AWS_SESSION_TOKEN"),
+        )
+
+
+def _filter_headers_for_signature(headers: Dict[str, str]) -> Dict[str, str]:
+    """Return only the headers AWS SigV4 includes in the signature."""
+    out: Dict[str, str] = {}
+    for name, value in headers.items():
+        if value is None:
+            continue
+        lower = name.lower()
+        if lower in _SIGNABLE_HEADERS or lower.startswith("x-amz-") or lower.startswith("x-amzn-"):
+            out[name] = value
+    return out
+
+
+def _sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _hmac(key: bytes, msg: bytes) -> bytes:
+    return hmac.new(key, msg, hashlib.sha256).digest()
+
+
+def _canonical_uri(path: str) -> str:
+    """URI-encode each path segment, never re-encoding the ``/`` separator."""
+    if not path or path == "/":
+        return "/"
+    segments = [urllib.parse.quote(seg, safe="/-_.~") for seg in path.split("/")]
+    return "/".join(segments)
+
+
+def _canonical_query(query: str) -> str:
+    """Sort query params by (encoded key, encoded value) and join with '&'."""
+    params = urllib.parse.parse_qsl(query, keep_blank_values=True)
+    encoded = [
+        (urllib.parse.quote(k, safe="-_.~"), urllib.parse.quote(v, safe="-_.~")) for k, v in params
+    ]
+    encoded.sort()
+    return "&".join(f"{k}={v}" for k, v in encoded)
+
+
+def _canonical_headers(headers: Dict[str, str]) -> tuple[str, str]:
+    """Return (canonical_headers, signed_headers) sorted by lower-cased name."""
+    items = sorted(
+        ((name.lower(), value.strip()) for name, value in headers.items() if value is not None),
+        key=lambda pair: pair[0],
+    )
+    canonical = "".join(f"{name}:{value}\n" for name, value in items)
+    signed = ";".join(name for name, _ in items)
+    return canonical, signed
+
+
+def sign_request(
+    method: str,
+    url: str,
+    payload: bytes,
+    credentials: AWSCredentials,
+    region: str,
+    service: str,
+    headers: Optional[Dict[str, str]] = None,
+    now: Optional[datetime] = None,
+) -> Dict[str, str]:
+    """Sign a request with AWS SigV4 and return the headers to send.
+
+    Args:
+        method: HTTP method (``POST`` for the Bedrock APIs).
+        url: Full request URL.
+        payload: Encoded request body.
+        credentials: AWS credentials (access key / secret / optional session token).
+        region: AWS region (e.g. ``us-east-1``).
+        service: AWS service name (``bedrock`` for Bedrock / Mantle).
+        headers: Extra headers to sign (e.g. ``content-type``); ``host`` and
+            ``x-amz-date`` are added automatically.
+        now: Fixed timestamp (for deterministic tests).
+
+    Returns:
+        The complete headers dict including ``Authorization``, ``X-Amz-Date``
+        and ``X-Amz-Security-Token`` (when a session token is set). The payload
+        hash is part of the canonical request but not sent as a header, matching
+        the AWS reference examples.
+    """
+    now = now or datetime.now(timezone.utc)
+    amz_date = now.strftime("%Y%m%dT%H%M%SZ")
+    date_stamp = now.strftime("%Y%m%d")
+
+    parsed = urllib.parse.urlsplit(url)
+    host = parsed.netloc
+    path = parsed.path or "/"
+    query = parsed.query
+
+    payload_hash = _sha256_hex(payload)
+
+    # Normalize header names to lowercase so a caller-supplied ``Content-Type``
+    # and our ``setdefault`` can never collide into a duplicate signed header.
+    sig_headers = {
+        name.lower(): value for name, value in (headers or {}).items() if value is not None
+    }
+    sig_headers.setdefault("host", host)
+    sig_headers.setdefault("x-amz-date", amz_date)
+    sig_headers.setdefault("content-type", "application/json")
+    if credentials.session_token:
+        sig_headers.setdefault("x-amz-security-token", credentials.session_token)
+
+    # Only AWS-relevant headers participate in canonicalization (mirrors litellm).
+    sig_headers = _filter_headers_for_signature(sig_headers)
+
+    canonical_headers, signed_headers = _canonical_headers(sig_headers)
+    canonical_request = "\n".join(
+        [
+            method.upper(),
+            _canonical_uri(path),
+            _canonical_query(query),
+            canonical_headers,
+            signed_headers,
+            payload_hash,
+        ]
+    )
+
+    scope = f"{date_stamp}/{region}/{service}/aws4_request"
+    string_to_sign = "\n".join(
+        [
+            "AWS4-HMAC-SHA256",
+            amz_date,
+            scope,
+            _sha256_hex(canonical_request.encode("utf-8")),
+        ]
+    )
+
+    k_date = _hmac(("AWS4" + credentials.secret_key).encode("utf-8"), date_stamp.encode("utf-8"))
+    k_region = _hmac(k_date, region.encode("utf-8"))
+    k_service = _hmac(k_region, service.encode("utf-8"))
+    k_signing = _hmac(k_service, b"aws4_request")
+    signature = hmac.new(k_signing, string_to_sign.encode("utf-8"), hashlib.sha256).hexdigest()
+
+    authorization = (
+        f"AWS4-HMAC-SHA256 Credential={credentials.access_key}/{scope}, "
+        f"SignedHeaders={signed_headers}, Signature={signature}"
+    )
+
+    out = dict(sig_headers)
+    out["Authorization"] = authorization
+    return out
+
+
+def resolve_aws_region() -> Optional[str]:
+    """Resolve the AWS region from the environment (litellm-compatible order)."""
+    import os
+
+    return os.environ.get("AWS_REGION_NAME") or os.environ.get("AWS_REGION") or None
+
+
+__all__ = [
+    "AWSCredentials",
+    "resolve_aws_region",
+    "sign_request",
+]