camb-sdk 1.5.4__py3-none-any.whl

camb/core/http_response.py

@@ -0,0 +1,55 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Dict, Generic, TypeVar
+
+import httpx
+
+# Generic to represent the underlying type of the data wrapped by the HTTP response.
+T = TypeVar("T")
+
+
+class BaseHttpResponse:
+    """Minimalist HTTP response wrapper that exposes response headers."""
+
+    _response: httpx.Response
+
+    def __init__(self, response: httpx.Response):
+        self._response = response
+
+    @property
+    def headers(self) -> Dict[str, str]:
+        return dict(self._response.headers)
+
+
+class HttpResponse(Generic[T], BaseHttpResponse):
+    """HTTP response wrapper that exposes response headers and data."""
+
+    _data: T
+
+    def __init__(self, response: httpx.Response, data: T):
+        super().__init__(response)
+        self._data = data
+
+    @property
+    def data(self) -> T:
+        return self._data
+
+    def close(self) -> None:
+        self._response.close()
+
+
+class AsyncHttpResponse(Generic[T], BaseHttpResponse):
+    """HTTP response wrapper that exposes response headers and data."""
+
+    _data: T
+
+    def __init__(self, response: httpx.Response, data: T):
+        super().__init__(response)
+        self._data = data
+
+    @property
+    def data(self) -> T:
+        return self._data
+
+    async def close(self) -> None:
+        await self._response.aclose()

camb/core/http_sse/__init__.py

@@ -0,0 +1,42 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from ._api import EventSource, aconnect_sse, connect_sse
+    from ._exceptions import SSEError
+    from ._models import ServerSentEvent
+_dynamic_imports: typing.Dict[str, str] = {
+    "EventSource": "._api",
+    "SSEError": "._exceptions",
+    "ServerSentEvent": "._models",
+    "aconnect_sse": "._api",
+    "connect_sse": "._api",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = ["EventSource", "SSEError", "ServerSentEvent", "aconnect_sse", "connect_sse"]

camb/core/http_sse/_api.py

@@ -0,0 +1,112 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import re
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any, AsyncGenerator, AsyncIterator, Iterator, cast
+
+import httpx
+from ._decoders import SSEDecoder
+from ._exceptions import SSEError
+from ._models import ServerSentEvent
+
+
+class EventSource:
+    def __init__(self, response: httpx.Response) -> None:
+        self._response = response
+
+    def _check_content_type(self) -> None:
+        content_type = self._response.headers.get("content-type", "").partition(";")[0]
+        if "text/event-stream" not in content_type:
+            raise SSEError(
+                f"Expected response header Content-Type to contain 'text/event-stream', got {content_type!r}"
+            )
+
+    def _get_charset(self) -> str:
+        """Extract charset from Content-Type header, fallback to UTF-8."""
+        content_type = self._response.headers.get("content-type", "")
+
+        # Parse charset parameter using regex
+        charset_match = re.search(r"charset=([^;\s]+)", content_type, re.IGNORECASE)
+        if charset_match:
+            charset = charset_match.group(1).strip("\"'")
+            # Validate that it's a known encoding
+            try:
+                # Test if the charset is valid by trying to encode/decode
+                "test".encode(charset).decode(charset)
+                return charset
+            except (LookupError, UnicodeError):
+                # If charset is invalid, fall back to UTF-8
+                pass
+
+        # Default to UTF-8 if no charset specified or invalid charset
+        return "utf-8"
+
+    @property
+    def response(self) -> httpx.Response:
+        return self._response
+
+    def iter_sse(self) -> Iterator[ServerSentEvent]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        charset = self._get_charset()
+
+        buffer = ""
+        for chunk in self._response.iter_bytes():
+            # Decode chunk using detected charset
+            text_chunk = chunk.decode(charset, errors="replace")
+            buffer += text_chunk
+
+            # Process complete lines
+            while "\n" in buffer:
+                line, buffer = buffer.split("\n", 1)
+                line = line.rstrip("\r")
+                sse = decoder.decode(line)
+                # when we reach a "\n\n" => line = ''
+                # => decoder will attempt to return an SSE Event
+                if sse is not None:
+                    yield sse
+
+        # Process any remaining data in buffer
+        if buffer.strip():
+            line = buffer.rstrip("\r")
+            sse = decoder.decode(line)
+            if sse is not None:
+                yield sse
+
+    async def aiter_sse(self) -> AsyncGenerator[ServerSentEvent, None]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        lines = cast(AsyncGenerator[str, None], self._response.aiter_lines())
+        try:
+            async for line in lines:
+                line = line.rstrip("\n")
+                sse = decoder.decode(line)
+                if sse is not None:
+                    yield sse
+        finally:
+            await lines.aclose()
+
+
+@contextmanager
+def connect_sse(client: httpx.Client, method: str, url: str, **kwargs: Any) -> Iterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)
+
+
+@asynccontextmanager
+async def aconnect_sse(
+    client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    **kwargs: Any,
+) -> AsyncIterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    async with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)

camb/core/http_sse/_decoders.py

@@ -0,0 +1,61 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import List, Optional
+
+from ._models import ServerSentEvent
+
+
+class SSEDecoder:
+    def __init__(self) -> None:
+        self._event = ""
+        self._data: List[str] = []
+        self._last_event_id = ""
+        self._retry: Optional[int] = None
+
+    def decode(self, line: str) -> Optional[ServerSentEvent]:
+        # See: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation  # noqa: E501
+
+        if not line:
+            if not self._event and not self._data and not self._last_event_id and self._retry is None:
+                return None
+
+            sse = ServerSentEvent(
+                event=self._event,
+                data="\n".join(self._data),
+                id=self._last_event_id,
+                retry=self._retry,
+            )
+
+            # NOTE: as per the SSE spec, do not reset last_event_id.
+            self._event = ""
+            self._data = []
+            self._retry = None
+
+            return sse
+
+        if line.startswith(":"):
+            return None
+
+        fieldname, _, value = line.partition(":")
+
+        if value.startswith(" "):
+            value = value[1:]
+
+        if fieldname == "event":
+            self._event = value
+        elif fieldname == "data":
+            self._data.append(value)
+        elif fieldname == "id":
+            if "\0" in value:
+                pass
+            else:
+                self._last_event_id = value
+        elif fieldname == "retry":
+            try:
+                self._retry = int(value)
+            except (TypeError, ValueError):
+                pass
+        else:
+            pass  # Field is ignored.
+
+        return None

camb/core/http_sse/_exceptions.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import httpx
+
+
+class SSEError(httpx.TransportError):
+    pass

camb/core/http_sse/_models.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import json
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass(frozen=True)
+class ServerSentEvent:
+    event: str = "message"
+    data: str = ""
+    id: str = ""
+    retry: Optional[int] = None
+
+    def json(self) -> Any:
+        """Parse the data field as JSON."""
+        return json.loads(self.data)

camb/core/jsonable_encoder.py

@@ -0,0 +1,100 @@
+# This file was auto-generated by Fern from our API Definition.
+
+"""
+jsonable_encoder converts a Python object to a JSON-friendly dict
+(e.g. datetimes to strings, Pydantic models to dicts).
+
+Taken from FastAPI, and made a bit simpler
+https://github.com/tiangolo/fastapi/blob/master/fastapi/encoders.py
+"""
+
+import base64
+import dataclasses
+import datetime as dt
+from enum import Enum
+from pathlib import PurePath
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Set, Union
+
+import pydantic
+from .datetime_utils import serialize_datetime
+from .pydantic_utilities import (
+    IS_PYDANTIC_V2,
+    encode_by_type,
+    to_jsonable_with_fallback,
+)
+
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
+
+def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if isinstance(obj, pydantic.BaseModel):
+        if IS_PYDANTIC_V2:
+            encoder = getattr(obj.model_config, "json_encoders", {})  # type: ignore # Pydantic v2
+        else:
+            encoder = getattr(obj.__config__, "json_encoders", {})  # type: ignore # Pydantic v1
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        obj_dict = obj.dict(by_alias=True)
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        if "root" in obj_dict:
+            obj_dict = obj_dict["root"]
+        return jsonable_encoder(obj_dict, custom_encoder=encoder)
+    if dataclasses.is_dataclass(obj):
+        obj_dict = dataclasses.asdict(obj)  # type: ignore
+        return jsonable_encoder(obj_dict, custom_encoder=custom_encoder)
+    if isinstance(obj, bytes):
+        return base64.b64encode(obj).decode("utf-8")
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, dt.datetime):
+        return serialize_datetime(obj)
+    if isinstance(obj, dt.date):
+        return str(obj)
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        allowed_keys = set(obj.keys())
+        for key, value in obj.items():
+            if key in allowed_keys:
+                encoded_key = jsonable_encoder(key, custom_encoder=custom_encoder)
+                encoded_value = jsonable_encoder(value, custom_encoder=custom_encoder)
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
+        return encoded_list
+
+    def fallback_serializer(o: Any) -> Any:
+        attempt_encode = encode_by_type(o)
+        if attempt_encode is not None:
+            return attempt_encode
+
+        try:
+            data = dict(o)
+        except Exception as e:
+            errors: List[Exception] = []
+            errors.append(e)
+            try:
+                data = vars(o)
+            except Exception as e:
+                errors.append(e)
+                raise ValueError(errors) from e
+        return jsonable_encoder(data, custom_encoder=custom_encoder)
+
+    return to_jsonable_with_fallback(obj, fallback_serializer)

camb/core/pydantic_utilities.py

@@ -0,0 +1,260 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# nopycln: file
+import datetime as dt
+from collections import defaultdict
+from typing import Any, Callable, ClassVar, Dict, List, Mapping, Optional, Set, Tuple, Type, TypeVar, Union, cast
+
+import pydantic
+
+IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+if IS_PYDANTIC_V2:
+    from pydantic.v1.datetime_parse import parse_date as parse_date
+    from pydantic.v1.datetime_parse import parse_datetime as parse_datetime
+    from pydantic.v1.fields import ModelField as ModelField
+    from pydantic.v1.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[attr-defined]
+    from pydantic.v1.typing import get_args as get_args
+    from pydantic.v1.typing import get_origin as get_origin
+    from pydantic.v1.typing import is_literal_type as is_literal_type
+    from pydantic.v1.typing import is_union as is_union
+else:
+    from pydantic.datetime_parse import parse_date as parse_date  # type: ignore[no-redef]
+    from pydantic.datetime_parse import parse_datetime as parse_datetime  # type: ignore[no-redef]
+    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined, no-redef]
+    from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[no-redef]
+    from pydantic.typing import get_args as get_args  # type: ignore[no-redef]
+    from pydantic.typing import get_origin as get_origin  # type: ignore[no-redef]
+    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore[no-redef]
+    from pydantic.typing import is_union as is_union  # type: ignore[no-redef]
+
+from .datetime_utils import serialize_datetime
+from .serialization import convert_and_respect_annotation_metadata
+from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+Model = TypeVar("Model", bound=pydantic.BaseModel)
+
+
+def parse_obj_as(type_: Type[T], object_: Any) -> T:
+    dealiased_object = convert_and_respect_annotation_metadata(object_=object_, annotation=type_, direction="read")
+    if IS_PYDANTIC_V2:
+        adapter = pydantic.TypeAdapter(type_)  # type: ignore[attr-defined]
+        return adapter.validate_python(dealiased_object)
+    return pydantic.parse_obj_as(type_, dealiased_object)
+
+
+def to_jsonable_with_fallback(obj: Any, fallback_serializer: Callable[[Any], Any]) -> Any:
+    if IS_PYDANTIC_V2:
+        from pydantic_core import to_jsonable_python
+
+        return to_jsonable_python(obj, fallback=fallback_serializer)
+    return fallback_serializer(obj)
+
+
+class UniversalBaseModel(pydantic.BaseModel):
+    if IS_PYDANTIC_V2:
+        model_config: ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(  # type: ignore[typeddict-unknown-key]
+            # Allow fields beginning with `model_` to be used in the model
+            protected_namespaces=(),
+        )
+
+        @pydantic.model_serializer(mode="plain", when_used="json")  # type: ignore[attr-defined]
+        def serialize_model(self) -> Any:  # type: ignore[name-defined]
+            serialized = self.dict()  # type: ignore[attr-defined]
+            data = {k: serialize_datetime(v) if isinstance(v, dt.datetime) else v for k, v in serialized.items()}
+            return data
+
+    else:
+
+        class Config:
+            smart_union = True
+            json_encoders = {dt.datetime: serialize_datetime}
+
+    @classmethod
+    def model_construct(cls: Type["Model"], _fields_set: Optional[Set[str]] = None, **values: Any) -> "Model":
+        dealiased_object = convert_and_respect_annotation_metadata(object_=values, annotation=cls, direction="read")
+        return cls.construct(_fields_set, **dealiased_object)
+
+    @classmethod
+    def construct(cls: Type["Model"], _fields_set: Optional[Set[str]] = None, **values: Any) -> "Model":
+        dealiased_object = convert_and_respect_annotation_metadata(object_=values, annotation=cls, direction="read")
+        if IS_PYDANTIC_V2:
+            return super().model_construct(_fields_set, **dealiased_object)  # type: ignore[misc]
+        return super().construct(_fields_set, **dealiased_object)
+
+    def json(self, **kwargs: Any) -> str:
+        kwargs_with_defaults = {
+            "by_alias": True,
+            "exclude_unset": True,
+            **kwargs,
+        }
+        if IS_PYDANTIC_V2:
+            return super().model_dump_json(**kwargs_with_defaults)  # type: ignore[misc]
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Override the default dict method to `exclude_unset` by default. This function patches
+        `exclude_unset` to work include fields within non-None default values.
+        """
+        # Note: the logic here is multiplexed given the levers exposed in Pydantic V1 vs V2
+        # Pydantic V1's .dict can be extremely slow, so we do not want to call it twice.
+        #
+        # We'd ideally do the same for Pydantic V2, but it shells out to a library to serialize models
+        # that we have less control over, and this is less intrusive than custom serializers for now.
+        if IS_PYDANTIC_V2:
+            kwargs_with_defaults_exclude_unset = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_unset": True,
+                "exclude_none": False,
+            }
+            kwargs_with_defaults_exclude_none = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_none": True,
+                "exclude_unset": False,
+            }
+            dict_dump = deep_union_pydantic_dicts(
+                super().model_dump(**kwargs_with_defaults_exclude_unset),  # type: ignore[misc]
+                super().model_dump(**kwargs_with_defaults_exclude_none),  # type: ignore[misc]
+            )
+
+        else:
+            _fields_set = self.__fields_set__.copy()
+
+            fields = _get_model_fields(self.__class__)
+            for name, field in fields.items():
+                if name not in _fields_set:
+                    default = _get_field_default(field)
+
+                    # If the default values are non-null act like they've been set
+                    # This effectively allows exclude_unset to work like exclude_none where
+                    # the latter passes through intentionally set none values.
+                    if default is not None or ("exclude_unset" in kwargs and not kwargs["exclude_unset"]):
+                        _fields_set.add(name)
+
+                        if default is not None:
+                            self.__fields_set__.add(name)
+
+            kwargs_with_defaults_exclude_unset_include_fields = {
+                "by_alias": True,
+                "exclude_unset": True,
+                "include": _fields_set,
+                **kwargs,
+            }
+
+            dict_dump = super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
+
+        return cast(
+            Dict[str, Any],
+            convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write"),
+        )
+
+
+def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]:
+    converted_list: List[Any] = []
+    for i, item in enumerate(source):
+        destination_value = destination[i]
+        if isinstance(item, dict):
+            converted_list.append(deep_union_pydantic_dicts(item, destination_value))
+        elif isinstance(item, list):
+            converted_list.append(_union_list_of_pydantic_dicts(item, destination_value))
+        else:
+            converted_list.append(item)
+    return converted_list
+
+
+def deep_union_pydantic_dicts(source: Dict[str, Any], destination: Dict[str, Any]) -> Dict[str, Any]:
+    for key, value in source.items():
+        node = destination.setdefault(key, {})
+        if isinstance(value, dict):
+            deep_union_pydantic_dicts(value, node)
+        # Note: we do not do this same processing for sets given we do not have sets of models
+        # and given the sets are unordered, the processing of the set and matching objects would
+        # be non-trivial.
+        elif isinstance(value, list):
+            destination[key] = _union_list_of_pydantic_dicts(value, node)
+        else:
+            destination[key] = value
+
+    return destination
+
+
+if IS_PYDANTIC_V2:
+
+    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore[misc, name-defined, type-arg]
+        pass
+
+    UniversalRootModel: TypeAlias = V2RootModel  # type: ignore[misc]
+else:
+    UniversalRootModel: TypeAlias = UniversalBaseModel  # type: ignore[misc, no-redef]
+
+
+def encode_by_type(o: Any) -> Any:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
+    for type_, encoder in encoders_by_type.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+
+    if type(o) in encoders_by_type:
+        return encoders_by_type[type(o)](o)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(o, classes_tuple):
+            return encoder(o)
+
+
+def update_forward_refs(model: Type["Model"], **localns: Any) -> None:
+    if IS_PYDANTIC_V2:
+        model.model_rebuild(raise_errors=False)  # type: ignore[attr-defined]
+    else:
+        model.update_forward_refs(**localns)
+
+
+# Mirrors Pydantic's internal typing
+AnyCallable = Callable[..., Any]
+
+
+def universal_root_validator(
+    pre: bool = False,
+) -> Callable[[AnyCallable], AnyCallable]:
+    def decorator(func: AnyCallable) -> AnyCallable:
+        if IS_PYDANTIC_V2:
+            # In Pydantic v2, for RootModel we always use "before" mode
+            # The custom validators transform the input value before the model is created
+            return cast(AnyCallable, pydantic.model_validator(mode="before")(func))  # type: ignore[attr-defined]
+        return cast(AnyCallable, pydantic.root_validator(pre=pre)(func))  # type: ignore[call-overload]
+
+    return decorator
+
+
+def universal_field_validator(field_name: str, pre: bool = False) -> Callable[[AnyCallable], AnyCallable]:
+    def decorator(func: AnyCallable) -> AnyCallable:
+        if IS_PYDANTIC_V2:
+            return cast(AnyCallable, pydantic.field_validator(field_name, mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
+        return cast(AnyCallable, pydantic.validator(field_name, pre=pre)(func))
+
+    return decorator
+
+
+PydanticField = Union[ModelField, pydantic.fields.FieldInfo]
+
+
+def _get_model_fields(model: Type["Model"]) -> Mapping[str, PydanticField]:
+    if IS_PYDANTIC_V2:
+        return cast(Mapping[str, PydanticField], model.model_fields)  # type: ignore[attr-defined]
+    return cast(Mapping[str, PydanticField], model.__fields__)
+
+
+def _get_field_default(field: PydanticField) -> Any:
+    try:
+        value = field.get_default()  # type: ignore[union-attr]
+    except:
+        value = field.default
+    if IS_PYDANTIC_V2:
+        from pydantic_core import PydanticUndefined
+
+        if value == PydanticUndefined:
+            return None
+        return value
+    return value