antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/inference_config.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.inference_config_model_strategies import InferenceConfigModelStrategies
+    from ..models.inference_content_security_config import InferenceContentSecurityConfig
+    from ..models.inference_credentials import InferenceCredentials
+    from ..models.inferenceschemas_config import InferenceschemasConfig
+
+
+T = TypeVar("T", bound="InferenceConfig")
+
+
+@_attrs_define
+class InferenceConfig:
+    """
+    Attributes:
+        api_url (str): URL of the inference embedding/chunking service Example: http://localhost:8080.
+        api_key (str | Unset): API key used when calling an authenticated shared Antfly inference API.
+        models_dir (str | Unset): Base directory containing model subdirectories. Antfly inference auto-discovers models
+            from:
+            - `{models_dir}/embedders/` - Embedding models (ONNX)
+            - `{models_dir}/chunkers/` - Chunking models (ONNX)
+            - `{models_dir}/rerankers/` - Reranking models (ONNX)
+            - `{models_dir}/recognizers/` - Recognition models (ONNX)
+            - `{models_dir}/rewriters/` - Seq2Seq rewriter models (ONNX)
+
+            Defaults to ~/.antfly/inference/models (set via viper). If not set, only built-in fixed chunking is available.
+             Example: ~/.antfly/inference/models.
+        content_security (InferenceContentSecurityConfig | Unset):
+        s3_credentials (InferenceCredentials | Unset):
+        keep_alive (str | Unset): How long to keep models loaded in memory after last use (Ollama-compatible).
+            Models are automatically unloaded after this duration of inactivity.
+            Use Go duration format: "5m" (5 minutes), "1h" (1 hour), "0" (eager loading).
+            Defaults to "5m" (lazy loading) like Ollama. Set to "0" to explicitly enable eager loading
+            where all models are loaded at startup and never unloaded.
+             Default: '5m'. Example: 5m.
+        max_loaded_models (int | Unset): Maximum total models loaded across all registry types (embedders, rerankers,
+            generators, chunkers, etc.). When the limit is reached, the least-recently-used
+            idle model from any registry is evicted to make room. Set to 0 for unlimited (default).
+             Default: 0. Example: 3.
+        pool_size (int | Unset): Number of concurrent inference pipelines per model. Each pipeline loads
+            a copy of the model, so higher values use more memory but allow more
+            concurrent requests. Note: pool_size multiplies per-model memory
+            independently of max_loaded_models.
+             Default: 1. Example: 1.
+        backend_priority (list[str] | Unset): Backend priority order for model loading with optional device specifiers.
+            Format: `backend` or `backend:device` where device defaults to `auto`.
+
+            Antfly inference tries entries in order and uses the first available backend+device
+            combination that supports the model.
+
+            **Backends** (depend on build flags):
+            - `native` - Native CPU backend
+            - `onnx` - ONNX Runtime backend
+            - `metal` - Apple Metal backend
+            - `mlx` - MLX backend
+            - `cuda` - NVIDIA CUDA backend
+            - `xla` - PJRT/XLA compiled backend
+
+            **Devices**:
+            - `auto` - Auto-detect best available (default)
+            - `cuda` - NVIDIA CUDA GPU
+            - `tpu` - Google TPU (used by XLA)
+            - `cpu` - Force CPU only
+
+            **Examples**:
+            - `["native", "onnx", "xla"]` - Try backends with auto device detection
+            - `["cuda", "onnx:cuda", "xla:tpu", "native"]` - Prefer GPU, fall back to CPU
+             Example: ['cuda', 'onnx:cuda', 'xla:tpu', 'native'].
+        max_concurrent_requests (int | Unset): Maximum number of concurrent inference requests allowed.
+            Additional requests will be queued up to max_queue_size.
+            Set to 0 for unlimited (default).
+             Default: 0. Example: 4.
+        max_queue_size (int | Unset): Maximum number of requests to queue when max_concurrent_requests is reached.
+            When the queue is full, new requests receive 503 Service Unavailable with Retry-After header.
+            Set to 0 for unlimited queue (default). Only effective when max_concurrent_requests > 0.
+             Default: 0. Example: 100.
+        request_timeout (str | Unset): Maximum time to wait for a request to complete, including queue wait time.
+            Use Go duration format: "30s", "1m", "0" (no timeout, default).
+            Requests exceeding this timeout receive 504 Gateway Timeout.
+             Default: '0'. Example: 30s.
+        preload (list[str] | Unset): List of model names to preload at startup (Ollama-compatible).
+            These models are loaded immediately when inference starts, avoiding first-request latency.
+            Model names should match those in models_dir/embedders/ (e.g., "BAAI/bge-small-en-v1.5").
+            Only effective when keep_alive is non-zero (lazy loading mode).
+             Example: ['BAAI/bge-small-en-v1.5', 'openai/clip-vit-base-patch32'].
+        max_memory_mb (int | Unset): Maximum memory (in MB) to use for loaded models.
+            When this limit is approached, least recently used models are unloaded.
+            Set to 0 for unlimited (default). This is an advisory limit - actual memory
+            usage depends on model sizes and may temporarily exceed this value.
+            Works alongside max_loaded_models for fine-grained control.
+             Default: 0. Example: 4096.
+        model_strategies (InferenceConfigModelStrategies | Unset): Per-model loading strategy overrides. Maps model
+            names to their loading strategy.
+            Models not in this map use the default strategy based on keep_alive:
+            - If keep_alive>0 (default "5m"): lazy loading (load on demand, unload after idle)
+            - If keep_alive="0": eager loading (load at startup, never unload)
+
+            When a model has strategy "eager" in this map:
+            - It is loaded at startup (as part of preload)
+            - It is never unloaded, even when keep_alive>0 (pinned in memory)
+
+            This allows mixing eager and lazy models in the same pool.
+             Example: {'BAAI/bge-small-en-v1.5': 'eager', 'mirth/chonky-mmbert-small-multilingual-1': 'lazy'}.
+        allow_downloads (bool | Unset): Whether the dashboard should show model download commands.
+            Defaults to true for standalone/swarm mode. Set to false in managed
+            deployments (e.g., Kubernetes operator) where models are managed externally.
+             Default: True.
+        log (InferenceschemasConfig | Unset): Logging configuration for inference services
+    """
+
+    api_url: str
+    api_key: str | Unset = UNSET
+    models_dir: str | Unset = UNSET
+    content_security: InferenceContentSecurityConfig | Unset = UNSET
+    s3_credentials: InferenceCredentials | Unset = UNSET
+    keep_alive: str | Unset = "5m"
+    max_loaded_models: int | Unset = 0
+    pool_size: int | Unset = 1
+    backend_priority: list[str] | Unset = UNSET
+    max_concurrent_requests: int | Unset = 0
+    max_queue_size: int | Unset = 0
+    request_timeout: str | Unset = "0"
+    preload: list[str] | Unset = UNSET
+    max_memory_mb: int | Unset = 0
+    model_strategies: InferenceConfigModelStrategies | Unset = UNSET
+    allow_downloads: bool | Unset = True
+    log: InferenceschemasConfig | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        api_url = self.api_url
+
+        api_key = self.api_key
+
+        models_dir = self.models_dir
+
+        content_security: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.content_security, Unset):
+            content_security = self.content_security.to_dict()
+
+        s3_credentials: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.s3_credentials, Unset):
+            s3_credentials = self.s3_credentials.to_dict()
+
+        keep_alive = self.keep_alive
+
+        max_loaded_models = self.max_loaded_models
+
+        pool_size = self.pool_size
+
+        backend_priority: list[str] | Unset = UNSET
+        if not isinstance(self.backend_priority, Unset):
+            backend_priority = self.backend_priority
+
+        max_concurrent_requests = self.max_concurrent_requests
+
+        max_queue_size = self.max_queue_size
+
+        request_timeout = self.request_timeout
+
+        preload: list[str] | Unset = UNSET
+        if not isinstance(self.preload, Unset):
+            preload = self.preload
+
+        max_memory_mb = self.max_memory_mb
+
+        model_strategies: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.model_strategies, Unset):
+            model_strategies = self.model_strategies.to_dict()
+
+        allow_downloads = self.allow_downloads
+
+        log: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.log, Unset):
+            log = self.log.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "api_url": api_url,
+            }
+        )
+        if api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if models_dir is not UNSET:
+            field_dict["models_dir"] = models_dir
+        if content_security is not UNSET:
+            field_dict["content_security"] = content_security
+        if s3_credentials is not UNSET:
+            field_dict["s3_credentials"] = s3_credentials
+        if keep_alive is not UNSET:
+            field_dict["keep_alive"] = keep_alive
+        if max_loaded_models is not UNSET:
+            field_dict["max_loaded_models"] = max_loaded_models
+        if pool_size is not UNSET:
+            field_dict["pool_size"] = pool_size
+        if backend_priority is not UNSET:
+            field_dict["backend_priority"] = backend_priority
+        if max_concurrent_requests is not UNSET:
+            field_dict["max_concurrent_requests"] = max_concurrent_requests
+        if max_queue_size is not UNSET:
+            field_dict["max_queue_size"] = max_queue_size
+        if request_timeout is not UNSET:
+            field_dict["request_timeout"] = request_timeout
+        if preload is not UNSET:
+            field_dict["preload"] = preload
+        if max_memory_mb is not UNSET:
+            field_dict["max_memory_mb"] = max_memory_mb
+        if model_strategies is not UNSET:
+            field_dict["model_strategies"] = model_strategies
+        if allow_downloads is not UNSET:
+            field_dict["allow_downloads"] = allow_downloads
+        if log is not UNSET:
+            field_dict["log"] = log
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_config_model_strategies import InferenceConfigModelStrategies
+        from ..models.inference_content_security_config import InferenceContentSecurityConfig
+        from ..models.inference_credentials import InferenceCredentials
+        from ..models.inferenceschemas_config import InferenceschemasConfig
+
+        d = dict(src_dict)
+        api_url = d.pop("api_url")
+
+        api_key = d.pop("api_key", UNSET)
+
+        models_dir = d.pop("models_dir", UNSET)
+
+        _content_security = d.pop("content_security", UNSET)
+        content_security: InferenceContentSecurityConfig | Unset
+        if isinstance(_content_security, Unset):
+            content_security = UNSET
+        else:
+            content_security = InferenceContentSecurityConfig.from_dict(_content_security)
+
+        _s3_credentials = d.pop("s3_credentials", UNSET)
+        s3_credentials: InferenceCredentials | Unset
+        if isinstance(_s3_credentials, Unset):
+            s3_credentials = UNSET
+        else:
+            s3_credentials = InferenceCredentials.from_dict(_s3_credentials)
+
+        keep_alive = d.pop("keep_alive", UNSET)
+
+        max_loaded_models = d.pop("max_loaded_models", UNSET)
+
+        pool_size = d.pop("pool_size", UNSET)
+
+        backend_priority = cast(list[str], d.pop("backend_priority", UNSET))
+
+        max_concurrent_requests = d.pop("max_concurrent_requests", UNSET)
+
+        max_queue_size = d.pop("max_queue_size", UNSET)
+
+        request_timeout = d.pop("request_timeout", UNSET)
+
+        preload = cast(list[str], d.pop("preload", UNSET))
+
+        max_memory_mb = d.pop("max_memory_mb", UNSET)
+
+        _model_strategies = d.pop("model_strategies", UNSET)
+        model_strategies: InferenceConfigModelStrategies | Unset
+        if isinstance(_model_strategies, Unset):
+            model_strategies = UNSET
+        else:
+            model_strategies = InferenceConfigModelStrategies.from_dict(_model_strategies)
+
+        allow_downloads = d.pop("allow_downloads", UNSET)
+
+        _log = d.pop("log", UNSET)
+        log: InferenceschemasConfig | Unset
+        if isinstance(_log, Unset):
+            log = UNSET
+        else:
+            log = InferenceschemasConfig.from_dict(_log)
+
+        inference_config = cls(
+            api_url=api_url,
+            api_key=api_key,
+            models_dir=models_dir,
+            content_security=content_security,
+            s3_credentials=s3_credentials,
+            keep_alive=keep_alive,
+            max_loaded_models=max_loaded_models,
+            pool_size=pool_size,
+            backend_priority=backend_priority,
+            max_concurrent_requests=max_concurrent_requests,
+            max_queue_size=max_queue_size,
+            request_timeout=request_timeout,
+            preload=preload,
+            max_memory_mb=max_memory_mb,
+            model_strategies=model_strategies,
+            allow_downloads=allow_downloads,
+            log=log,
+        )
+
+        inference_config.additional_properties = d
+        return inference_config
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/inference_config_model_strategies.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.inference_config_model_strategies_additional_property import (
+    InferenceConfigModelStrategiesAdditionalProperty,
+)
+
+T = TypeVar("T", bound="InferenceConfigModelStrategies")
+
+
+@_attrs_define
+class InferenceConfigModelStrategies:
+    """Per-model loading strategy overrides. Maps model names to their loading strategy.
+    Models not in this map use the default strategy based on keep_alive:
+    - If keep_alive>0 (default "5m"): lazy loading (load on demand, unload after idle)
+    - If keep_alive="0": eager loading (load at startup, never unload)
+
+    When a model has strategy "eager" in this map:
+    - It is loaded at startup (as part of preload)
+    - It is never unloaded, even when keep_alive>0 (pinned in memory)
+
+    This allows mixing eager and lazy models in the same pool.
+
+        Example:
+            {'BAAI/bge-small-en-v1.5': 'eager', 'mirth/chonky-mmbert-small-multilingual-1': 'lazy'}
+
+    """
+
+    additional_properties: dict[str, InferenceConfigModelStrategiesAdditionalProperty] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.value
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        inference_config_model_strategies = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = InferenceConfigModelStrategiesAdditionalProperty(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        inference_config_model_strategies.additional_properties = additional_properties
+        return inference_config_model_strategies
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> InferenceConfigModelStrategiesAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: InferenceConfigModelStrategiesAdditionalProperty) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/inference_config_model_strategies_additional_property.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class InferenceConfigModelStrategiesAdditionalProperty(str, Enum):
+    BOUNDED = "bounded"
+    EAGER = "eager"
+    LAZY = "lazy"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/inference_content_security_config.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InferenceContentSecurityConfig")
+
+
+@_attrs_define
+class InferenceContentSecurityConfig:
+    """
+    Attributes:
+        allowed_hosts (list[str] | Unset): Whitelist of allowed hostnames/IPs for link downloads. If empty, all hosts
+            are allowed (except private IPs if block_private_ips is true). Example: ['example.com', 'cdn.example.com',
+            '192.0.2.1'].
+        block_private_ips (bool | Unset): Block requests to private IP ranges (127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12,
+            192.168.0.0/16, 169.254.0.0/16) Default: True.
+        max_download_size_bytes (int | Unset): Maximum size of downloaded content in bytes Default: 104857600. Example:
+            104857600.
+        download_timeout_seconds (int | Unset): Timeout for individual download operations in seconds Default: 30.
+            Example: 30.
+        max_image_dimension (int | Unset): Maximum image width/height in pixels (images will be resized) Default: 2048.
+            Example: 2048.
+        allowed_paths (list[str] | Unset): Whitelist of allowed path prefixes for file:// and s3:// URLs. If empty, all
+            paths are allowed. For file:// use absolute paths (e.g., /Users/data/). For s3:// use bucket/prefix (e.g., my-
+            bucket/uploads/). Example: ['/Users/data/', 'my-bucket/uploads/'].
+        user_agent (str | Unset): User-Agent header for HTTP downloads. Defaults to 'AntflyDB/1.0' if not set. Some
+            servers (e.g., Wikipedia) reject requests without a User-Agent. Example: AntflyDB/1.0.
+    """
+
+    allowed_hosts: list[str] | Unset = UNSET
+    block_private_ips: bool | Unset = True
+    max_download_size_bytes: int | Unset = 104857600
+    download_timeout_seconds: int | Unset = 30
+    max_image_dimension: int | Unset = 2048
+    allowed_paths: list[str] | Unset = UNSET
+    user_agent: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        allowed_hosts: list[str] | Unset = UNSET
+        if not isinstance(self.allowed_hosts, Unset):
+            allowed_hosts = self.allowed_hosts
+
+        block_private_ips = self.block_private_ips
+
+        max_download_size_bytes = self.max_download_size_bytes
+
+        download_timeout_seconds = self.download_timeout_seconds
+
+        max_image_dimension = self.max_image_dimension
+
+        allowed_paths: list[str] | Unset = UNSET
+        if not isinstance(self.allowed_paths, Unset):
+            allowed_paths = self.allowed_paths
+
+        user_agent = self.user_agent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if allowed_hosts is not UNSET:
+            field_dict["allowed_hosts"] = allowed_hosts
+        if block_private_ips is not UNSET:
+            field_dict["block_private_ips"] = block_private_ips
+        if max_download_size_bytes is not UNSET:
+            field_dict["max_download_size_bytes"] = max_download_size_bytes
+        if download_timeout_seconds is not UNSET:
+            field_dict["download_timeout_seconds"] = download_timeout_seconds
+        if max_image_dimension is not UNSET:
+            field_dict["max_image_dimension"] = max_image_dimension
+        if allowed_paths is not UNSET:
+            field_dict["allowed_paths"] = allowed_paths
+        if user_agent is not UNSET:
+            field_dict["user_agent"] = user_agent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        allowed_hosts = cast(list[str], d.pop("allowed_hosts", UNSET))
+
+        block_private_ips = d.pop("block_private_ips", UNSET)
+
+        max_download_size_bytes = d.pop("max_download_size_bytes", UNSET)
+
+        download_timeout_seconds = d.pop("download_timeout_seconds", UNSET)
+
+        max_image_dimension = d.pop("max_image_dimension", UNSET)
+
+        allowed_paths = cast(list[str], d.pop("allowed_paths", UNSET))
+
+        user_agent = d.pop("user_agent", UNSET)
+
+        inference_content_security_config = cls(
+            allowed_hosts=allowed_hosts,
+            block_private_ips=block_private_ips,
+            max_download_size_bytes=max_download_size_bytes,
+            download_timeout_seconds=download_timeout_seconds,
+            max_image_dimension=max_image_dimension,
+            allowed_paths=allowed_paths,
+            user_agent=user_agent,
+        )
+
+        inference_content_security_config.additional_properties = d
+        return inference_content_security_config
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/inference_credentials.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InferenceCredentials")
+
+
+@_attrs_define
+class InferenceCredentials:
+    """
+    Attributes:
+        endpoint (str | Unset): S3-compatible endpoint (e.g., 's3.amazonaws.com' or 'localhost:9000' for MinIO) Example:
+            s3.amazonaws.com.
+        use_ssl (bool | Unset): Enable SSL/TLS for S3 connections (default: true for AWS, false for local MinIO)
+            Default: True.
+        access_key_id (str | Unset): AWS access key ID. Supports keystore syntax for secret lookup. Falls back to
+            AWS_ACCESS_KEY_ID environment variable if not set. Example: your-access-key-id.
+        secret_access_key (str | Unset): AWS secret access key. Supports keystore syntax for secret lookup. Falls back
+            to AWS_SECRET_ACCESS_KEY environment variable if not set. Example: your-secret-access-key.
+        session_token (str | Unset): Optional AWS session token for temporary credentials. Supports keystore syntax for
+            secret lookup. Example: your-session-token.
+    """
+
+    endpoint: str | Unset = UNSET
+    use_ssl: bool | Unset = True
+    access_key_id: str | Unset = UNSET
+    secret_access_key: str | Unset = UNSET
+    session_token: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        endpoint = self.endpoint
+
+        use_ssl = self.use_ssl
+
+        access_key_id = self.access_key_id
+
+        secret_access_key = self.secret_access_key
+
+        session_token = self.session_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if endpoint is not UNSET:
+            field_dict["endpoint"] = endpoint
+        if use_ssl is not UNSET:
+            field_dict["use_ssl"] = use_ssl
+        if access_key_id is not UNSET:
+            field_dict["access_key_id"] = access_key_id
+        if secret_access_key is not UNSET:
+            field_dict["secret_access_key"] = secret_access_key
+        if session_token is not UNSET:
+            field_dict["session_token"] = session_token
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        endpoint = d.pop("endpoint", UNSET)
+
+        use_ssl = d.pop("use_ssl", UNSET)
+
+        access_key_id = d.pop("access_key_id", UNSET)
+
+        secret_access_key = d.pop("secret_access_key", UNSET)
+
+        session_token = d.pop("session_token", UNSET)
+
+        inference_credentials = cls(
+            endpoint=endpoint,
+            use_ssl=use_ssl,
+            access_key_id=access_key_id,
+            secret_access_key=secret_access_key,
+            session_token=session_token,
+        )
+
+        inference_credentials.additional_properties = d
+        return inference_credentials
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties