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

antfly/client_generated/models/brave_search_config.py

@@ -0,0 +1,169 @@
+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.brave_search_config_freshness import BraveSearchConfigFreshness
+from ..models.web_search_provider import WebSearchProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BraveSearchConfig")
+
+
+@_attrs_define
+class BraveSearchConfig:
+    """Configuration for Brave Search API.
+
+    Brave Search provides privacy-focused search with its own independent index.
+
+    **Setup:**
+    1. Sign up at https://brave.com/search/api/
+    2. Get API key from dashboard
+
+    **Docs:** https://api.search.brave.com/app/documentation
+
+        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): Brave Search API key (or set BRAVE_API_KEY env var)
+            freshness (BraveSearchConfigFreshness | Unset): Freshness filter: pd=day, pw=week, pm=month, py=year
+            text_decorations (bool | Unset): Include text decorations (bold, italic markers) Default: False.
+            spellcheck (bool | Unset): Enable spellcheck suggestions Default: True.
+    """
+
+    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
+    freshness: BraveSearchConfigFreshness | Unset = UNSET
+    text_decorations: bool | Unset = False
+    spellcheck: bool | Unset = True
+    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
+
+        freshness: str | Unset = UNSET
+        if not isinstance(self.freshness, Unset):
+            freshness = self.freshness.value
+
+        text_decorations = self.text_decorations
+
+        spellcheck = self.spellcheck
+
+        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 freshness is not UNSET:
+            field_dict["freshness"] = freshness
+        if text_decorations is not UNSET:
+            field_dict["text_decorations"] = text_decorations
+        if spellcheck is not UNSET:
+            field_dict["spellcheck"] = spellcheck
+
+        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)
+
+        _freshness = d.pop("freshness", UNSET)
+        freshness: BraveSearchConfigFreshness | Unset
+        if isinstance(_freshness, Unset):
+            freshness = UNSET
+        else:
+            freshness = BraveSearchConfigFreshness(_freshness)
+
+        text_decorations = d.pop("text_decorations", UNSET)
+
+        spellcheck = d.pop("spellcheck", UNSET)
+
+        brave_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,
+            freshness=freshness,
+            text_decorations=text_decorations,
+            spellcheck=spellcheck,
+        )
+
+        brave_search_config.additional_properties = d
+        return brave_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/brave_search_config_freshness.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class BraveSearchConfigFreshness(str, Enum):
+    PD = "pd"
+    PM = "pm"
+    PW = "pw"
+    PY = "py"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/calendar_interval.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class CalendarInterval(str, Enum):
+    DAY = "day"
+    HOUR = "hour"
+    MINUTE = "minute"
+    MONTH = "month"
+    QUARTER = "quarter"
+    WEEK = "week"
+    YEAR = "year"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/chain_condition.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ChainCondition(str, Enum):
+    ALWAYS = "always"
+    ON_ERROR = "on_error"
+    ON_RATE_LIMIT = "on_rate_limit"
+    ON_TIMEOUT = "on_timeout"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/chain_link.py

@@ -0,0 +1,110 @@
+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
+
+from ..models.chain_condition import ChainCondition
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.generator_config import GeneratorConfig
+    from ..models.retry_config import RetryConfig
+
+
+T = TypeVar("T", bound="ChainLink")
+
+
+@_attrs_define
+class ChainLink:
+    """A single link in a generator chain with optional retry and condition
+
+    Attributes:
+        generator (GeneratorConfig): A unified configuration for a generative AI provider.
+             Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+        retry (RetryConfig | Unset): Retry configuration for generator calls
+        condition (ChainCondition | Unset): Condition for trying the next generator in chain:
+            - always: Always try next regardless of outcome
+            - on_error: Try next on any error (default)
+            - on_timeout: Try next only on timeout errors
+            - on_rate_limit: Try next only on rate limit errors
+    """
+
+    generator: GeneratorConfig
+    retry: RetryConfig | Unset = UNSET
+    condition: ChainCondition | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        generator = self.generator.to_dict()
+
+        retry: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.retry, Unset):
+            retry = self.retry.to_dict()
+
+        condition: str | Unset = UNSET
+        if not isinstance(self.condition, Unset):
+            condition = self.condition.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "generator": generator,
+            }
+        )
+        if retry is not UNSET:
+            field_dict["retry"] = retry
+        if condition is not UNSET:
+            field_dict["condition"] = condition
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.generator_config import GeneratorConfig
+        from ..models.retry_config import RetryConfig
+
+        d = dict(src_dict)
+        generator = GeneratorConfig.from_dict(d.pop("generator"))
+
+        _retry = d.pop("retry", UNSET)
+        retry: RetryConfig | Unset
+        if isinstance(_retry, Unset):
+            retry = UNSET
+        else:
+            retry = RetryConfig.from_dict(_retry)
+
+        _condition = d.pop("condition", UNSET)
+        condition: ChainCondition | Unset
+        if isinstance(_condition, Unset):
+            condition = UNSET
+        else:
+            condition = ChainCondition(_condition)
+
+        chain_link = cls(
+            generator=generator,
+            retry=retry,
+            condition=condition,
+        )
+
+        chain_link.additional_properties = d
+        return chain_link
+
+    @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/chat_message.py

@@ -0,0 +1,208 @@
+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 ..models.chat_message_role import ChatMessageRole
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.image_url_content_part import ImageURLContentPart
+    from ..models.media_content_part import MediaContentPart
+    from ..models.text_content_part import TextContentPart
+    from ..models.tool_call import ToolCall
+
+
+T = TypeVar("T", bound="ChatMessage")
+
+
+@_attrs_define
+class ChatMessage:
+    """OpenAI-compatible message in a generation/chat conversation.
+
+    Attributes:
+        role (ChatMessageRole): Role of the message sender in a generation/chat conversation
+        content (list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset): Message content.
+            Supports two formats:
+            - Simple string: "Hello, how are you?"
+            - Array of content parts: [{"type": "text", "text": "Hello"}]
+        tool_calls (list[ToolCall] | Unset): Tool calls made by the assistant (only for role=assistant).
+        tool_call_id (str | Unset): ID of the tool call this message responds to (only for role=tool).
+        name (str | Unset): Optional tool name for tool messages when model templates need it.
+    """
+
+    role: ChatMessageRole
+    content: list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset = UNSET
+    tool_calls: list[ToolCall] | Unset = UNSET
+    tool_call_id: str | Unset = UNSET
+    name: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.image_url_content_part import ImageURLContentPart
+        from ..models.text_content_part import TextContentPart
+
+        role = self.role.value
+
+        content: list[dict[str, Any]] | str | Unset
+        if isinstance(self.content, Unset):
+            content = UNSET
+        elif isinstance(self.content, list):
+            content = []
+            for componentsschemas_chat_message_content_type_1_item_data in self.content:
+                componentsschemas_chat_message_content_type_1_item: dict[str, Any]
+                if isinstance(componentsschemas_chat_message_content_type_1_item_data, TextContentPart):
+                    componentsschemas_chat_message_content_type_1_item = (
+                        componentsschemas_chat_message_content_type_1_item_data.to_dict()
+                    )
+                elif isinstance(componentsschemas_chat_message_content_type_1_item_data, ImageURLContentPart):
+                    componentsschemas_chat_message_content_type_1_item = (
+                        componentsschemas_chat_message_content_type_1_item_data.to_dict()
+                    )
+                else:
+                    componentsschemas_chat_message_content_type_1_item = (
+                        componentsschemas_chat_message_content_type_1_item_data.to_dict()
+                    )
+
+                content.append(componentsschemas_chat_message_content_type_1_item)
+
+        else:
+            content = self.content
+
+        tool_calls: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.tool_calls, Unset):
+            tool_calls = []
+            for tool_calls_item_data in self.tool_calls:
+                tool_calls_item = tool_calls_item_data.to_dict()
+                tool_calls.append(tool_calls_item)
+
+        tool_call_id = self.tool_call_id
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+            }
+        )
+        if content is not UNSET:
+            field_dict["content"] = content
+        if tool_calls is not UNSET:
+            field_dict["tool_calls"] = tool_calls
+        if tool_call_id is not UNSET:
+            field_dict["tool_call_id"] = tool_call_id
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.image_url_content_part import ImageURLContentPart
+        from ..models.media_content_part import MediaContentPart
+        from ..models.text_content_part import TextContentPart
+        from ..models.tool_call import ToolCall
+
+        d = dict(src_dict)
+        role = ChatMessageRole(d.pop("role"))
+
+        def _parse_content(
+            data: object,
+        ) -> list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                componentsschemas_chat_message_content_type_1 = []
+                _componentsschemas_chat_message_content_type_1 = data
+                for (
+                    componentsschemas_chat_message_content_type_1_item_data
+                ) in _componentsschemas_chat_message_content_type_1:
+
+                    def _parse_componentsschemas_chat_message_content_type_1_item(
+                        data: object,
+                    ) -> ImageURLContentPart | MediaContentPart | TextContentPart:
+                        try:
+                            if not isinstance(data, dict):
+                                raise TypeError()
+                            componentsschemas_content_part_type_0 = TextContentPart.from_dict(data)
+
+                            return componentsschemas_content_part_type_0
+                        except (TypeError, ValueError, AttributeError, KeyError):
+                            pass
+                        try:
+                            if not isinstance(data, dict):
+                                raise TypeError()
+                            componentsschemas_content_part_type_1 = ImageURLContentPart.from_dict(data)
+
+                            return componentsschemas_content_part_type_1
+                        except (TypeError, ValueError, AttributeError, KeyError):
+                            pass
+                        if not isinstance(data, dict):
+                            raise TypeError()
+                        componentsschemas_content_part_type_2 = MediaContentPart.from_dict(data)
+
+                        return componentsschemas_content_part_type_2
+
+                    componentsschemas_chat_message_content_type_1_item = (
+                        _parse_componentsschemas_chat_message_content_type_1_item(
+                            componentsschemas_chat_message_content_type_1_item_data
+                        )
+                    )
+
+                    componentsschemas_chat_message_content_type_1.append(
+                        componentsschemas_chat_message_content_type_1_item
+                    )
+
+                return componentsschemas_chat_message_content_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset, data)
+
+        content = _parse_content(d.pop("content", UNSET))
+
+        _tool_calls = d.pop("tool_calls", UNSET)
+        tool_calls: list[ToolCall] | Unset = UNSET
+        if _tool_calls is not UNSET:
+            tool_calls = []
+            for tool_calls_item_data in _tool_calls:
+                tool_calls_item = ToolCall.from_dict(tool_calls_item_data)
+
+                tool_calls.append(tool_calls_item)
+
+        tool_call_id = d.pop("tool_call_id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        chat_message = cls(
+            role=role,
+            content=content,
+            tool_calls=tool_calls,
+            tool_call_id=tool_call_id,
+            name=name,
+        )
+
+        chat_message.additional_properties = d
+        return chat_message
+
+    @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/chat_message_role.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ChatMessageRole(str, Enum):
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+    USER = "user"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/chat_tool_name.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class ChatToolName(str, Enum):
+    ADD_FILTER = "add_filter"
+    ASK_CLARIFICATION = "ask_clarification"
+    FETCH = "fetch"
+    FULL_TEXT_SEARCH = "full_text_search"
+    GRAPH_SEARCH = "graph_search"
+    SEARCH = "search"
+    SEMANTIC_SEARCH = "semantic_search"
+    TREE_SEARCH = "tree_search"
+    WEBSEARCH = "websearch"
+
+    def __str__(self) -> str:
+        return str(self.value)