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

antfly/client_generated/models/batch_request_inserts.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.batch_request_inserts_additional_property import BatchRequestInsertsAdditionalProperty
+
+
+T = TypeVar("T", bound="BatchRequestInserts")
+
+
+@_attrs_define
+class BatchRequestInserts:
+    """Map of document IDs to document objects. Each key is the unique identifier for the document.
+
+    Best practices:
+    - Use consistent key naming schemes (e.g., "user:123", "article:456")
+    - Key length affects storage and performance - keep them reasonably short
+    - Keys are sorted lexicographically, so choose prefixes that support range scans
+
+        Example:
+            {'user:123': {'name': 'John Doe', 'email': 'john@example.com', 'age': 30, 'tags': ['customer', 'premium']},
+                'user:456': {'name': 'Jane Smith', 'email': 'jane@example.com', 'age': 25, 'tags': ['customer']}}
+
+    """
+
+    additional_properties: dict[str, BatchRequestInsertsAdditionalProperty] = _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.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.batch_request_inserts_additional_property import BatchRequestInsertsAdditionalProperty
+
+        d = dict(src_dict)
+        batch_request_inserts = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = BatchRequestInsertsAdditionalProperty.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        batch_request_inserts.additional_properties = additional_properties
+        return batch_request_inserts
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> BatchRequestInsertsAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: BatchRequestInsertsAdditionalProperty) -> 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/batch_request_inserts_additional_property.py

@@ -0,0 +1,47 @@
+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
+
+T = TypeVar("T", bound="BatchRequestInsertsAdditionalProperty")
+
+
+@_attrs_define
+class BatchRequestInsertsAdditionalProperty:
+    """Document object with arbitrary fields matching your table schema."""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        batch_request_inserts_additional_property = cls()
+
+        batch_request_inserts_additional_property.additional_properties = d
+        return batch_request_inserts_additional_property
+
+    @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/batch_response.py

@@ -0,0 +1,79 @@
+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="BatchResponse")
+
+
+@_attrs_define
+class BatchResponse:
+    """
+    Attributes:
+        inserted (int | Unset): Number of documents successfully inserted
+        deleted (int | Unset): Number of documents successfully deleted
+        transformed (int | Unset): Number of documents successfully transformed
+    """
+
+    inserted: int | Unset = UNSET
+    deleted: int | Unset = UNSET
+    transformed: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        inserted = self.inserted
+
+        deleted = self.deleted
+
+        transformed = self.transformed
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if inserted is not UNSET:
+            field_dict["inserted"] = inserted
+        if deleted is not UNSET:
+            field_dict["deleted"] = deleted
+        if transformed is not UNSET:
+            field_dict["transformed"] = transformed
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        inserted = d.pop("inserted", UNSET)
+
+        deleted = d.pop("deleted", UNSET)
+
+        transformed = d.pop("transformed", UNSET)
+
+        batch_response = cls(
+            inserted=inserted,
+            deleted=deleted,
+            transformed=transformed,
+        )
+
+        batch_response.additional_properties = d
+        return batch_response
+
+    @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/bedrock_embedder_config.py

@@ -0,0 +1,139 @@
+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="BedrockEmbedderConfig")
+
+
+@_attrs_define
+class BedrockEmbedderConfig:
+    """Configuration for the AWS Bedrock embedding provider.
+
+    Uses the AWS credential chain: environment variables, web identity, shared credentials, ECS task roles, and EC2
+    instance roles.
+
+    **Example Models:** cohere.embed-v4, amazon.titan-embed-text-v2:0
+
+    **Docs:** https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
+
+        Example:
+            {'provider': 'bedrock', 'model': 'cohere.embed-v4', 'region': 'us-east-1'}
+
+        Attributes:
+            model (str): The Bedrock model ID to use (e.g., 'cohere.embed-v4', 'amazon.titan-embed-text-v2:0'). Example:
+                cohere.embed-v4.
+            region (str | Unset): The AWS region for the Bedrock service (e.g., 'us-east-1'). Example: us-east-1.
+            dimension (int | Unset): Output dimension for Bedrock embedding models that support configurable dimensions.
+            dimensions (int | Unset): Alias for output dimension when using OpenAI-compatible configuration fields.
+            input_type (str | Unset): Cohere Bedrock input type, such as search_document, search_query, classification, or
+                clustering.
+            truncate (str | Unset): Cohere Bedrock truncate behavior.
+            strip_new_lines (bool | Unset): Whether to strip new lines from the input text before embedding. Default: False.
+            batch_size (int | Unset): The batch size for embedding requests to optimize throughput. Default: 1.
+    """
+
+    model: str
+    region: str | Unset = UNSET
+    dimension: int | Unset = UNSET
+    dimensions: int | Unset = UNSET
+    input_type: str | Unset = UNSET
+    truncate: str | Unset = UNSET
+    strip_new_lines: bool | Unset = False
+    batch_size: int | Unset = 1
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        region = self.region
+
+        dimension = self.dimension
+
+        dimensions = self.dimensions
+
+        input_type = self.input_type
+
+        truncate = self.truncate
+
+        strip_new_lines = self.strip_new_lines
+
+        batch_size = self.batch_size
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if region is not UNSET:
+            field_dict["region"] = region
+        if dimension is not UNSET:
+            field_dict["dimension"] = dimension
+        if dimensions is not UNSET:
+            field_dict["dimensions"] = dimensions
+        if input_type is not UNSET:
+            field_dict["input_type"] = input_type
+        if truncate is not UNSET:
+            field_dict["truncate"] = truncate
+        if strip_new_lines is not UNSET:
+            field_dict["strip_new_lines"] = strip_new_lines
+        if batch_size is not UNSET:
+            field_dict["batch_size"] = batch_size
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        region = d.pop("region", UNSET)
+
+        dimension = d.pop("dimension", UNSET)
+
+        dimensions = d.pop("dimensions", UNSET)
+
+        input_type = d.pop("input_type", UNSET)
+
+        truncate = d.pop("truncate", UNSET)
+
+        strip_new_lines = d.pop("strip_new_lines", UNSET)
+
+        batch_size = d.pop("batch_size", UNSET)
+
+        bedrock_embedder_config = cls(
+            model=model,
+            region=region,
+            dimension=dimension,
+            dimensions=dimensions,
+            input_type=input_type,
+            truncate=truncate,
+            strip_new_lines=strip_new_lines,
+            batch_size=batch_size,
+        )
+
+        bedrock_embedder_config.additional_properties = d
+        return bedrock_embedder_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/bedrock_generator_config.py

@@ -0,0 +1,109 @@
+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="BedrockGeneratorConfig")
+
+
+@_attrs_define
+class BedrockGeneratorConfig:
+    """Configuration for the AWS Bedrock generative AI provider.
+
+    Attributes:
+        model (str): The Bedrock model ID to use. Example: anthropic.claude-sonnet-4-5-20250929-v1:0.
+        region (str | Unset): The AWS region for the Bedrock service.
+        temperature (float | Unset): Controls randomness in generation (0.0-1.0).
+        max_tokens (int | Unset): Maximum number of tokens to generate.
+        top_p (float | Unset): Nucleus sampling parameter.
+        top_k (int | Unset): Top-k sampling parameter.
+    """
+
+    model: str
+    region: str | Unset = UNSET
+    temperature: float | Unset = UNSET
+    max_tokens: int | Unset = UNSET
+    top_p: float | Unset = UNSET
+    top_k: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        region = self.region
+
+        temperature = self.temperature
+
+        max_tokens = self.max_tokens
+
+        top_p = self.top_p
+
+        top_k = self.top_k
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if region is not UNSET:
+            field_dict["region"] = region
+        if temperature is not UNSET:
+            field_dict["temperature"] = temperature
+        if max_tokens is not UNSET:
+            field_dict["max_tokens"] = max_tokens
+        if top_p is not UNSET:
+            field_dict["top_p"] = top_p
+        if top_k is not UNSET:
+            field_dict["top_k"] = top_k
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        region = d.pop("region", UNSET)
+
+        temperature = d.pop("temperature", UNSET)
+
+        max_tokens = d.pop("max_tokens", UNSET)
+
+        top_p = d.pop("top_p", UNSET)
+
+        top_k = d.pop("top_k", UNSET)
+
+        bedrock_generator_config = cls(
+            model=model,
+            region=region,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+        )
+
+        bedrock_generator_config.additional_properties = d
+        return bedrock_generator_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/bing_search_config.py

@@ -0,0 +1,159 @@
+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.bing_search_config_freshness import BingSearchConfigFreshness
+from ..models.web_search_provider import WebSearchProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BingSearchConfig")
+
+
+@_attrs_define
+class BingSearchConfig:
+    """Configuration for Microsoft Bing Web Search API.
+
+    **Setup:**
+    1. Create Azure account at https://portal.azure.com
+    2. Create a Bing Search resource
+    3. Get API key from resource keys
+
+    **Docs:** https://docs.microsoft.com/en-us/bing/search-apis/bing-web-search/overview
+
+        Attributes:
+            provider (WebSearchProvider): The web search provider to use.
+
+                - **google**: Google Custom Search API (requires CSE setup)
+                - **bing**: Microsoft Bing Web Search API
+                - **serper**: Serper.dev Google Search API (simpler setup)
+                - **tavily**: Tavily AI Search API (optimized for RAG)
+                - **brave**: Brave Search API
+                - **duckduckgo**: DuckDuckGo Instant Answer API (limited, no API key)
+            max_results (int | Unset): Maximum number of search results to return Default: 5.
+            timeout_ms (int | Unset): Request timeout in milliseconds Default: 10000.
+            safe_search (bool | Unset): Enable safe search filtering Default: True.
+            language (str | Unset): Preferred language for results (e.g., 'en', 'es', 'fr') Example: en.
+            region (str | Unset): Preferred region for results (e.g., 'us', 'uk', 'de') Example: us.
+            api_key (str | Unset): Bing Search API key (or set BING_SEARCH_API_KEY env var)
+            endpoint (str | Unset): Bing API endpoint URL Default: 'https://api.bing.microsoft.com/v7.0/search'.
+            freshness (BingSearchConfigFreshness | Unset): Filter results by freshness
+    """
+
+    provider: WebSearchProvider
+    max_results: int | Unset = 5
+    timeout_ms: int | Unset = 10000
+    safe_search: bool | Unset = True
+    language: str | Unset = UNSET
+    region: str | Unset = UNSET
+    api_key: str | Unset = UNSET
+    endpoint: str | Unset = "https://api.bing.microsoft.com/v7.0/search"
+    freshness: BingSearchConfigFreshness | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        provider = self.provider.value
+
+        max_results = self.max_results
+
+        timeout_ms = self.timeout_ms
+
+        safe_search = self.safe_search
+
+        language = self.language
+
+        region = self.region
+
+        api_key = self.api_key
+
+        endpoint = self.endpoint
+
+        freshness: str | Unset = UNSET
+        if not isinstance(self.freshness, Unset):
+            freshness = self.freshness.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "provider": provider,
+            }
+        )
+        if max_results is not UNSET:
+            field_dict["max_results"] = max_results
+        if timeout_ms is not UNSET:
+            field_dict["timeout_ms"] = timeout_ms
+        if safe_search is not UNSET:
+            field_dict["safe_search"] = safe_search
+        if language is not UNSET:
+            field_dict["language"] = language
+        if region is not UNSET:
+            field_dict["region"] = region
+        if api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if endpoint is not UNSET:
+            field_dict["endpoint"] = endpoint
+        if freshness is not UNSET:
+            field_dict["freshness"] = freshness
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        provider = WebSearchProvider(d.pop("provider"))
+
+        max_results = d.pop("max_results", UNSET)
+
+        timeout_ms = d.pop("timeout_ms", UNSET)
+
+        safe_search = d.pop("safe_search", UNSET)
+
+        language = d.pop("language", UNSET)
+
+        region = d.pop("region", UNSET)
+
+        api_key = d.pop("api_key", UNSET)
+
+        endpoint = d.pop("endpoint", UNSET)
+
+        _freshness = d.pop("freshness", UNSET)
+        freshness: BingSearchConfigFreshness | Unset
+        if isinstance(_freshness, Unset):
+            freshness = UNSET
+        else:
+            freshness = BingSearchConfigFreshness(_freshness)
+
+        bing_search_config = cls(
+            provider=provider,
+            max_results=max_results,
+            timeout_ms=timeout_ms,
+            safe_search=safe_search,
+            language=language,
+            region=region,
+            api_key=api_key,
+            endpoint=endpoint,
+            freshness=freshness,
+        )
+
+        bing_search_config.additional_properties = d
+        return bing_search_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/bing_search_config_freshness.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class BingSearchConfigFreshness(str, Enum):
+    DAY = "Day"
+    MONTH = "Month"
+    WEEK = "Week"
+
+    def __str__(self) -> str:
+        return str(self.value)