Add files using upload-large-folder tool

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/__init__.py

@@ -0,0 +1 @@
+from ._files import files_from_dir as files_from_dir, async_files_from_dir as async_files_from_dir

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/_extras/__init__.py

@@ -0,0 +1 @@
+from ._google_auth import google_auth as google_auth

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/_extras/_common.py

@@ -0,0 +1,13 @@
+from ..._exceptions import AnthropicError
+
+INSTRUCTIONS = """
+
+Anthropic error: missing required dependency `{library}`.
+
+    $ pip install anthropic[{extra}]
+"""
+
+
+class MissingDependencyError(AnthropicError):
+    def __init__(self, *, library: str, extra: str) -> None:
+        super().__init__(INSTRUCTIONS.format(library=library, extra=extra))

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/_extras/_google_auth.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from typing_extensions import ClassVar, override
+
+from ._common import MissingDependencyError
+from ..._utils import LazyProxy
+
+if TYPE_CHECKING:
+    import google.auth  # type: ignore
+
+    google_auth = google.auth
+
+
+class GoogleAuthProxy(LazyProxy[Any]):
+    should_cache: ClassVar[bool] = True
+
+    @override
+    def __load__(self) -> Any:
+        try:
+            import google.auth  # type: ignore
+        except ImportError as err:
+            raise MissingDependencyError(extra="vertex", library="google-auth") from err
+
+        return google.auth
+
+
+if not TYPE_CHECKING:
+    google_auth = GoogleAuthProxy()

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/_files.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import anyio
+
+from .._types import FileTypes
+
+
+def files_from_dir(directory: str | os.PathLike[str]) -> list[FileTypes]:
+    path = Path(directory)
+
+    files: list[FileTypes] = []
+    _collect_files(path, path.parent, files)
+    return files
+
+
+def _collect_files(directory: Path, relative_to: Path, files: list[FileTypes]) -> None:
+    for path in directory.iterdir():
+        if path.is_dir():
+            _collect_files(path, relative_to, files)
+            continue
+
+        files.append((path.relative_to(relative_to).as_posix(), path.read_bytes()))
+
+
+async def async_files_from_dir(directory: str | os.PathLike[str]) -> list[FileTypes]:
+    path = anyio.Path(directory)
+
+    files: list[FileTypes] = []
+    await _async_collect_files(path, path.parent, files)
+    return files
+
+
+async def _async_collect_files(directory: anyio.Path, relative_to: anyio.Path, files: list[FileTypes]) -> None:
+    async for path in directory.iterdir():
+        if await path.is_dir():
+            await _async_collect_files(path, relative_to, files)
+            continue
+
+        files.append((path.relative_to(relative_to).as_posix(), await path.read_bytes()))

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/_parse/_response.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing_extensions import TypeVar
+
+from ..._types import NotGiven
+from ..._models import TypeAdapter, construct_type_unchecked
+from ..._utils._utils import is_given
+from ...types.message import Message
+from ...types.parsed_message import ParsedMessage, ParsedTextBlock, ParsedContentBlock
+from ...types.beta.beta_message import BetaMessage
+from ...types.beta.parsed_beta_message import ParsedBetaMessage, ParsedBetaTextBlock, ParsedBetaContentBlock
+
+ResponseFormatT = TypeVar("ResponseFormatT", default=None)
+
+
+def parse_text(text: str, output_format: ResponseFormatT | NotGiven) -> ResponseFormatT | None:
+    if is_given(output_format):
+        adapted_type: TypeAdapter[ResponseFormatT] = TypeAdapter(output_format)
+        return adapted_type.validate_json(text)
+    return None
+
+
+def parse_beta_response(
+    *,
+    output_format: ResponseFormatT | NotGiven,
+    response: BetaMessage,
+) -> ParsedBetaMessage[ResponseFormatT]:
+    content_list: list[ParsedBetaContentBlock[ResponseFormatT]] = []
+    for content in response.content:
+        if content.type == "text":
+            content_list.append(
+                construct_type_unchecked(
+                    type_=ParsedBetaTextBlock[ResponseFormatT],
+                    value={**content.to_dict(), "parsed_output": parse_text(content.text, output_format)},
+                )
+            )
+        else:
+            content_list.append(content)  # type: ignore
+
+    return construct_type_unchecked(
+        type_=ParsedBetaMessage[ResponseFormatT],
+        value={
+            **response.to_dict(),
+            "content": content_list,
+        },
+    )
+
+
+def parse_response(
+    *,
+    output_format: ResponseFormatT | NotGiven,
+    response: Message,
+) -> ParsedMessage[ResponseFormatT]:
+    content_list: list[ParsedContentBlock[ResponseFormatT]] = []
+    for content in response.content:
+        if content.type == "text":
+            content_list.append(
+                construct_type_unchecked(
+                    type_=ParsedTextBlock[ResponseFormatT],
+                    value={**content.to_dict(), "parsed_output": parse_text(content.text, output_format)},
+                )
+            )
+        else:
+            content_list.append(content)  # type: ignore
+
+    return construct_type_unchecked(
+        type_=ParsedMessage[ResponseFormatT],
+        value={
+            **response.to_dict(),
+            "content": content_list,
+        },
+    )

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/_parse/_transform.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any, Literal, Optional, cast
+from typing_extensions import assert_never
+
+import pydantic
+
+from ..._utils import is_list
+
+SupportedTypes = Literal[
+    "object",
+    "array",
+    "string",
+    "integer",
+    "number",
+    "boolean",
+    "null",
+]
+
+SupportedStringFormats = {
+    "date-time",
+    "time",
+    "date",
+    "duration",
+    "email",
+    "hostname",
+    "uri",
+    "ipv4",
+    "ipv6",
+    "uuid",
+}
+
+
+def get_transformed_string(
+    schema: dict[str, Any],
+) -> dict[str, Any]:
+    """Transforms a JSON schema of type string to ensure it conforms to the API's expectations.
+
+    Specifically, it ensures that if the schema is of type "string" and does not already
+    specify a "format", it sets the format to "text".
+
+    Args:
+        schema: The original JSON schema.
+
+    Returns:
+        The transformed JSON schema.
+    """
+    if schema.get("type") == "string" and "format" not in schema:
+        schema["format"] = "text"
+    return schema
+
+
+def transform_schema(
+    json_schema: type[pydantic.BaseModel] | dict[str, Any],
+) -> dict[str, Any]:
+    """
+    Transforms a JSON schema to ensure it conforms to the API's expectations.
+
+    Args:
+        json_schema (Dict[str, Any]): The original JSON schema.
+
+    Returns:
+        The transformed JSON schema.
+
+    Examples:
+        >>> transform_schema(
+        ...     {
+        ...         "type": "integer",
+        ...         "minimum": 1,
+        ...         "maximum": 10,
+        ...         "description": "A number",
+        ...     }
+        ... )
+        {'type': 'integer', 'description': 'A number\n\n{minimum: 1, maximum: 10}'}
+    """
+    if inspect.isclass(json_schema) and issubclass(json_schema, pydantic.BaseModel):  # pyright: ignore[reportUnnecessaryIsInstance]
+        json_schema = json_schema.model_json_schema()
+
+    strict_schema: dict[str, Any] = {}
+    json_schema = {**json_schema}
+
+    ref = json_schema.pop("$ref", None)
+    if ref is not None:
+        strict_schema["$ref"] = ref
+        return strict_schema
+
+    defs = json_schema.pop("$defs", None)
+    if defs is not None:
+        strict_defs: dict[str, Any] = {}
+        strict_schema["$defs"] = strict_defs
+
+        for name, schema in defs.items():
+            strict_defs[name] = transform_schema(schema)
+
+    type_: Optional[SupportedTypes] = json_schema.pop("type", None)
+    any_of = json_schema.pop("anyOf", None)
+    one_of = json_schema.pop("oneOf", None)
+    all_of = json_schema.pop("allOf", None)
+
+    if is_list(any_of):
+        strict_schema["anyOf"] = [transform_schema(cast("dict[str, Any]", variant)) for variant in any_of]
+    elif is_list(one_of):
+        strict_schema["anyOf"] = [transform_schema(cast("dict[str, Any]", variant)) for variant in one_of]
+    elif is_list(all_of):
+        strict_schema["allOf"] = [transform_schema(cast("dict[str, Any]", variant)) for variant in all_of]
+    else:
+        if type_ is None:
+            raise ValueError("Schema must have a 'type', 'anyOf', 'oneOf', or 'allOf' field.")
+
+        strict_schema["type"] = type_
+
+    enum = json_schema.pop("enum", None)
+    if is_list(enum):
+        strict_schema["enum"] = enum
+
+    description = json_schema.pop("description", None)
+    if description is not None:
+        strict_schema["description"] = description
+
+    title = json_schema.pop("title", None)
+    if title is not None:
+        strict_schema["title"] = title
+
+    if type_ == "object":
+        strict_schema["properties"] = {
+            key: transform_schema(prop_schema) for key, prop_schema in json_schema.pop("properties", {}).items()
+        }
+        json_schema.pop("additionalProperties", None)
+        strict_schema["additionalProperties"] = False
+
+        required = json_schema.pop("required", None)
+        if required is not None:
+            strict_schema["required"] = required
+
+    elif type_ == "string":
+        format = json_schema.pop("format", None)
+        if format and format in SupportedStringFormats:
+            strict_schema["format"] = format
+        elif format:
+            # add it back so its treated as an extra property and appended to the description
+            json_schema["format"] = format
+    elif type_ == "array":
+        items = json_schema.pop("items", None)
+        if items is not None:
+            strict_schema["items"] = transform_schema(items)
+
+        min_items = json_schema.pop("minItems", None)
+        if min_items is not None and min_items == 0 or min_items == 1:
+            strict_schema["minItems"] = min_items
+        elif min_items is not None:
+            # add it back so its treated as an extra property and appended to the description
+            json_schema["minItems"] = min_items
+
+    elif type_ == "boolean" or type_ == "integer" or type_ == "number" or type_ == "null" or type_ is None:
+        pass
+    else:
+        assert_never(type_)
+
+    # if there are any propes leftover then they aren't supported, so we add them to the description
+    # so that the model *might* follow them.
+    if json_schema:
+        description = strict_schema.get("description")
+        strict_schema["description"] = (
+            (description + "\n\n" if description is not None else "")
+            + "{"
+            + ", ".join(f"{key}: {value}" for key, value in json_schema.items())
+            + "}"
+        )
+
+    return strict_schema

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/_stainless_helpers.py

@@ -0,0 +1,75 @@
+"""Tracking for SDK helper usage via the x-stainless-helper header."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, cast
+
+_HELPER_ATTR = "_stainless_helper"
+
+
+def tag_helper(obj: Any, name: str) -> None:
+    """Mark an object as created by a named SDK helper."""
+    try:
+        object.__setattr__(obj, _HELPER_ATTR, name)
+    except (AttributeError, TypeError):
+        pass
+
+
+def get_helper_tag(obj: object) -> str | None:
+    """Get the helper name from an object, if any."""
+    return getattr(obj, _HELPER_ATTR, None)  # type: ignore[return-value]
+
+
+def collect_helpers(
+    tools: Any = None,
+    messages: Any = None,
+) -> list[str]:
+    """Collect deduplicated helper names from tools and messages."""
+    helpers: set[str] = set()
+
+    if tools:
+        for tool in tools:
+            tag = get_helper_tag(tool)
+            if tag is not None:
+                helpers.add(tag)
+
+    if messages:
+        for message in messages:
+            tag = get_helper_tag(message)
+            if tag is not None:
+                helpers.add(tag)
+
+            # Check content blocks within messages
+            if isinstance(message, dict):
+                blocks: Any = cast(Dict[str, Any], message).get("content")
+            else:
+                blocks = getattr(message, "content", None)
+            if isinstance(blocks, list):
+                for block in cast(list[object], blocks):
+                    tag = get_helper_tag(block)
+                    if tag is not None:
+                        helpers.add(tag)
+
+    return list(helpers)
+
+
+def stainless_helper_header(
+    tools: Any = None,
+    messages: Any = None,
+) -> dict[str, str]:
+    """Build x-stainless-helper header dict from tools and messages.
+
+    Returns an empty dict if no helpers are found.
+    """
+    helpers = collect_helpers(tools, messages)
+    if not helpers:
+        return {}
+    return {"x-stainless-helper": ", ".join(helpers)}
+
+
+def stainless_helper_header_from_file(file: object) -> dict[str, str]:
+    """Build x-stainless-helper header dict from a file object."""
+    tag = get_helper_tag(file)
+    if tag is None:
+        return {}
+    return {"x-stainless-helper": tag}

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/aws/__init__.py

@@ -0,0 +1 @@
+from ._client import AnthropicAWS as AnthropicAWS, AsyncAnthropicAWS as AsyncAnthropicAWS

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/aws/_auth.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import httpx
+
+from ..._utils import lru_cache
+
+if TYPE_CHECKING:
+    import boto3
+
+
+@lru_cache(maxsize=512)
+def _get_session(
+    *,
+    aws_access_key: str | None,
+    aws_secret_key: str | None,
+    aws_session_token: str | None,
+    region: str | None,
+    profile: str | None,
+) -> boto3.Session:
+    import boto3
+
+    return boto3.Session(
+        profile_name=profile,
+        region_name=region,
+        aws_access_key_id=aws_access_key,
+        aws_secret_access_key=aws_secret_key,
+        aws_session_token=aws_session_token,
+    )
+
+
+def get_auth_headers(
+    *,
+    method: str,
+    url: str,
+    headers: httpx.Headers,
+    aws_access_key: str | None,
+    aws_secret_key: str | None,
+    aws_session_token: str | None,
+    region: str | None,
+    profile: str | None,
+    data: str | None,
+    service_name: str,
+) -> dict[str, str]:
+    from botocore.auth import SigV4Auth
+    from botocore.awsrequest import AWSRequest
+
+    session = _get_session(
+        profile=profile,
+        region=region,
+        aws_access_key=aws_access_key,
+        aws_secret_key=aws_secret_key,
+        aws_session_token=aws_session_token,
+    )
+
+    # The connection header may be stripped by a proxy somewhere, so the receiver
+    # of this message may not see this header, so we remove it from the set of headers
+    # that are signed.
+    new_headers = {k: v for k, v in dict(headers).items() if k.lower() != "connection"}
+
+    request = AWSRequest(method=method.upper(), url=url, headers=new_headers, data=data)
+    credentials = session.get_credentials()
+    if not credentials:
+        raise RuntimeError("Could not resolve AWS credentials from session")
+
+    signer = SigV4Auth(credentials, service_name, session.region_name)
+    signer.add_auth(request)
+
+    prepped = request.prepare()
+
+    return {key: value for key, value in dict(prepped.headers).items() if value is not None}

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/aws/_client.py

@@ -0,0 +1,409 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+from typing_extensions import Self, override
+
+import httpx
+
+from ..._types import NOT_GIVEN, Omit, Headers, Timeout, NotGiven
+from ..._client import Anthropic, AsyncAnthropic
+from ._credentials import (
+    resolve_region,
+    resolve_api_key,
+    resolve_base_url,
+    resolve_auth_mode,
+    resolve_workspace_id,
+    validate_credentials,
+)
+from ..._exceptions import AnthropicError
+from ..._base_client import DEFAULT_MAX_RETRIES
+
+
+class AnthropicAWS(Anthropic):
+    aws_access_key: str | None
+    aws_secret_key: str | None
+    aws_region: str | None
+    aws_profile: str | None
+    aws_session_token: str | None
+    workspace_id: str | None
+    _use_sigv4: bool
+    _skip_auth: bool
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        aws_session_token: str | None = None,
+        workspace_id: str | None = None,
+        skip_auth: bool = False,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.Client | None = None,
+        _strict_response_validation: bool = False,
+        # Passed through to parent but not used for AWS auth
+        auth_token: str | None = None,
+        webhook_key: str | None = None,
+    ) -> None:
+        self._skip_auth = skip_auth
+
+        validate_credentials(aws_access_key=aws_access_key, aws_secret_key=aws_secret_key)
+
+        if skip_auth:
+            self._use_sigv4 = False
+            resolved_api_key = None
+        else:
+            self._use_sigv4 = resolve_auth_mode(
+                api_key=api_key,
+                aws_access_key=aws_access_key,
+                aws_secret_key=aws_secret_key,
+                aws_profile=aws_profile,
+            )
+            resolved_api_key = resolve_api_key(api_key=api_key, use_sigv4=self._use_sigv4)
+
+        resolved_region = resolve_region(aws_region)
+
+        if self._use_sigv4 and resolved_region is None:
+            raise AnthropicError(
+                "No AWS region was provided. Set the `aws_region` argument or the `AWS_REGION`/`AWS_DEFAULT_REGION` environment variable."
+            )
+
+        self.aws_access_key = aws_access_key
+        self.aws_secret_key = aws_secret_key
+        self.aws_region = resolved_region
+        self.aws_profile = aws_profile
+        self.aws_session_token = aws_session_token
+
+        if skip_auth:
+            self.workspace_id = workspace_id
+        else:
+            resolved_workspace_id = resolve_workspace_id(workspace_id)
+            if resolved_workspace_id is None:
+                raise AnthropicError(
+                    "No workspace ID found. Set the `workspace_id` argument or the `ANTHROPIC_AWS_WORKSPACE_ID` environment variable."
+                )
+            self.workspace_id = resolved_workspace_id
+
+        if not skip_auth:
+            resolved_base_url = resolve_base_url(
+                str(base_url) if base_url is not None else None,
+                region=resolved_region,
+            )
+            if resolved_base_url is None:
+                raise AnthropicError(
+                    "No AWS region was provided and no base_url was given. "
+                    "Set the `aws_region` argument, the `AWS_REGION`/`AWS_DEFAULT_REGION` environment variable, "
+                    "or provide a `base_url` directly."
+                )
+            base_url = resolved_base_url
+
+        super().__init__(
+            api_key=resolved_api_key,
+            auth_token=auth_token,
+            webhook_key=webhook_key,
+            base_url=base_url,  # type: ignore[arg-type]
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            default_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+
+    @property
+    @override
+    def default_headers(self) -> dict[str, str | Omit]:
+        headers = {**super().default_headers}
+        if self.workspace_id is not None:
+            headers["anthropic-workspace-id"] = self.workspace_id
+        return headers
+
+    @property
+    @override
+    def _api_key_auth(self) -> dict[str, str]:
+        if self._use_sigv4 or self._skip_auth:
+            return {}
+        return super()._api_key_auth
+
+    @override
+    def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if self._use_sigv4 or self._skip_auth:
+            return
+        super()._validate_headers(headers, custom_headers)
+
+    @override
+    def _prepare_request(self, request: httpx.Request) -> None:
+        if not self._use_sigv4:
+            return
+
+        from ._auth import get_auth_headers
+
+        data = request.read().decode()
+
+        headers = get_auth_headers(
+            method=request.method,
+            url=str(request.url),
+            headers=request.headers,
+            aws_access_key=self.aws_access_key,
+            aws_secret_key=self.aws_secret_key,
+            aws_session_token=self.aws_session_token,
+            region=self.aws_region,
+            profile=self.aws_profile,
+            data=data,
+            service_name="aws-external-anthropic",
+        )
+        request.headers.update(headers)
+
+    @override
+    def copy(  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride] — subclass intentionally drops `credentials`
+        self,
+        *,
+        api_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        aws_session_token: str | None = None,
+        workspace_id: str | None = None,
+        skip_auth: bool | None = None,
+        auth_token: str | None = None,
+        webhook_key: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.Client | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        # If region is changing and no explicit base_url, let __init__ derive it
+        resolved_base_url = base_url or (None if aws_region else self.base_url)
+
+        return super().copy(
+            api_key=api_key or self.api_key,
+            auth_token=auth_token,
+            webhook_key=webhook_key,
+            base_url=resolved_base_url,
+            timeout=timeout,
+            http_client=http_client,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            set_default_headers=set_default_headers,
+            default_query=default_query,
+            set_default_query=set_default_query,
+            _extra_kwargs={
+                "aws_access_key": aws_access_key or self.aws_access_key,
+                "aws_secret_key": aws_secret_key or self.aws_secret_key,
+                "aws_region": aws_region or self.aws_region,
+                "aws_profile": aws_profile or self.aws_profile,
+                "aws_session_token": aws_session_token or self.aws_session_token,
+                "workspace_id": workspace_id or self.workspace_id,
+                "skip_auth": skip_auth if skip_auth is not None else self._skip_auth,
+                **_extra_kwargs,
+            },
+        )
+
+    with_options = copy  # type: ignore[assignment]
+
+
+class AsyncAnthropicAWS(AsyncAnthropic):
+    aws_access_key: str | None
+    aws_secret_key: str | None
+    aws_region: str | None
+    aws_profile: str | None
+    aws_session_token: str | None
+    workspace_id: str | None
+    _use_sigv4: bool
+    _skip_auth: bool
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        aws_session_token: str | None = None,
+        workspace_id: str | None = None,
+        skip_auth: bool = False,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        _strict_response_validation: bool = False,
+        # Accepted for compatibility with AsyncAnthropic.copy() but not used
+        auth_token: str | None = None,
+        webhook_key: str | None = None,
+    ) -> None:
+        self._skip_auth = skip_auth
+
+        validate_credentials(aws_access_key=aws_access_key, aws_secret_key=aws_secret_key)
+
+        if skip_auth:
+            self._use_sigv4 = False
+            resolved_api_key = None
+        else:
+            self._use_sigv4 = resolve_auth_mode(
+                api_key=api_key,
+                aws_access_key=aws_access_key,
+                aws_secret_key=aws_secret_key,
+                aws_profile=aws_profile,
+            )
+            resolved_api_key = resolve_api_key(api_key=api_key, use_sigv4=self._use_sigv4)
+
+        resolved_region = resolve_region(aws_region)
+
+        if self._use_sigv4 and resolved_region is None:
+            raise AnthropicError(
+                "No AWS region was provided. Set the `aws_region` argument or the `AWS_REGION`/`AWS_DEFAULT_REGION` environment variable."
+            )
+
+        self.aws_access_key = aws_access_key
+        self.aws_secret_key = aws_secret_key
+        self.aws_region = resolved_region
+        self.aws_profile = aws_profile
+        self.aws_session_token = aws_session_token
+
+        if skip_auth:
+            self.workspace_id = workspace_id
+        else:
+            resolved_workspace_id = resolve_workspace_id(workspace_id)
+            if resolved_workspace_id is None:
+                raise AnthropicError(
+                    "No workspace ID found. Set the `workspace_id` argument or the `ANTHROPIC_AWS_WORKSPACE_ID` environment variable."
+                )
+            self.workspace_id = resolved_workspace_id
+
+        if not skip_auth:
+            resolved_base_url = resolve_base_url(
+                str(base_url) if base_url is not None else None,
+                region=resolved_region,
+            )
+            if resolved_base_url is None:
+                raise AnthropicError(
+                    "No AWS region was provided and no base_url was given. "
+                    "Set the `aws_region` argument, the `AWS_REGION`/`AWS_DEFAULT_REGION` environment variable, "
+                    "or provide a `base_url` directly."
+                )
+            base_url = resolved_base_url
+
+        super().__init__(
+            api_key=resolved_api_key,
+            auth_token=auth_token,
+            webhook_key=webhook_key,
+            base_url=base_url,  # type: ignore[arg-type]
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            default_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+
+    @property
+    @override
+    def default_headers(self) -> dict[str, str | Omit]:
+        headers = {**super().default_headers}
+        if self.workspace_id is not None:
+            headers["anthropic-workspace-id"] = self.workspace_id
+        return headers
+
+    @property
+    @override
+    def _api_key_auth(self) -> dict[str, str]:
+        if self._use_sigv4 or self._skip_auth:
+            return {}
+        return super()._api_key_auth
+
+    @override
+    def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if self._use_sigv4 or self._skip_auth:
+            return
+        super()._validate_headers(headers, custom_headers)
+
+    @override
+    async def _prepare_request(self, request: httpx.Request) -> None:
+        if not self._use_sigv4:
+            return
+
+        from ._auth import get_auth_headers
+
+        data = request.read().decode()
+
+        headers = get_auth_headers(
+            method=request.method,
+            url=str(request.url),
+            headers=request.headers,
+            aws_access_key=self.aws_access_key,
+            aws_secret_key=self.aws_secret_key,
+            aws_session_token=self.aws_session_token,
+            region=self.aws_region,
+            profile=self.aws_profile,
+            data=data,
+            service_name="aws-external-anthropic",
+        )
+        request.headers.update(headers)
+
+    @override
+    def copy(  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride] — subclass intentionally drops `credentials`
+        self,
+        *,
+        api_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        aws_session_token: str | None = None,
+        workspace_id: str | None = None,
+        skip_auth: bool | None = None,
+        auth_token: str | None = None,
+        webhook_key: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.AsyncClient | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        # If region is changing and no explicit base_url, let __init__ derive it
+        resolved_base_url = base_url or (None if aws_region else self.base_url)
+
+        return super().copy(
+            api_key=api_key or self.api_key,
+            auth_token=auth_token,
+            webhook_key=webhook_key,
+            base_url=resolved_base_url,
+            timeout=timeout,
+            http_client=http_client,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            set_default_headers=set_default_headers,
+            default_query=default_query,
+            set_default_query=set_default_query,
+            _extra_kwargs={
+                "aws_access_key": aws_access_key or self.aws_access_key,
+                "aws_secret_key": aws_secret_key or self.aws_secret_key,
+                "aws_region": aws_region or self.aws_region,
+                "aws_profile": aws_profile or self.aws_profile,
+                "aws_session_token": aws_session_token or self.aws_session_token,
+                "workspace_id": workspace_id or self.workspace_id,
+                "skip_auth": skip_auth if skip_auth is not None else self._skip_auth,
+                **_extra_kwargs,
+            },
+        )
+
+    with_options = copy  # type: ignore[assignment]

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/aws/_credentials.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import os
+from typing import Sequence
+
+
+def validate_credentials(
+    *,
+    aws_access_key: str | None,
+    aws_secret_key: str | None,
+) -> None:
+    """Raise if only one of aws_access_key/aws_secret_key is provided."""
+    if (aws_access_key is not None) != (aws_secret_key is not None):
+        provided = "aws_access_key" if aws_access_key is not None else "aws_secret_key"
+        missing = "aws_secret_key" if aws_access_key is not None else "aws_access_key"
+        raise ValueError(
+            f"`{provided}` was provided without `{missing}`. "
+            f"Both must be provided together, or neither (to use the default credential chain)."
+        )
+
+
+def _read_env(*env_vars: str) -> str | None:
+    """Return the first non-None value from the given env vars, or None."""
+    for var in env_vars:
+        value = os.environ.get(var)
+        if value is not None:
+            return value
+    return None
+
+
+def resolve_auth_mode(
+    *,
+    api_key: str | None,
+    aws_access_key: str | None,
+    aws_secret_key: str | None,
+    aws_profile: str | None,
+    api_key_env_vars: Sequence[str] = ("ANTHROPIC_AWS_API_KEY",),
+) -> bool:
+    """Determine whether to use SigV4 auth. Returns True for SigV4, False for API key.
+
+    Auth precedence:
+    1. api_key constructor arg → API key mode
+    2. aws_access_key + aws_secret_key constructor args → SigV4
+    3. aws_profile constructor arg → SigV4
+    4. API key env var(s) → API key mode (checked in order; first match wins)
+    5. Default AWS credential chain → SigV4
+    """
+    if api_key is not None:
+        return False
+
+    if aws_access_key is not None or aws_secret_key is not None:
+        return True
+
+    if aws_profile is not None:
+        return True
+
+    # No explicit constructor args that signal SigV4 — check env vars
+    if _read_env(*api_key_env_vars) is not None:
+        return False
+
+    # Fall back to default AWS credential chain
+    return True
+
+
+def resolve_api_key(
+    *,
+    api_key: str | None,
+    use_sigv4: bool,
+    api_key_env_vars: Sequence[str] = ("ANTHROPIC_AWS_API_KEY",),
+) -> str | None:
+    """Resolve the API key. Returns None if using SigV4."""
+    if api_key is not None:
+        return api_key
+
+    if not use_sigv4:
+        # Must be from env var
+        return _read_env(*api_key_env_vars)
+
+    return None
+
+
+def resolve_region(aws_region: str | None) -> str | None:
+    """Resolve the AWS region from constructor arg or env var.
+
+    Does not silently default — returns None if no region is available.
+    """
+    if aws_region is not None:
+        return aws_region
+
+    return os.environ.get("AWS_REGION") or os.environ.get("AWS_DEFAULT_REGION")
+
+
+def resolve_workspace_id(
+    workspace_id: str | None,
+    *,
+    workspace_id_env_vars: Sequence[str] = ("ANTHROPIC_AWS_WORKSPACE_ID",),
+) -> str | None:
+    """Resolve the workspace ID from constructor arg or env var(s).
+
+    Returns None if no workspace ID is available (caller should raise).
+    """
+    if workspace_id is not None:
+        return workspace_id
+
+    return _read_env(*workspace_id_env_vars)
+
+
+def resolve_base_url(
+    base_url: str | None,
+    *,
+    region: str | None,
+    base_url_env_vars: Sequence[str] = ("ANTHROPIC_AWS_BASE_URL",),
+    url_template: str = "https://aws-external-anthropic.{region}.api.aws",
+) -> str | None:
+    """Resolve the base URL from constructor arg, env var, or region.
+
+    Returns None if no base URL is resolvable (caller should raise).
+    """
+    if base_url is not None:
+        return base_url
+
+    env_url = _read_env(*base_url_env_vars)
+    if env_url is not None:
+        return env_url
+
+    if region is not None:
+        return url_template.format(region=region)
+
+    return None

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/__init__.py

@@ -0,0 +1,5 @@
+from ._client import AnthropicBedrock as AnthropicBedrock, AsyncAnthropicBedrock as AsyncAnthropicBedrock
+from ._mantle import (
+    AnthropicBedrockMantle as AnthropicBedrockMantle,
+    AsyncAnthropicBedrockMantle as AsyncAnthropicBedrockMantle,
+)

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/_auth.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import httpx
+
+from ..._utils import lru_cache
+
+if TYPE_CHECKING:
+    import boto3
+
+
+@lru_cache(maxsize=512)
+def _get_session(
+    *,
+    aws_access_key: str | None,
+    aws_secret_key: str | None,
+    aws_session_token: str | None,
+    region: str | None,
+    profile: str | None,
+) -> boto3.Session:
+    import boto3
+
+    return boto3.Session(
+        profile_name=profile,
+        region_name=region,
+        aws_access_key_id=aws_access_key,
+        aws_secret_access_key=aws_secret_key,
+        aws_session_token=aws_session_token,
+    )
+
+
+def get_auth_headers(
+    *,
+    method: str,
+    url: str,
+    headers: httpx.Headers,
+    aws_access_key: str | None,
+    aws_secret_key: str | None,
+    aws_session_token: str | None,
+    region: str | None,
+    profile: str | None,
+    data: str | None,
+) -> dict[str, str]:
+    from botocore.auth import SigV4Auth
+    from botocore.awsrequest import AWSRequest
+
+    session = _get_session(
+        profile=profile,
+        region=region,
+        aws_access_key=aws_access_key,
+        aws_secret_key=aws_secret_key,
+        aws_session_token=aws_session_token,
+    )
+
+    # The connection header may be stripped by a proxy somewhere, so the receiver
+    # of this message may not see this header, so we remove it from the set of headers
+    # that are signed.
+    headers = headers.copy()
+    del headers["connection"]
+
+    request = AWSRequest(method=method.upper(), url=url, headers=headers, data=data)
+    credentials = session.get_credentials()
+    if not credentials:
+        raise RuntimeError("could not resolve credentials from session")
+
+    signer = SigV4Auth(credentials, "bedrock", session.region_name)
+    signer.add_auth(request)
+
+    prepped = request.prepare()
+
+    return {key: value for key, value in dict(prepped.headers).items() if value is not None}

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/_beta.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ._beta_messages import (
+    Messages,
+    AsyncMessages,
+    MessagesWithRawResponse,
+    AsyncMessagesWithRawResponse,
+    MessagesWithStreamingResponse,
+    AsyncMessagesWithStreamingResponse,
+)
+
+__all__ = ["Beta", "AsyncBeta"]
+
+
+class Beta(SyncAPIResource):
+    @cached_property
+    def messages(self) -> Messages:
+        return Messages(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> BetaWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return BetaWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BetaWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return BetaWithStreamingResponse(self)
+
+
+class AsyncBeta(AsyncAPIResource):
+    @cached_property
+    def messages(self) -> AsyncMessages:
+        return AsyncMessages(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncBetaWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBetaWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBetaWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncBetaWithStreamingResponse(self)
+
+
+class BetaWithRawResponse:
+    def __init__(self, beta: Beta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def messages(self) -> MessagesWithRawResponse:
+        return MessagesWithRawResponse(self._beta.messages)
+
+
+class AsyncBetaWithRawResponse:
+    def __init__(self, beta: AsyncBeta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def messages(self) -> AsyncMessagesWithRawResponse:
+        return AsyncMessagesWithRawResponse(self._beta.messages)
+
+
+class BetaWithStreamingResponse:
+    def __init__(self, beta: Beta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def messages(self) -> MessagesWithStreamingResponse:
+        return MessagesWithStreamingResponse(self._beta.messages)
+
+
+class AsyncBetaWithStreamingResponse:
+    def __init__(self, beta: AsyncBeta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def messages(self) -> AsyncMessagesWithStreamingResponse:
+        return AsyncMessagesWithStreamingResponse(self._beta.messages)

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/_beta_messages.py

@@ -0,0 +1,93 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ... import _legacy_response
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...resources.beta import Messages as FirstPartyMessagesAPI, AsyncMessages as FirstPartyAsyncMessagesAPI
+
+__all__ = ["Messages", "AsyncMessages"]
+
+
+class Messages(SyncAPIResource):
+    create = FirstPartyMessagesAPI.create
+
+    @cached_property
+    def with_raw_response(self) -> MessagesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return MessagesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> MessagesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return MessagesWithStreamingResponse(self)
+
+
+class AsyncMessages(AsyncAPIResource):
+    create = FirstPartyAsyncMessagesAPI.create
+
+    @cached_property
+    def with_raw_response(self) -> AsyncMessagesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncMessagesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncMessagesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncMessagesWithStreamingResponse(self)
+
+
+class MessagesWithRawResponse:
+    def __init__(self, messages: Messages) -> None:
+        self._messages = messages
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            messages.create,
+        )
+
+
+class AsyncMessagesWithRawResponse:
+    def __init__(self, messages: AsyncMessages) -> None:
+        self._messages = messages
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            messages.create,
+        )
+
+
+class MessagesWithStreamingResponse:
+    def __init__(self, messages: Messages) -> None:
+        self._messages = messages
+
+        self.create = to_streamed_response_wrapper(
+            messages.create,
+        )
+
+
+class AsyncMessagesWithStreamingResponse:
+    def __init__(self, messages: AsyncMessages) -> None:
+        self._messages = messages
+
+        self.create = async_to_streamed_response_wrapper(
+            messages.create,
+        )

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/_client.py

@@ -0,0 +1,458 @@
+from __future__ import annotations
+
+import os
+import logging
+import urllib.parse
+from typing import Any, Union, Mapping, TypeVar
+from typing_extensions import Self, override
+
+import httpx
+
+from ... import _exceptions
+from ._beta import Beta, AsyncBeta
+from ..._types import NOT_GIVEN, Timeout, NotGiven
+from ..._utils import is_dict, is_given
+from ..._compat import model_copy
+from ..._version import __version__
+from ..._streaming import Stream, AsyncStream
+from ..._exceptions import AnthropicError, APIStatusError
+from ..._base_client import (
+    DEFAULT_MAX_RETRIES,
+    BaseClient,
+    SyncAPIClient,
+    AsyncAPIClient,
+    FinalRequestOptions,
+)
+from ._stream_decoder import AWSEventStreamDecoder
+from ...resources.messages import Messages, AsyncMessages
+from ...resources.completions import Completions, AsyncCompletions
+
+log: logging.Logger = logging.getLogger(__name__)
+
+DEFAULT_VERSION = "bedrock-2023-05-31"
+
+_HttpxClientT = TypeVar("_HttpxClientT", bound=Union[httpx.Client, httpx.AsyncClient])
+_DefaultStreamT = TypeVar("_DefaultStreamT", bound=Union[Stream[Any], AsyncStream[Any]])
+
+
+def _prepare_options(input_options: FinalRequestOptions) -> FinalRequestOptions:
+    options = model_copy(input_options, deep=True)
+
+    if is_dict(options.json_data):
+        options.json_data.setdefault("anthropic_version", DEFAULT_VERSION)
+
+        if is_given(options.headers):
+            betas = options.headers.get("anthropic-beta")
+            if betas:
+                options.json_data.setdefault("anthropic_beta", betas.split(","))
+
+    if options.url in {"/v1/complete", "/v1/messages", "/v1/messages?beta=true"} and options.method == "post":
+        if not is_dict(options.json_data):
+            raise RuntimeError("Expected dictionary json_data for post /completions endpoint")
+
+        model = options.json_data.pop("model", None)
+        model = urllib.parse.quote(str(model), safe=":")
+        stream = options.json_data.pop("stream", False)
+        if stream:
+            options.url = f"/model/{model}/invoke-with-response-stream"
+        else:
+            options.url = f"/model/{model}/invoke"
+
+    if options.url.startswith("/v1/messages/batches"):
+        raise AnthropicError("The Batch API is not supported in Bedrock yet")
+
+    if options.url == "/v1/messages/count_tokens":
+        raise AnthropicError("Token counting is not supported in Bedrock yet")
+
+    return options
+
+
+def _infer_region() -> str:
+    """
+    Infer the AWS region from the environment variables or
+    from the boto3 session if available.
+    """
+    aws_region = os.environ.get("AWS_REGION")
+    if aws_region is None:
+        try:
+            import boto3
+
+            session = boto3.Session()
+            if session.region_name:
+                aws_region = session.region_name
+        except ImportError:
+            pass
+
+    if aws_region is None:
+        log.warning("No AWS region specified, defaulting to us-east-1")
+        aws_region = "us-east-1"  # fall back to legacy behavior
+
+    return aws_region
+
+
+class BaseBedrockClient(BaseClient[_HttpxClientT, _DefaultStreamT]):
+    @override
+    def _make_status_error(
+        self,
+        err_msg: str,
+        *,
+        body: object,
+        response: httpx.Response,
+    ) -> APIStatusError:
+        if response.status_code == 400:
+            return _exceptions.BadRequestError(err_msg, response=response, body=body)
+
+        if response.status_code == 401:
+            return _exceptions.AuthenticationError(err_msg, response=response, body=body)
+
+        if response.status_code == 403:
+            return _exceptions.PermissionDeniedError(err_msg, response=response, body=body)
+
+        if response.status_code == 404:
+            return _exceptions.NotFoundError(err_msg, response=response, body=body)
+
+        if response.status_code == 409:
+            return _exceptions.ConflictError(err_msg, response=response, body=body)
+
+        if response.status_code == 422:
+            return _exceptions.UnprocessableEntityError(err_msg, response=response, body=body)
+
+        if response.status_code == 429:
+            return _exceptions.RateLimitError(err_msg, response=response, body=body)
+
+        if response.status_code == 503:
+            return _exceptions.ServiceUnavailableError(err_msg, response=response, body=body)
+
+        if response.status_code >= 500:
+            return _exceptions.InternalServerError(err_msg, response=response, body=body)
+        return APIStatusError(err_msg, response=response, body=body)
+
+
+class AnthropicBedrock(BaseBedrockClient[httpx.Client, Stream[Any]], SyncAPIClient):
+    messages: Messages
+    completions: Completions
+    beta: Beta
+
+    def __init__(
+        self,
+        aws_secret_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        aws_session_token: str | None = None,
+        api_key: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        # Configure a custom httpx client. See the [httpx documentation](https://www.python-httpx.org/api/#client) for more details.
+        http_client: httpx.Client | None = None,
+        # Enable or disable schema validation for data returned by the API.
+        # When enabled an error APIResponseValidationError is raised
+        # if the API responds with invalid data for the expected schema.
+        #
+        # This parameter may be removed or changed in the future.
+        # If you rely on this feature, please open a GitHub issue
+        # outlining your use-case to help us decide if it should be
+        # part of our public interface in the future.
+        _strict_response_validation: bool = False,
+    ) -> None:
+        if api_key is None:
+            api_key = os.environ.get("AWS_BEARER_TOKEN_BEDROCK")
+
+        has_aws_credentials = (
+            aws_access_key is not None
+            or aws_secret_key is not None
+            or aws_session_token is not None
+            or aws_profile is not None
+        )
+        if api_key is not None and has_aws_credentials:
+            raise ValueError(
+                "Cannot specify both `api_key` and AWS credentials (`aws_access_key`, `aws_secret_key`, `aws_session_token`, `aws_profile`)"
+            )
+
+        self.api_key: str | None = api_key
+
+        self.aws_secret_key = aws_secret_key
+
+        self.aws_access_key = aws_access_key
+
+        self.aws_region = _infer_region() if aws_region is None else aws_region
+        self.aws_profile = aws_profile
+
+        self.aws_session_token = aws_session_token
+
+        if base_url is None:
+            base_url = os.environ.get("ANTHROPIC_BEDROCK_BASE_URL")
+        if base_url is None:
+            base_url = f"https://bedrock-runtime.{self.aws_region}.amazonaws.com"
+
+        super().__init__(
+            version=__version__,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            custom_headers=default_headers,
+            custom_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+
+        self.beta = Beta(self)
+        self.messages = Messages(self)
+        self.completions = Completions(self)
+
+    @override
+    def _make_sse_decoder(self) -> AWSEventStreamDecoder:
+        return AWSEventStreamDecoder()
+
+    @override
+    def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        return _prepare_options(options)
+
+    @override
+    def _prepare_request(self, request: httpx.Request) -> None:
+        if self.api_key is not None:
+            request.headers["Authorization"] = f"Bearer {self.api_key}"
+            return
+
+        from ._auth import get_auth_headers
+
+        data = request.read().decode()
+
+        headers = get_auth_headers(
+            method=request.method,
+            url=str(request.url),
+            headers=request.headers,
+            aws_access_key=self.aws_access_key,
+            aws_secret_key=self.aws_secret_key,
+            aws_session_token=self.aws_session_token,
+            region=self.aws_region or "us-east-1",
+            profile=self.aws_profile,
+            data=data,
+        )
+        request.headers.update(headers)
+
+    def copy(
+        self,
+        *,
+        aws_secret_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_region: str | None = None,
+        aws_session_token: str | None = None,
+        api_key: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.Client | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        """
+        Create a new client instance re-using the same options given to the current client with optional overriding.
+        """
+        if default_headers is not None and set_default_headers is not None:
+            raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
+
+        if default_query is not None and set_default_query is not None:
+            raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
+
+        headers = self._custom_headers
+        if default_headers is not None:
+            headers = {**headers, **default_headers}
+        elif set_default_headers is not None:
+            headers = set_default_headers
+
+        params = self._custom_query
+        if default_query is not None:
+            params = {**params, **default_query}
+        elif set_default_query is not None:
+            params = set_default_query
+
+        return self.__class__(
+            aws_secret_key=aws_secret_key or self.aws_secret_key,
+            aws_access_key=aws_access_key or self.aws_access_key,
+            aws_region=aws_region or self.aws_region,
+            aws_session_token=aws_session_token or self.aws_session_token,
+            api_key=api_key or self.api_key,
+            base_url=base_url or self.base_url,
+            timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
+            http_client=http_client,
+            max_retries=max_retries if is_given(max_retries) else self.max_retries,
+            default_headers=headers,
+            default_query=params,
+            **_extra_kwargs,
+        )
+
+    # Alias for `copy` for nicer inline usage, e.g.
+    # client.with_options(timeout=10).foo.create(...)
+    with_options = copy
+
+
+class AsyncAnthropicBedrock(BaseBedrockClient[httpx.AsyncClient, AsyncStream[Any]], AsyncAPIClient):
+    messages: AsyncMessages
+    completions: AsyncCompletions
+    beta: AsyncBeta
+
+    def __init__(
+        self,
+        aws_secret_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        aws_session_token: str | None = None,
+        api_key: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        # Configure a custom httpx client. See the [httpx documentation](https://www.python-httpx.org/api/#client) for more details.
+        http_client: httpx.AsyncClient | None = None,
+        # Enable or disable schema validation for data returned by the API.
+        # When enabled an error APIResponseValidationError is raised
+        # if the API responds with invalid data for the expected schema.
+        #
+        # This parameter may be removed or changed in the future.
+        # If you rely on this feature, please open a GitHub issue
+        # outlining your use-case to help us decide if it should be
+        # part of our public interface in the future.
+        _strict_response_validation: bool = False,
+    ) -> None:
+        if api_key is None:
+            api_key = os.environ.get("AWS_BEARER_TOKEN_BEDROCK")
+
+        has_aws_credentials = (
+            aws_access_key is not None
+            or aws_secret_key is not None
+            or aws_session_token is not None
+            or aws_profile is not None
+        )
+        if api_key is not None and has_aws_credentials:
+            raise ValueError(
+                "Cannot specify both `api_key` and AWS credentials (`aws_access_key`, `aws_secret_key`, `aws_session_token`, `aws_profile`)"
+            )
+
+        self.api_key: str | None = api_key
+
+        self.aws_secret_key = aws_secret_key
+
+        self.aws_access_key = aws_access_key
+
+        self.aws_region = _infer_region() if aws_region is None else aws_region
+        self.aws_profile = aws_profile
+
+        self.aws_session_token = aws_session_token
+
+        if base_url is None:
+            base_url = os.environ.get("ANTHROPIC_BEDROCK_BASE_URL")
+        if base_url is None:
+            base_url = f"https://bedrock-runtime.{self.aws_region}.amazonaws.com"
+
+        super().__init__(
+            version=__version__,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            custom_headers=default_headers,
+            custom_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+
+        self.messages = AsyncMessages(self)
+        self.completions = AsyncCompletions(self)
+        self.beta = AsyncBeta(self)
+
+    @override
+    def _make_sse_decoder(self) -> AWSEventStreamDecoder:
+        return AWSEventStreamDecoder()
+
+    @override
+    async def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        return _prepare_options(options)
+
+    @override
+    async def _prepare_request(self, request: httpx.Request) -> None:
+        if self.api_key is not None:
+            request.headers["Authorization"] = f"Bearer {self.api_key}"
+            return
+
+        from ._auth import get_auth_headers
+
+        data = request.read().decode()
+
+        headers = get_auth_headers(
+            method=request.method,
+            url=str(request.url),
+            headers=request.headers,
+            aws_access_key=self.aws_access_key,
+            aws_secret_key=self.aws_secret_key,
+            aws_session_token=self.aws_session_token,
+            region=self.aws_region or "us-east-1",
+            profile=self.aws_profile,
+            data=data,
+        )
+        request.headers.update(headers)
+
+    def copy(
+        self,
+        *,
+        aws_secret_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_region: str | None = None,
+        aws_session_token: str | None = None,
+        api_key: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.AsyncClient | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        """
+        Create a new client instance re-using the same options given to the current client with optional overriding.
+        """
+        if default_headers is not None and set_default_headers is not None:
+            raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
+
+        if default_query is not None and set_default_query is not None:
+            raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
+
+        headers = self._custom_headers
+        if default_headers is not None:
+            headers = {**headers, **default_headers}
+        elif set_default_headers is not None:
+            headers = set_default_headers
+
+        params = self._custom_query
+        if default_query is not None:
+            params = {**params, **default_query}
+        elif set_default_query is not None:
+            params = set_default_query
+
+        return self.__class__(
+            aws_secret_key=aws_secret_key or self.aws_secret_key,
+            aws_access_key=aws_access_key or self.aws_access_key,
+            aws_region=aws_region or self.aws_region,
+            aws_session_token=aws_session_token or self.aws_session_token,
+            api_key=api_key or self.api_key,
+            base_url=base_url or self.base_url,
+            timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
+            http_client=http_client,
+            max_retries=max_retries if is_given(max_retries) else self.max_retries,
+            default_headers=headers,
+            default_query=params,
+            **_extra_kwargs,
+        )
+
+    # Alias for `copy` for nicer inline usage, e.g.
+    # client.with_options(timeout=10).foo.create(...)
+    with_options = copy

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/_mantle.py

@@ -0,0 +1,512 @@
+from __future__ import annotations
+
+import os
+from typing import Any, Union, Mapping, TypeVar
+from typing_extensions import Self, override
+
+import httpx
+
+from ... import _exceptions
+from ..._qs import Querystring
+from ..._types import NOT_GIVEN, Omit, Timeout, NotGiven
+from ..._utils import is_given
+from ..._compat import cached_property
+from ..._version import __version__
+from ..aws._auth import get_auth_headers
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._streaming import Stream, AsyncStream
+from ..._exceptions import AnthropicError, APIStatusError
+from ..._base_client import (
+    DEFAULT_MAX_RETRIES,
+    BaseClient,
+    SyncAPIClient,
+    AsyncAPIClient,
+)
+from ..aws._credentials import (
+    resolve_region,
+    resolve_api_key,
+    resolve_auth_mode,
+    validate_credentials,
+)
+from ...resources.messages import Messages, AsyncMessages
+from ...resources.beta.messages import Messages as BetaMessages, AsyncMessages as AsyncBetaMessages
+
+DEFAULT_SERVICE_NAME = "bedrock-mantle"
+
+_MANTLE_API_KEY_ENV_VARS = ("AWS_BEARER_TOKEN_BEDROCK", "ANTHROPIC_AWS_API_KEY")
+
+_HttpxClientT = TypeVar("_HttpxClientT", bound=Union[httpx.Client, httpx.AsyncClient])
+_DefaultStreamT = TypeVar("_DefaultStreamT", bound=Union[Stream[Any], AsyncStream[Any]])
+
+
+# --- Beta resources (messages-only) ---
+
+
+class MantleBeta(SyncAPIResource):
+    @cached_property
+    def messages(self) -> BetaMessages:
+        return BetaMessages(self._client)
+
+
+class AsyncMantleBeta(AsyncAPIResource):
+    @cached_property
+    def messages(self) -> AsyncBetaMessages:
+        return AsyncBetaMessages(self._client)
+
+
+# --- Base ---
+
+
+class BaseMantleClient(BaseClient[_HttpxClientT, _DefaultStreamT]):
+    @override
+    def _make_status_error(
+        self,
+        err_msg: str,
+        *,
+        body: object,
+        response: httpx.Response,
+    ) -> APIStatusError:
+        if response.status_code == 400:
+            return _exceptions.BadRequestError(err_msg, response=response, body=body)
+
+        if response.status_code == 401:
+            return _exceptions.AuthenticationError(err_msg, response=response, body=body)
+
+        if response.status_code == 403:
+            return _exceptions.PermissionDeniedError(err_msg, response=response, body=body)
+
+        if response.status_code == 404:
+            return _exceptions.NotFoundError(err_msg, response=response, body=body)
+
+        if response.status_code == 409:
+            return _exceptions.ConflictError(err_msg, response=response, body=body)
+
+        if response.status_code == 413:
+            return _exceptions.RequestTooLargeError(err_msg, response=response, body=body)
+
+        if response.status_code == 422:
+            return _exceptions.UnprocessableEntityError(err_msg, response=response, body=body)
+
+        if response.status_code == 429:
+            return _exceptions.RateLimitError(err_msg, response=response, body=body)
+
+        if response.status_code == 529:
+            return _exceptions.OverloadedError(err_msg, response=response, body=body)
+
+        if response.status_code >= 500:
+            return _exceptions.InternalServerError(err_msg, response=response, body=body)
+        return APIStatusError(err_msg, response=response, body=body)
+
+
+# --- Shared init logic ---
+
+
+def _resolve_mantle_config(
+    *,
+    api_key: str | None,
+    aws_access_key: str | None,
+    aws_secret_key: str | None,
+    aws_region: str | None,
+    aws_profile: str | None,
+    skip_auth: bool,
+    base_url: str | httpx.URL | None,
+    default_headers: Mapping[str, str] | None,
+) -> tuple[str | None, str | httpx.URL, bool, dict[str, str]]:
+    """Resolve and validate all Mantle client configuration.
+
+    Returns (resolved_api_key, resolved_base_url, use_sigv4, merged_headers).
+    """
+    if skip_auth:
+        use_sigv4 = False
+        resolved_api_key = None
+    else:
+        validate_credentials(aws_access_key=aws_access_key, aws_secret_key=aws_secret_key)
+
+        use_sigv4 = resolve_auth_mode(
+            api_key=api_key,
+            aws_access_key=aws_access_key,
+            aws_secret_key=aws_secret_key,
+            aws_profile=aws_profile,
+            api_key_env_vars=_MANTLE_API_KEY_ENV_VARS,
+        )
+
+        resolved_api_key = resolve_api_key(
+            api_key=api_key,
+            use_sigv4=use_sigv4,
+            api_key_env_vars=_MANTLE_API_KEY_ENV_VARS,
+        )
+
+    resolved_region = resolve_region(aws_region)
+
+    if base_url is None:
+        base_url = os.environ.get("ANTHROPIC_BEDROCK_MANTLE_BASE_URL")
+    if base_url is None:
+        if resolved_region is None:
+            raise AnthropicError(
+                "No AWS region or base URL found. Set `aws_region` in the constructor, "
+                "the `AWS_REGION` / `AWS_DEFAULT_REGION` environment variable, or provide "
+                "a `base_url` / `ANTHROPIC_BEDROCK_MANTLE_BASE_URL` environment variable."
+            )
+        base_url = f"https://bedrock-mantle.{resolved_region}.api.aws/anthropic"
+
+    merged_headers: dict[str, str] = {}
+    if default_headers:
+        merged_headers.update(default_headers)
+
+    return resolved_api_key, base_url, use_sigv4, merged_headers
+
+
+# --- Sync client ---
+
+
+class AnthropicBedrockMantle(BaseMantleClient[httpx.Client, Stream[Any]], SyncAPIClient):
+    messages: Messages
+    beta: MantleBeta
+
+    aws_region: str | None
+    aws_access_key: str | None
+    aws_secret_key: str | None
+    aws_session_token: str | None
+    aws_profile: str | None
+    skip_auth: bool
+
+    _use_sigv4: bool
+
+    def __init__(
+        self,
+        *,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_session_token: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        api_key: str | None = None,
+        skip_auth: bool = False,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.Client | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None:
+        resolved_api_key, resolved_base_url, use_sigv4, merged_headers = _resolve_mantle_config(
+            api_key=api_key,
+            aws_access_key=aws_access_key,
+            aws_secret_key=aws_secret_key,
+            aws_region=aws_region,
+            aws_profile=aws_profile,
+            skip_auth=skip_auth,
+            base_url=base_url,
+            default_headers=default_headers,
+        )
+
+        resolved_region = resolve_region(aws_region)
+
+        super().__init__(
+            version=__version__,
+            base_url=resolved_base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            custom_headers=merged_headers,
+            custom_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+
+        self.api_key = resolved_api_key
+        self.aws_region = resolved_region
+        self.aws_access_key = aws_access_key
+        self.aws_secret_key = aws_secret_key
+        self.aws_session_token = aws_session_token
+        self.aws_profile = aws_profile
+        self.skip_auth = skip_auth
+        self._use_sigv4 = use_sigv4
+
+        self.messages = Messages(self)
+        self.beta = MantleBeta(self)
+
+    @property
+    @override
+    def qs(self) -> Querystring:
+        return Querystring(array_format="comma")
+
+    @property
+    @override
+    def auth_headers(self) -> dict[str, str]:
+        if self.skip_auth or self._use_sigv4:
+            return {}
+        api_key = self.api_key
+        if api_key is None:
+            return {}
+        return {"Authorization": f"Bearer {api_key}"}
+
+    @property
+    @override
+    def default_headers(self) -> dict[str, str | Omit]:
+        return {
+            **super().default_headers,
+            "X-Stainless-Async": "false",
+            "anthropic-version": "2023-06-01",
+            **self._custom_headers,
+        }
+
+    @override
+    def _validate_headers(self, headers: Any, custom_headers: Any) -> None:
+        pass
+
+    @override
+    def _prepare_request(self, request: httpx.Request) -> None:
+        if self.skip_auth or not self._use_sigv4:
+            return
+
+        data = request.read().decode()
+
+        headers = get_auth_headers(
+            method=request.method,
+            url=str(request.url),
+            headers=request.headers,
+            aws_access_key=self.aws_access_key,
+            aws_secret_key=self.aws_secret_key,
+            aws_session_token=self.aws_session_token,
+            region=self.aws_region,
+            profile=self.aws_profile,
+            data=data,
+            service_name=DEFAULT_SERVICE_NAME,
+        )
+        request.headers.update(headers)
+
+    def copy(
+        self,
+        *,
+        api_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_session_token: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        skip_auth: bool | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.Client | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        if default_headers is not None and set_default_headers is not None:
+            raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
+
+        if default_query is not None and set_default_query is not None:
+            raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
+
+        headers = self._custom_headers
+        if default_headers is not None:
+            headers = {**headers, **default_headers}
+        elif set_default_headers is not None:
+            headers = set_default_headers
+
+        params = self._custom_query
+        if default_query is not None:
+            params = {**params, **default_query}
+        elif set_default_query is not None:
+            params = set_default_query
+
+        return self.__class__(
+            api_key=api_key or self.api_key,
+            aws_access_key=aws_access_key or self.aws_access_key,
+            aws_secret_key=aws_secret_key or self.aws_secret_key,
+            aws_session_token=aws_session_token or self.aws_session_token,
+            aws_region=aws_region or self.aws_region,
+            aws_profile=aws_profile or self.aws_profile,
+            skip_auth=skip_auth if skip_auth is not None else self.skip_auth,
+            base_url=base_url or self.base_url,
+            timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
+            http_client=http_client,
+            max_retries=max_retries if is_given(max_retries) else self.max_retries,
+            default_headers=headers,
+            default_query=params,
+            **_extra_kwargs,
+        )
+
+    with_options = copy
+
+
+# --- Async client ---
+
+
+class AsyncAnthropicBedrockMantle(BaseMantleClient[httpx.AsyncClient, AsyncStream[Any]], AsyncAPIClient):
+    messages: AsyncMessages
+    beta: AsyncMantleBeta
+
+    aws_region: str | None
+    aws_access_key: str | None
+    aws_secret_key: str | None
+    aws_session_token: str | None
+    aws_profile: str | None
+    skip_auth: bool
+
+    _use_sigv4: bool
+
+    def __init__(
+        self,
+        *,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_session_token: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        api_key: str | None = None,
+        skip_auth: bool = False,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None:
+        resolved_api_key, resolved_base_url, use_sigv4, merged_headers = _resolve_mantle_config(
+            api_key=api_key,
+            aws_access_key=aws_access_key,
+            aws_secret_key=aws_secret_key,
+            aws_region=aws_region,
+            aws_profile=aws_profile,
+            skip_auth=skip_auth,
+            base_url=base_url,
+            default_headers=default_headers,
+        )
+
+        resolved_region = resolve_region(aws_region)
+
+        super().__init__(
+            version=__version__,
+            base_url=resolved_base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            custom_headers=merged_headers,
+            custom_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+
+        self.api_key = resolved_api_key
+        self.aws_region = resolved_region
+        self.aws_access_key = aws_access_key
+        self.aws_secret_key = aws_secret_key
+        self.aws_session_token = aws_session_token
+        self.aws_profile = aws_profile
+        self.skip_auth = skip_auth
+        self._use_sigv4 = use_sigv4
+
+        self.messages = AsyncMessages(self)
+        self.beta = AsyncMantleBeta(self)
+
+    @property
+    @override
+    def qs(self) -> Querystring:
+        return Querystring(array_format="comma")
+
+    @property
+    @override
+    def auth_headers(self) -> dict[str, str]:
+        if self.skip_auth or self._use_sigv4:
+            return {}
+        api_key = self.api_key
+        if api_key is None:
+            return {}
+        return {"Authorization": f"Bearer {api_key}"}
+
+    @property
+    @override
+    def default_headers(self) -> dict[str, str | Omit]:
+        return {
+            **super().default_headers,
+            "X-Stainless-Async": "async:asyncio",
+            "anthropic-version": "2023-06-01",
+            **self._custom_headers,
+        }
+
+    @override
+    def _validate_headers(self, headers: Any, custom_headers: Any) -> None:
+        pass
+
+    @override
+    async def _prepare_request(self, request: httpx.Request) -> None:
+        if self.skip_auth or not self._use_sigv4:
+            return
+
+        data = request.read().decode()
+
+        headers = get_auth_headers(
+            method=request.method,
+            url=str(request.url),
+            headers=request.headers,
+            aws_access_key=self.aws_access_key,
+            aws_secret_key=self.aws_secret_key,
+            aws_session_token=self.aws_session_token,
+            region=self.aws_region,
+            profile=self.aws_profile,
+            data=data,
+            service_name=DEFAULT_SERVICE_NAME,
+        )
+        request.headers.update(headers)
+
+    def copy(
+        self,
+        *,
+        api_key: str | None = None,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_session_token: str | None = None,
+        aws_region: str | None = None,
+        aws_profile: str | None = None,
+        skip_auth: bool | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.AsyncClient | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        if default_headers is not None and set_default_headers is not None:
+            raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
+
+        if default_query is not None and set_default_query is not None:
+            raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
+
+        headers = self._custom_headers
+        if default_headers is not None:
+            headers = {**headers, **default_headers}
+        elif set_default_headers is not None:
+            headers = set_default_headers
+
+        params = self._custom_query
+        if default_query is not None:
+            params = {**params, **default_query}
+        elif set_default_query is not None:
+            params = set_default_query
+
+        return self.__class__(
+            api_key=api_key or self.api_key,
+            aws_access_key=aws_access_key or self.aws_access_key,
+            aws_secret_key=aws_secret_key or self.aws_secret_key,
+            aws_session_token=aws_session_token or self.aws_session_token,
+            aws_region=aws_region or self.aws_region,
+            aws_profile=aws_profile or self.aws_profile,
+            skip_auth=skip_auth if skip_auth is not None else self.skip_auth,
+            base_url=base_url or self.base_url,
+            timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
+            http_client=http_client,
+            max_retries=max_retries if is_given(max_retries) else self.max_retries,
+            default_headers=headers,
+            default_query=params,
+            **_extra_kwargs,
+        )
+
+    with_options = copy

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/_stream.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TypeVar
+
+import httpx
+
+from ..._client import Anthropic, AsyncAnthropic
+from ..._streaming import Stream, AsyncStream
+from ._stream_decoder import AWSEventStreamDecoder
+
+_T = TypeVar("_T")
+
+
+class BedrockStream(Stream[_T]):
+    def __init__(
+        self,
+        *,
+        cast_to: type[_T],
+        response: httpx.Response,
+        client: Anthropic,
+    ) -> None:
+        super().__init__(cast_to=cast_to, response=response, client=client)
+
+        self._decoder = AWSEventStreamDecoder()
+
+
+class AsyncBedrockStream(AsyncStream[_T]):
+    def __init__(
+        self,
+        *,
+        cast_to: type[_T],
+        response: httpx.Response,
+        client: AsyncAnthropic,
+    ) -> None:
+        super().__init__(cast_to=cast_to, response=response, client=client)
+
+        self._decoder = AWSEventStreamDecoder()

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/bedrock/_stream_decoder.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterator, AsyncIterator
+
+from ..._utils import lru_cache
+from ..._streaming import ServerSentEvent
+
+if TYPE_CHECKING:
+    from botocore.model import Shape
+    from botocore.eventstream import EventStreamMessage
+
+
+@lru_cache(maxsize=None)
+def get_response_stream_shape() -> Shape:
+    from botocore.model import ServiceModel
+    from botocore.loaders import Loader
+
+    loader = Loader()
+    bedrock_service_dict = loader.load_service_model("bedrock-runtime", "service-2")
+    bedrock_service_model = ServiceModel(bedrock_service_dict)
+    return bedrock_service_model.shape_for("ResponseStream")
+
+
+class AWSEventStreamDecoder:
+    def __init__(self) -> None:
+        from botocore.parsers import EventStreamJSONParser
+
+        self.parser = EventStreamJSONParser()
+
+    def iter_bytes(self, iterator: Iterator[bytes]) -> Iterator[ServerSentEvent]:
+        """Given an iterator that yields lines, iterate over it & yield every event encountered"""
+        from botocore.eventstream import EventStreamBuffer
+
+        event_stream_buffer = EventStreamBuffer()
+        for chunk in iterator:
+            event_stream_buffer.add_data(chunk)
+            for event in event_stream_buffer:
+                message = self._parse_message_from_event(event)
+                if message:
+                    yield ServerSentEvent(data=message, event="completion")
+
+    async def aiter_bytes(self, iterator: AsyncIterator[bytes]) -> AsyncIterator[ServerSentEvent]:
+        """Given an async iterator that yields lines, iterate over it & yield every event encountered"""
+        from botocore.eventstream import EventStreamBuffer
+
+        event_stream_buffer = EventStreamBuffer()
+        async for chunk in iterator:
+            event_stream_buffer.add_data(chunk)
+            for event in event_stream_buffer:
+                message = self._parse_message_from_event(event)
+                if message:
+                    yield ServerSentEvent(data=message, event="completion")
+
+    def _parse_message_from_event(self, event: EventStreamMessage) -> str | None:
+        response_dict = event.to_response_dict()
+        parsed_response = self.parser.parse(response_dict, get_response_stream_shape())
+        if response_dict["status_code"] != 200:
+            raise ValueError(f"Bad response code, expected 200: {response_dict}")
+
+        chunk = parsed_response.get("chunk")
+        if not chunk:
+            return None
+
+        return chunk.get("bytes").decode()  # type: ignore[no-any-return]

hientran/sythetic_crawl_data/crawl/lib64/python3.12/site-packages/anthropic/lib/credentials/__init__.py

@@ -0,0 +1,39 @@
+from ._auth import AccessTokenAuth as AccessTokenAuth
+from ._cache import TokenCache as TokenCache
+from ._chain import default_credentials as default_credentials
+from ._types import (
+    AccessToken as AccessToken,
+    CredentialResult as CredentialResult,
+    AccessTokenProvider as AccessTokenProvider,
+    IdentityTokenProvider as IdentityTokenProvider,
+)
+from ._workload import (
+    WorkloadIdentityError as WorkloadIdentityError,
+    WorkloadIdentityCredentials as WorkloadIdentityCredentials,
+    exchange_federation_assertion as exchange_federation_assertion,
+)
+from ._providers import (
+    EnvToken as EnvToken,
+    StaticToken as StaticToken,
+    InMemoryConfig as InMemoryConfig,
+    CredentialsFile as CredentialsFile,
+    IdentityTokenFile as IdentityTokenFile,
+)
+
+__all__ = [
+    "AccessToken",
+    "AccessTokenProvider",
+    "CredentialResult",
+    "IdentityTokenProvider",
+    "StaticToken",
+    "EnvToken",
+    "CredentialsFile",
+    "InMemoryConfig",
+    "IdentityTokenFile",
+    "WorkloadIdentityCredentials",
+    "WorkloadIdentityError",
+    "exchange_federation_assertion",
+    "TokenCache",
+    "AccessTokenAuth",
+    "default_credentials",
+]