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

antfly/client_generated/models/secret_write_request.py

@@ -0,0 +1,61 @@
+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="SecretWriteRequest")
+
+
+@_attrs_define
+class SecretWriteRequest:
+    """
+    Attributes:
+        value (str): Secret value (stored encrypted, never returned)
+    """
+
+    value: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        value = d.pop("value")
+
+        secret_write_request = cls(
+            value=value,
+        )
+
+        secret_write_request.additional_properties = d
+        return secret_write_request
+
+    @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/semantic_query_mode.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SemanticQueryMode(str, Enum):
+    HYPOTHETICAL = "hypothetical"
+    REWRITE = "rewrite"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/serper_search_config.py

@@ -0,0 +1,170 @@
+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.serper_search_config_search_type import SerperSearchConfigSearchType
+from ..models.serper_search_config_time_period import SerperSearchConfigTimePeriod
+from ..models.web_search_provider import WebSearchProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SerperSearchConfig")
+
+
+@_attrs_define
+class SerperSearchConfig:
+    """Configuration for Serper.dev Google Search API.
+
+    Serper provides a simpler alternative to Google Custom Search with
+    competitive pricing and easy setup.
+
+    **Setup:**
+    1. Sign up at https://serper.dev
+    2. Get API key from dashboard
+
+    **Docs:** https://serper.dev/docs
+
+        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): Serper API key (or set SERPER_API_KEY env var)
+            search_type (SerperSearchConfigSearchType | Unset): Type of search to perform Default:
+                SerperSearchConfigSearchType.SEARCH.
+            time_period (SerperSearchConfigTimePeriod | Unset): Time period filter: d=day, w=week, m=month, y=year
+    """
+
+    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
+    search_type: SerperSearchConfigSearchType | Unset = SerperSearchConfigSearchType.SEARCH
+    time_period: SerperSearchConfigTimePeriod | 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
+
+        search_type: str | Unset = UNSET
+        if not isinstance(self.search_type, Unset):
+            search_type = self.search_type.value
+
+        time_period: str | Unset = UNSET
+        if not isinstance(self.time_period, Unset):
+            time_period = self.time_period.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 search_type is not UNSET:
+            field_dict["search_type"] = search_type
+        if time_period is not UNSET:
+            field_dict["time_period"] = time_period
+
+        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)
+
+        _search_type = d.pop("search_type", UNSET)
+        search_type: SerperSearchConfigSearchType | Unset
+        if isinstance(_search_type, Unset):
+            search_type = UNSET
+        else:
+            search_type = SerperSearchConfigSearchType(_search_type)
+
+        _time_period = d.pop("time_period", UNSET)
+        time_period: SerperSearchConfigTimePeriod | Unset
+        if isinstance(_time_period, Unset):
+            time_period = UNSET
+        else:
+            time_period = SerperSearchConfigTimePeriod(_time_period)
+
+        serper_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,
+            search_type=search_type,
+            time_period=time_period,
+        )
+
+        serper_search_config.additional_properties = d
+        return serper_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/serper_search_config_search_type.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class SerperSearchConfigSearchType(str, Enum):
+    IMAGES = "images"
+    NEWS = "news"
+    PLACES = "places"
+    SEARCH = "search"
+    SHOPPING = "shopping"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/serper_search_config_time_period.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SerperSearchConfigTimePeriod(str, Enum):
+    D = "d"
+    M = "m"
+    W = "w"
+    Y = "y"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/set_row_filter_body.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="SetRowFilterBody")
+
+
+@_attrs_define
+class SetRowFilterBody:
+    """ """
+
+    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)
+        set_row_filter_body = cls()
+
+        set_row_filter_body.additional_properties = d
+        return set_row_filter_body
+
+    @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/set_subject_row_filter_body.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="SetSubjectRowFilterBody")
+
+
+@_attrs_define
+class SetSubjectRowFilterBody:
+    """ """
+
+    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)
+        set_subject_row_filter_body = cls()
+
+        set_subject_row_filter_body.additional_properties = d
+        return set_subject_row_filter_body
+
+    @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/shard_config.py

@@ -0,0 +1,61 @@
+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
+
+T = TypeVar("T", bound="ShardConfig")
+
+
+@_attrs_define
+class ShardConfig:
+    """
+    Attributes:
+        byte_range (list[str]):
+    """
+
+    byte_range: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        byte_range = self.byte_range
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "byte_range": byte_range,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        byte_range = cast(list[str], d.pop("byte_range"))
+
+        shard_config = cls(
+            byte_range=byte_range,
+        )
+
+        shard_config.additional_properties = d
+        return shard_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/shards_profile.py

@@ -0,0 +1,80 @@
+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="ShardsProfile")
+
+
+@_attrs_define
+class ShardsProfile:
+    """Shard-level execution statistics.
+
+    Attributes:
+        total (int | Unset): Total shards targeted by the query.
+        successful (int | Unset): Shards that returned results successfully.
+        failed (int | Unset): Shards that failed during execution.
+    """
+
+    total: int | Unset = UNSET
+    successful: int | Unset = UNSET
+    failed: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        total = self.total
+
+        successful = self.successful
+
+        failed = self.failed
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if total is not UNSET:
+            field_dict["total"] = total
+        if successful is not UNSET:
+            field_dict["successful"] = successful
+        if failed is not UNSET:
+            field_dict["failed"] = failed
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        total = d.pop("total", UNSET)
+
+        successful = d.pop("successful", UNSET)
+
+        failed = d.pop("failed", UNSET)
+
+        shards_profile = cls(
+            total=total,
+            successful=successful,
+            failed=failed,
+        )
+
+        shards_profile.additional_properties = d
+        return shards_profile
+
+    @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/significance_algorithm.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SignificanceAlgorithm(str, Enum):
+    CHI_SQUARED = "chi_squared"
+    JLH = "jlh"
+    MUTUAL_INFORMATION = "mutual_information"
+    PERCENTAGE = "percentage"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/sort_field.py

@@ -0,0 +1,73 @@
+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="SortField")
+
+
+@_attrs_define
+class SortField:
+    """A single sort field with direction.
+
+    Attributes:
+        field (str): The field name to sort by.
+        desc (bool | Unset): Sort direction. true = descending, false = ascending. Default: False.
+    """
+
+    field: str
+    desc: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field = self.field
+
+        desc = self.desc
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "field": field,
+            }
+        )
+        if desc is not UNSET:
+            field_dict["desc"] = desc
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        field = d.pop("field")
+
+        desc = d.pop("desc", UNSET)
+
+        sort_field = cls(
+            field=field,
+            desc=desc,
+        )
+
+        sort_field.additional_properties = d
+        return sort_field
+
+    @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/sse_error.py

@@ -0,0 +1,62 @@
+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="SSEError")
+
+
+@_attrs_define
+class SSEError:
+    """Emitted when an error occurs during retrieval
+
+    Attributes:
+        error (str): Error message
+    """
+
+    error: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = d.pop("error")
+
+        sse_error = cls(
+            error=error,
+        )
+
+        sse_error.additional_properties = d
+        return sse_error
+
+    @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/sse_event.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class SSEEvent(str, Enum):
+    CLASSIFICATION = "classification"
+    DONE = "done"
+    ERROR = "error"
+    EVAL = "eval"
+    FOLLOWUP = "followup"
+    GENERATION = "generation"
+    HIT = "hit"
+    REASONING = "reasoning"
+    STEP_COMPLETED = "step_completed"
+    STEP_PROGRESS = "step_progress"
+    STEP_STARTED = "step_started"
+    TOOL_MODE = "tool_mode"
+
+    def __str__(self) -> str:
+        return str(self.value)