egain-api-python 0.1.1__py3-none-any.whl

egain_api_python/utils/__init__.py

@@ -0,0 +1,200 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import TYPE_CHECKING
+from importlib import import_module
+import builtins
+import sys
+
+if TYPE_CHECKING:
+    from .annotations import get_discriminator
+    from .datetimes import parse_datetime
+    from .enums import OpenEnumMeta
+    from .headers import get_headers, get_response_headers
+    from .metadata import (
+        FieldMetadata,
+        find_metadata,
+        FormMetadata,
+        HeaderMetadata,
+        MultipartFormMetadata,
+        PathParamMetadata,
+        QueryParamMetadata,
+        RequestMetadata,
+        SecurityMetadata,
+    )
+    from .queryparams import get_query_params
+    from .retries import BackoffStrategy, Retries, retry, retry_async, RetryConfig
+    from .requestbodies import serialize_request_body, SerializedRequestBody
+    from .security import get_security, get_security_from_env
+
+    from .serializers import (
+        get_pydantic_model,
+        marshal_json,
+        unmarshal,
+        unmarshal_json,
+        serialize_decimal,
+        serialize_float,
+        serialize_int,
+        stream_to_text,
+        stream_to_text_async,
+        stream_to_bytes,
+        stream_to_bytes_async,
+        validate_const,
+        validate_decimal,
+        validate_float,
+        validate_int,
+        validate_open_enum,
+    )
+    from .url import generate_url, template_url, remove_suffix
+    from .values import (
+        get_global_from_env,
+        match_content_type,
+        match_status_codes,
+        match_response,
+        cast_partial,
+    )
+    from .logger import Logger, get_body_content, get_default_logger
+
+__all__ = [
+    "BackoffStrategy",
+    "FieldMetadata",
+    "find_metadata",
+    "FormMetadata",
+    "generate_url",
+    "get_body_content",
+    "get_default_logger",
+    "get_discriminator",
+    "parse_datetime",
+    "get_global_from_env",
+    "get_headers",
+    "get_pydantic_model",
+    "get_query_params",
+    "get_response_headers",
+    "get_security",
+    "get_security_from_env",
+    "HeaderMetadata",
+    "Logger",
+    "marshal_json",
+    "match_content_type",
+    "match_status_codes",
+    "match_response",
+    "MultipartFormMetadata",
+    "OpenEnumMeta",
+    "PathParamMetadata",
+    "QueryParamMetadata",
+    "remove_suffix",
+    "Retries",
+    "retry",
+    "retry_async",
+    "RetryConfig",
+    "RequestMetadata",
+    "SecurityMetadata",
+    "serialize_decimal",
+    "serialize_float",
+    "serialize_int",
+    "serialize_request_body",
+    "SerializedRequestBody",
+    "stream_to_text",
+    "stream_to_text_async",
+    "stream_to_bytes",
+    "stream_to_bytes_async",
+    "template_url",
+    "unmarshal",
+    "unmarshal_json",
+    "validate_decimal",
+    "validate_const",
+    "validate_float",
+    "validate_int",
+    "validate_open_enum",
+    "cast_partial",
+]
+
+_dynamic_imports: dict[str, str] = {
+    "BackoffStrategy": ".retries",
+    "FieldMetadata": ".metadata",
+    "find_metadata": ".metadata",
+    "FormMetadata": ".metadata",
+    "generate_url": ".url",
+    "get_body_content": ".logger",
+    "get_default_logger": ".logger",
+    "get_discriminator": ".annotations",
+    "parse_datetime": ".datetimes",
+    "get_global_from_env": ".values",
+    "get_headers": ".headers",
+    "get_pydantic_model": ".serializers",
+    "get_query_params": ".queryparams",
+    "get_response_headers": ".headers",
+    "get_security": ".security",
+    "get_security_from_env": ".security",
+    "HeaderMetadata": ".metadata",
+    "Logger": ".logger",
+    "marshal_json": ".serializers",
+    "match_content_type": ".values",
+    "match_status_codes": ".values",
+    "match_response": ".values",
+    "MultipartFormMetadata": ".metadata",
+    "OpenEnumMeta": ".enums",
+    "PathParamMetadata": ".metadata",
+    "QueryParamMetadata": ".metadata",
+    "remove_suffix": ".url",
+    "Retries": ".retries",
+    "retry": ".retries",
+    "retry_async": ".retries",
+    "RetryConfig": ".retries",
+    "RequestMetadata": ".metadata",
+    "SecurityMetadata": ".metadata",
+    "serialize_decimal": ".serializers",
+    "serialize_float": ".serializers",
+    "serialize_int": ".serializers",
+    "serialize_request_body": ".requestbodies",
+    "SerializedRequestBody": ".requestbodies",
+    "stream_to_text": ".serializers",
+    "stream_to_text_async": ".serializers",
+    "stream_to_bytes": ".serializers",
+    "stream_to_bytes_async": ".serializers",
+    "template_url": ".url",
+    "unmarshal": ".serializers",
+    "unmarshal_json": ".serializers",
+    "validate_decimal": ".serializers",
+    "validate_const": ".serializers",
+    "validate_float": ".serializers",
+    "validate_int": ".serializers",
+    "validate_open_enum": ".serializers",
+    "cast_partial": ".values",
+}
+
+
+def dynamic_import(modname, retries=3):
+    for attempt in range(retries):
+        try:
+            return import_module(modname, __package__)
+        except KeyError:
+            # Clear any half-initialized module and retry
+            sys.modules.pop(modname, None)
+            if attempt == retries - 1:
+                break
+    raise KeyError(f"Failed to import module '{modname}' after {retries} attempts")
+
+
+def __getattr__(attr_name: str) -> object:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(
+            f"no {attr_name} found in _dynamic_imports, module name -> {__name__} "
+        )
+
+    try:
+        module = dynamic_import(module_name)
+        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 = builtins.list(_dynamic_imports.keys())
+    return builtins.sorted(lazy_attrs)

egain_api_python/utils/annotations.py

@@ -0,0 +1,79 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from enum import Enum
+from typing import Any, Optional
+
+
+def get_discriminator(model: Any, fieldname: str, key: str) -> str:
+    """
+    Recursively search for the discriminator attribute in a model.
+
+    Args:
+        model (Any): The model to search within.
+        fieldname (str): The name of the field to search for.
+        key (str): The key to search for in dictionaries.
+
+    Returns:
+        str: The name of the discriminator attribute.
+
+    Raises:
+        ValueError: If the discriminator attribute is not found.
+    """
+    upper_fieldname = fieldname.upper()
+
+    def get_field_discriminator(field: Any) -> Optional[str]:
+        """Search for the discriminator attribute in a given field."""
+
+        if isinstance(field, dict):
+            if key in field:
+                return f"{field[key]}"
+
+        if hasattr(field, fieldname):
+            attr = getattr(field, fieldname)
+            if isinstance(attr, Enum):
+                return f"{attr.value}"
+            return f"{attr}"
+
+        if hasattr(field, upper_fieldname):
+            attr = getattr(field, upper_fieldname)
+            if isinstance(attr, Enum):
+                return f"{attr.value}"
+            return f"{attr}"
+
+        return None
+
+    def search_nested_discriminator(obj: Any) -> Optional[str]:
+        """Recursively search for discriminator in nested structures."""
+        # First try direct field lookup
+        discriminator = get_field_discriminator(obj)
+        if discriminator is not None:
+            return discriminator
+
+        # If it's a dict, search in nested values
+        if isinstance(obj, dict):
+            for value in obj.values():
+                if isinstance(value, list):
+                    # Search in list items
+                    for item in value:
+                        nested_discriminator = search_nested_discriminator(item)
+                        if nested_discriminator is not None:
+                            return nested_discriminator
+                elif isinstance(value, dict):
+                    # Search in nested dict
+                    nested_discriminator = search_nested_discriminator(value)
+                    if nested_discriminator is not None:
+                        return nested_discriminator
+
+        return None
+
+    if isinstance(model, list):
+        for field in model:
+            discriminator = search_nested_discriminator(field)
+            if discriminator is not None:
+                return discriminator
+
+    discriminator = search_nested_discriminator(model)
+    if discriminator is not None:
+        return discriminator
+
+    raise ValueError(f"Could not find discriminator field {fieldname} in {model}")

egain_api_python/utils/datetimes.py

@@ -0,0 +1,23 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from datetime import datetime
+import sys
+
+
+def parse_datetime(datetime_string: str) -> datetime:
+    """
+    Convert a RFC 3339 / ISO 8601 formatted string into a datetime object.
+    Python versions 3.11 and later support parsing RFC 3339 directly with
+    datetime.fromisoformat(), but for earlier versions, this function
+    encapsulates the necessary extra logic.
+    """
+    # Python 3.11 and later can parse RFC 3339 directly
+    if sys.version_info >= (3, 11):
+        return datetime.fromisoformat(datetime_string)
+    
+    # For Python 3.10 and earlier, a common ValueError is trailing 'Z' suffix,
+    # so fix that upfront.
+    if datetime_string.endswith("Z"):
+        datetime_string = datetime_string[:-1] + "+00:00"
+
+    return datetime.fromisoformat(datetime_string)

egain_api_python/utils/enums.py

@@ -0,0 +1,74 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import enum
+import sys
+
+class OpenEnumMeta(enum.EnumMeta):
+    # The __call__ method `boundary` kwarg was added in 3.11 and must be present
+    # for pyright. Refer also: https://github.com/pylint-dev/pylint/issues/9622
+    # pylint: disable=unexpected-keyword-arg
+    # The __call__ method `values` varg must be named for pyright.
+    # pylint: disable=keyword-arg-before-vararg
+
+    if sys.version_info >= (3, 11):
+        def __call__(
+            cls, value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None
+        ):
+            # The `type` kwarg also happens to be a built-in that pylint flags as
+            # redeclared. Safe to ignore this lint rule with this scope.
+            # pylint: disable=redefined-builtin
+
+            if names is not None:
+                return super().__call__(
+                    value,
+                    names=names,
+                    *values,
+                    module=module,
+                    qualname=qualname,
+                    type=type,
+                    start=start,
+                    boundary=boundary,
+                )
+
+            try:
+                return super().__call__(
+                    value,
+                    names=names,  # pyright: ignore[reportArgumentType]
+                    *values,
+                    module=module,
+                    qualname=qualname,
+                    type=type,
+                    start=start,
+                    boundary=boundary,
+                )
+            except ValueError:
+                return value
+    else:
+        def __call__(
+            cls, value, names=None, *, module=None, qualname=None, type=None, start=1
+        ):
+            # The `type` kwarg also happens to be a built-in that pylint flags as
+            # redeclared. Safe to ignore this lint rule with this scope.
+            # pylint: disable=redefined-builtin
+
+            if names is not None:
+                return super().__call__(
+                    value,
+                    names=names,
+                    module=module,
+                    qualname=qualname,
+                    type=type,
+                    start=start,
+                )
+
+            try:
+                return super().__call__(
+                    value,
+                    names=names,  # pyright: ignore[reportArgumentType]
+                    module=module,
+                    qualname=qualname,
+                    type=type,
+                    start=start,
+                )
+            except ValueError:
+                return value

egain_api_python/utils/eventstreaming.py

@@ -0,0 +1,248 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import re
+import json
+from typing import (
+    Callable,
+    Generic,
+    TypeVar,
+    Optional,
+    Generator,
+    AsyncGenerator,
+    Tuple,
+)
+import httpx
+
+T = TypeVar("T")
+
+
+class EventStream(Generic[T]):
+    # Holds a reference to the SDK client to avoid it being garbage collected
+    # and cause termination of the underlying httpx client.
+    client_ref: Optional[object]
+    response: httpx.Response
+    generator: Generator[T, None, None]
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+        client_ref: Optional[object] = None,
+    ):
+        self.response = response
+        self.generator = stream_events(response, decoder, sentinel)
+        self.client_ref = client_ref
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self.generator)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.response.close()
+
+
+class EventStreamAsync(Generic[T]):
+    # Holds a reference to the SDK client to avoid it being garbage collected
+    # and cause termination of the underlying httpx client.
+    client_ref: Optional[object]
+    response: httpx.Response
+    generator: AsyncGenerator[T, None]
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+        client_ref: Optional[object] = None,
+    ):
+        self.response = response
+        self.generator = stream_events_async(response, decoder, sentinel)
+        self.client_ref = client_ref
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        return await self.generator.__anext__()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.response.aclose()
+
+
+class ServerEvent:
+    id: Optional[str] = None
+    event: Optional[str] = None
+    data: Optional[str] = None
+    retry: Optional[int] = None
+
+
+MESSAGE_BOUNDARIES = [
+    b"\r\n\r\n",
+    b"\n\n",
+    b"\r\r",
+]
+
+
+async def stream_events_async(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+) -> AsyncGenerator[T, None]:
+    buffer = bytearray()
+    position = 0
+    discard = False
+    async for chunk in response.aiter_bytes():
+        # We've encountered the sentinel value and should no longer process
+        # incoming data. Instead we throw new data away until the server closes
+        # the connection.
+        if discard:
+            continue
+
+        buffer += chunk
+        for i in range(position, len(buffer)):
+            char = buffer[i : i + 1]
+            seq: Optional[bytes] = None
+            if char in [b"\r", b"\n"]:
+                for boundary in MESSAGE_BOUNDARIES:
+                    seq = _peek_sequence(i, buffer, boundary)
+                    if seq is not None:
+                        break
+            if seq is None:
+                continue
+
+            block = buffer[position:i]
+            position = i + len(seq)
+            event, discard = _parse_event(block, decoder, sentinel)
+            if event is not None:
+                yield event
+
+        if position > 0:
+            buffer = buffer[position:]
+            position = 0
+
+    event, discard = _parse_event(buffer, decoder, sentinel)
+    if event is not None:
+        yield event
+
+
+def stream_events(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+) -> Generator[T, None, None]:
+    buffer = bytearray()
+    position = 0
+    discard = False
+    for chunk in response.iter_bytes():
+        # We've encountered the sentinel value and should no longer process
+        # incoming data. Instead we throw new data away until the server closes
+        # the connection.
+        if discard:
+            continue
+
+        buffer += chunk
+        for i in range(position, len(buffer)):
+            char = buffer[i : i + 1]
+            seq: Optional[bytes] = None
+            if char in [b"\r", b"\n"]:
+                for boundary in MESSAGE_BOUNDARIES:
+                    seq = _peek_sequence(i, buffer, boundary)
+                    if seq is not None:
+                        break
+            if seq is None:
+                continue
+
+            block = buffer[position:i]
+            position = i + len(seq)
+            event, discard = _parse_event(block, decoder, sentinel)
+            if event is not None:
+                yield event
+
+        if position > 0:
+            buffer = buffer[position:]
+            position = 0
+
+    event, discard = _parse_event(buffer, decoder, sentinel)
+    if event is not None:
+        yield event
+
+
+def _parse_event(
+    raw: bytearray, decoder: Callable[[str], T], sentinel: Optional[str] = None
+) -> Tuple[Optional[T], bool]:
+    block = raw.decode()
+    lines = re.split(r"\r?\n|\r", block)
+    publish = False
+    event = ServerEvent()
+    data = ""
+    for line in lines:
+        if not line:
+            continue
+
+        delim = line.find(":")
+        if delim <= 0:
+            continue
+
+        field = line[0:delim]
+        value = line[delim + 1 :] if delim < len(line) - 1 else ""
+        if len(value) and value[0] == " ":
+            value = value[1:]
+
+        if field == "event":
+            event.event = value
+            publish = True
+        elif field == "data":
+            data += value + "\n"
+            publish = True
+        elif field == "id":
+            event.id = value
+            publish = True
+        elif field == "retry":
+            event.retry = int(value) if value.isdigit() else None
+            publish = True
+
+    if sentinel and data == f"{sentinel}\n":
+        return None, True
+
+    if data:
+        data = data[:-1]
+        event.data = data
+
+        data_is_primitive = (
+            data.isnumeric() or data == "true" or data == "false" or data == "null"
+        )
+        data_is_json = (
+            data.startswith("{") or data.startswith("[") or data.startswith('"')
+        )
+
+        if data_is_primitive or data_is_json:
+            try:
+                event.data = json.loads(data)
+            except Exception:
+                pass
+
+    out = None
+    if publish:
+        out = decoder(json.dumps(event.__dict__))
+
+    return out, False
+
+
+def _peek_sequence(position: int, buffer: bytearray, sequence: bytes):
+    if len(sequence) > (len(buffer) - position):
+        return None
+
+    for i, seq in enumerate(sequence):
+        if buffer[position + i] != seq:
+            return None
+
+    return sequence