anthropic 0.72.1__py3-none-any.whl → 0.74.0__py3-none-any.whl

anthropic/__init__.py

@@ -44,6 +44,7 @@ from ._exceptions import (
 )
 from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
 from ._utils._logs import setup_logging as _setup_logging
+from .lib._parse._transform import transform_schema
 
 __all__ = [
     "types",
@@ -91,6 +92,7 @@ __all__ = [
     "AI_PROMPT",
     "beta_tool",
     "beta_async_tool",
+    "transform_schema",
 ]
 
 if not _t.TYPE_CHECKING:
@@ -99,6 +101,7 @@ if not _t.TYPE_CHECKING:
 from .lib.tools import beta_tool, beta_async_tool
 from .lib.vertex import *
 from .lib.bedrock import *
+from .lib.foundry import AnthropicFoundry as AnthropicFoundry, AsyncAnthropicFoundry as AsyncAnthropicFoundry
 from .lib.streaming import *
 
 _setup_logging()

anthropic/_client.py

@@ -183,6 +183,10 @@ class Anthropic(SyncAPIClient):
 
     @override
     def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if headers.get("Authorization") or headers.get("X-Api-Key"):
+            # valid
+            return
+
         if self.api_key and headers.get("X-Api-Key"):
             return
         if isinstance(custom_headers.get("X-Api-Key"), Omit):
@@ -423,6 +427,10 @@ class AsyncAnthropic(AsyncAPIClient):
 
     @override
     def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if headers.get("Authorization") or headers.get("X-Api-Key"):
+            # valid
+            return
+
         if self.api_key and headers.get("X-Api-Key"):
             return
         if isinstance(custom_headers.get("X-Api-Key"), Omit):

anthropic/_compat.py

@@ -131,6 +131,12 @@ def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str:
     return model.model_dump_json(indent=indent)
 
 
+def model_parse_json(model: type[_ModelT], data: str | bytes) -> _ModelT:
+    if PYDANTIC_V1:
+        return model.parse_raw(data)  # pyright: ignore[reportDeprecated]
+    return model.model_validate_json(data)
+
+
 def model_dump(
     model: pydantic.BaseModel,
     *,

anthropic/_models.py

@@ -774,7 +774,7 @@ else:
 
 
 if not PYDANTIC_V1:
-    from pydantic import TypeAdapter as _TypeAdapter
+    from pydantic import TypeAdapter as _TypeAdapter, computed_field as computed_field
 
     _CachedTypeAdapter = cast("TypeAdapter[object]", lru_cache(maxsize=None)(_TypeAdapter))
 
@@ -811,6 +811,18 @@ elif not TYPE_CHECKING:  # TODO: condition is weird
     def TypeAdapter(*_args: Any, **_kwargs: Any) -> Any:
         raise RuntimeError("attempted to use TypeAdapter in pydantic v1")
 
+    def computed_field(func: Any | None = None, /, **__: Any) -> Any:
+        def _exc_func(*_: Any, **__: Any) -> Any:
+            raise RuntimeError("attempted to use computed_field in pydantic v1")
+
+        def _dec(*_: Any, **__: Any) -> Any:
+            return _exc_func
+
+        if func is not None:
+            return _dec(func)
+        else:
+            return _dec
+
 
 class FinalRequestOptionsInput(TypedDict, total=False):
     method: Required[str]

anthropic/_utils/_transform.py

@@ -218,7 +218,7 @@ def _transform_recursive(
         return data
 
     if isinstance(data, pydantic.BaseModel):
-        return model_dump(data, exclude_unset=True, mode="json")
+        return model_dump(data, exclude_unset=True, mode="json", exclude=getattr(data, "__api_exclude__", None))
 
     annotated_type = _get_annotated_type(annotation)
     if annotated_type is None:

anthropic/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "anthropic"
-__version__ = "0.72.1"  # x-release-please-version
+__version__ = "0.74.0"  # x-release-please-version

anthropic/lib/_files.py

@@ -22,7 +22,7 @@ def _collect_files(directory: Path, relative_to: Path, files: list[FileTypes]) -
             _collect_files(path, relative_to, files)
             continue
 
-        files.append((str(path.relative_to(relative_to)), path.read_bytes()))
+        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]:
@@ -39,4 +39,4 @@ async def _async_collect_files(directory: anyio.Path, relative_to: anyio.Path, f
             await _async_collect_files(path, relative_to, files)
             continue
 
-        files.append((str(path.relative_to(relative_to)), await path.read_bytes()))
+        files.append((path.relative_to(relative_to).as_posix(), await path.read_bytes()))

anthropic/lib/_parse/_response.py

@@ -0,0 +1,44 @@
+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.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_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,
+        },
+    )

anthropic/lib/_parse/_transform.py

@@ -0,0 +1,167 @@
+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_
+
+    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

anthropic/lib/foundry.md

@@ -0,0 +1,127 @@
+# Anthropic Foundry
+
+To use this library with Foundry, use the `AnthropicFoundry` class instead of the `Anthropic` class.
+
+
+## Installation
+
+```bash
+pip install anthropic
+```
+
+## Usage
+
+### Basic Usage with API Key
+
+```python
+from anthropic import AnthropicFoundry
+
+client = AnthropicFoundry(
+    api_key="...",  # defaults to ANTHROPIC_FOUNDRY_API_KEY environment variable
+    resource="my-resource",  # your Foundry resource
+)
+
+message = client.messages.create(
+    model="claude-3-5-sonnet-20241022",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+print(message.content[0].text)
+```
+
+### Using Azure AD Token Provider
+
+For enhanced security, you can use Azure AD (Microsoft Entra) authentication instead of an API key:
+
+```python
+from anthropic import AnthropicFoundry
+from azure.identity import DefaultAzureCredential
+from azure.identity import get_bearer_token_provider
+
+credential = DefaultAzureCredential()
+token_provider = get_bearer_token_provider(
+    credential, 
+    "https://ai.azure.com/.default"
+)
+
+client = AnthropicFoundry(
+    azure_ad_token_provider=token_provider,
+    resource="my-resource",
+)
+
+message = client.messages.create(
+    model="claude-3-5-sonnet-20241022",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+print(message.content[0].text)
+```
+
+## Examples
+
+### Streaming Messages
+
+```python
+from anthropic import AnthropicFoundry
+
+client = AnthropicFoundry(
+    api_key="...",
+    resource="my-resource",
+)
+
+with client.messages.stream(
+    model="claude-3-5-sonnet-20241022",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Write a haiku about programming"}],
+) as stream:
+    for text in stream.text_stream:
+        print(text, end="", flush=True)
+```
+
+### Async Usage
+
+```python
+from anthropic import AsyncAnthropicFoundry
+
+async def main():
+    client = AsyncAnthropicFoundry(
+        api_key="...",
+        resource="my-resource",
+    )
+    
+    message = await client.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello!"}],
+    )
+    
+    print(message.content[0].text)
+
+import asyncio
+asyncio.run(main())
+```
+
+### Async Streaming
+
+```python
+from anthropic import AsyncAnthropicFoundry
+
+async def main():
+    client = AsyncAnthropicFoundry(
+        api_key="...",
+        resource="my-resource",
+    )
+    
+    async with client.messages.stream(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Write a haiku about programming"}],
+    ) as stream:
+        async for text in stream.text_stream:
+            print(text, end="", flush=True)
+
+import asyncio
+asyncio.run(main())
+```