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

antfly/client_generated/models/geo_point.py

@@ -0,0 +1,70 @@
+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="GeoPoint")
+
+
+@_attrs_define
+class GeoPoint:
+    """
+    Attributes:
+        lon (float | Unset):
+        lat (float | Unset):
+    """
+
+    lon: float | Unset = UNSET
+    lat: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        lon = self.lon
+
+        lat = self.lat
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if lon is not UNSET:
+            field_dict["lon"] = lon
+        if lat is not UNSET:
+            field_dict["lat"] = lat
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        lon = d.pop("lon", UNSET)
+
+        lat = d.pop("lat", UNSET)
+
+        geo_point = cls(
+            lon=lon,
+            lat=lat,
+        )
+
+        geo_point.additional_properties = d
+        return geo_point
+
+    @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/geo_shape_geometry_relation.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class GeoShapeGeometryRelation(str, Enum):
+    CONTAINS = "contains"
+    INTERSECTS = "intersects"
+    WITHIN = "within"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/get_current_user_response_200.py

@@ -0,0 +1,122 @@
+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.get_current_user_response_200_metadata_type_0 import GetCurrentUserResponse200MetadataType0
+    from ..models.permission import Permission
+
+
+T = TypeVar("T", bound="GetCurrentUserResponse200")
+
+
+@_attrs_define
+class GetCurrentUserResponse200:
+    """
+    Attributes:
+        username (str | Unset):  Example: johndoe.
+        permissions (list[Permission] | Unset):
+        metadata (GetCurrentUserResponse200MetadataType0 | None | Unset):
+    """
+
+    username: str | Unset = UNSET
+    permissions: list[Permission] | Unset = UNSET
+    metadata: GetCurrentUserResponse200MetadataType0 | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.get_current_user_response_200_metadata_type_0 import GetCurrentUserResponse200MetadataType0
+
+        username = self.username
+
+        permissions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.permissions, Unset):
+            permissions = []
+            for permissions_item_data in self.permissions:
+                permissions_item = permissions_item_data.to_dict()
+                permissions.append(permissions_item)
+
+        metadata: dict[str, Any] | None | Unset
+        if isinstance(self.metadata, Unset):
+            metadata = UNSET
+        elif isinstance(self.metadata, GetCurrentUserResponse200MetadataType0):
+            metadata = self.metadata.to_dict()
+        else:
+            metadata = self.metadata
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if username is not UNSET:
+            field_dict["username"] = username
+        if permissions is not UNSET:
+            field_dict["permissions"] = permissions
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.get_current_user_response_200_metadata_type_0 import GetCurrentUserResponse200MetadataType0
+        from ..models.permission import Permission
+
+        d = dict(src_dict)
+        username = d.pop("username", UNSET)
+
+        _permissions = d.pop("permissions", UNSET)
+        permissions: list[Permission] | Unset = UNSET
+        if _permissions is not UNSET:
+            permissions = []
+            for permissions_item_data in _permissions:
+                permissions_item = Permission.from_dict(permissions_item_data)
+
+                permissions.append(permissions_item)
+
+        def _parse_metadata(data: object) -> GetCurrentUserResponse200MetadataType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                metadata_type_0 = GetCurrentUserResponse200MetadataType0.from_dict(data)
+
+                return metadata_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(GetCurrentUserResponse200MetadataType0 | None | Unset, data)
+
+        metadata = _parse_metadata(d.pop("metadata", UNSET))
+
+        get_current_user_response_200 = cls(
+            username=username,
+            permissions=permissions,
+            metadata=metadata,
+        )
+
+        get_current_user_response_200.additional_properties = d
+        return get_current_user_response_200
+
+    @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/get_current_user_response_200_metadata_type_0.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="GetCurrentUserResponse200MetadataType0")
+
+
+@_attrs_define
+class GetCurrentUserResponse200MetadataType0:
+    """ """
+
+    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)
+        get_current_user_response_200_metadata_type_0 = cls()
+
+        get_current_user_response_200_metadata_type_0.additional_properties = d
+        return get_current_user_response_200_metadata_type_0
+
+    @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/google_embedder_config.py

@@ -0,0 +1,120 @@
+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="GoogleEmbedderConfig")
+
+
+@_attrs_define
+class GoogleEmbedderConfig:
+    """Configuration for the Google AI (Gemini) embedding provider.
+
+    API key via `api_key` field or `GEMINI_API_KEY` environment variable.
+
+    **Example Models:** gemini-embedding-001 (default, 3072 dims)
+
+    **Docs:** https://ai.google.dev/gemini-api/docs/embeddings
+
+        Example:
+            {'provider': 'gemini', 'model': 'gemini-embedding-001', 'dimension': 3072, 'api_key': 'your-api-key'}
+
+        Attributes:
+            model (str): The name of the embedding model to use. Default: 'gemini-embedding-001'. Example: gemini-
+                embedding-001.
+            project_id (str | Unset): The Google Cloud project ID (optional for Gemini API, required for Vertex AI).
+            location (str | Unset): The Google Cloud location (e.g., 'us-central1'). Required for Vertex AI, optional for
+                Gemini API.
+            dimension (int | Unset): The dimension of the embedding vector (768, 1536, or 3072 recommended). Default: 3072.
+            api_key (str | Unset): The Google API key. Can also be set via GEMINI_API_KEY environment variable.
+            url (str | Unset): The URL of the Google API endpoint (optional, uses default if not specified).
+    """
+
+    model: str = "gemini-embedding-001"
+    project_id: str | Unset = UNSET
+    location: str | Unset = UNSET
+    dimension: int | Unset = 3072
+    api_key: str | Unset = UNSET
+    url: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        project_id = self.project_id
+
+        location = self.location
+
+        dimension = self.dimension
+
+        api_key = self.api_key
+
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if project_id is not UNSET:
+            field_dict["project_id"] = project_id
+        if location is not UNSET:
+            field_dict["location"] = location
+        if dimension is not UNSET:
+            field_dict["dimension"] = dimension
+        if api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        project_id = d.pop("project_id", UNSET)
+
+        location = d.pop("location", UNSET)
+
+        dimension = d.pop("dimension", UNSET)
+
+        api_key = d.pop("api_key", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        google_embedder_config = cls(
+            model=model,
+            project_id=project_id,
+            location=location,
+            dimension=dimension,
+            api_key=api_key,
+            url=url,
+        )
+
+        google_embedder_config.additional_properties = d
+        return google_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/google_generator_config.py

@@ -0,0 +1,136 @@
+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="GoogleGeneratorConfig")
+
+
+@_attrs_define
+class GoogleGeneratorConfig:
+    """Configuration for the Google generative AI provider (Gemini).
+
+    Attributes:
+        model (str): The name of the generative model to use. Default: 'gemini-2.5-flash'. Example: gemini-2.5-flash.
+        project_id (str | Unset): The Google Cloud project ID.
+        location (str | Unset): The Google Cloud location (e.g., 'us-central1').
+        temperature (float | Unset): Controls randomness in generation (0.0-2.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.
+        api_key (str | Unset): The Google API key.
+        url (str | Unset): The URL of the Google API endpoint.
+    """
+
+    model: str = "gemini-2.5-flash"
+    project_id: str | Unset = UNSET
+    location: str | Unset = UNSET
+    temperature: float | Unset = UNSET
+    max_tokens: int | Unset = UNSET
+    top_p: float | Unset = UNSET
+    top_k: int | Unset = UNSET
+    api_key: str | Unset = UNSET
+    url: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        project_id = self.project_id
+
+        location = self.location
+
+        temperature = self.temperature
+
+        max_tokens = self.max_tokens
+
+        top_p = self.top_p
+
+        top_k = self.top_k
+
+        api_key = self.api_key
+
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if project_id is not UNSET:
+            field_dict["project_id"] = project_id
+        if location is not UNSET:
+            field_dict["location"] = location
+        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
+        if api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        project_id = d.pop("project_id", UNSET)
+
+        location = d.pop("location", 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)
+
+        api_key = d.pop("api_key", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        google_generator_config = cls(
+            model=model,
+            project_id=project_id,
+            location=location,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            api_key=api_key,
+            url=url,
+        )
+
+        google_generator_config.additional_properties = d
+        return google_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/google_search_config.py

@@ -0,0 +1,173 @@
+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.google_search_config_search_type import GoogleSearchConfigSearchType
+from ..models.web_search_provider import WebSearchProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="GoogleSearchConfig")
+
+
+@_attrs_define
+class GoogleSearchConfig:
+    """Configuration for Google Custom Search API.
+
+    Requires a Custom Search Engine (CSE) to be configured in Google Cloud Console.
+
+    **Setup:**
+    1. Create a project at https://console.cloud.google.com
+    2. Enable Custom Search API
+    3. Create a Custom Search Engine at https://cse.google.com
+    4. Get API key and CSE ID
+
+    **Docs:** https://developers.google.com/custom-search/v1/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): Google API key (or set GOOGLE_CSE_API_KEY env var)
+            cse_id (str | Unset): Custom Search Engine ID (or set GOOGLE_CSE_ID env var)
+            search_type (GoogleSearchConfigSearchType | Unset): Type of search to perform Default:
+                GoogleSearchConfigSearchType.WEB.
+            date_restrict (str | Unset): Restrict results by date (e.g., 'd7' for last 7 days, 'm1' for last month) Example:
+                m1.
+    """
+
+    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
+    cse_id: str | Unset = UNSET
+    search_type: GoogleSearchConfigSearchType | Unset = GoogleSearchConfigSearchType.WEB
+    date_restrict: str | 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
+
+        cse_id = self.cse_id
+
+        search_type: str | Unset = UNSET
+        if not isinstance(self.search_type, Unset):
+            search_type = self.search_type.value
+
+        date_restrict = self.date_restrict
+
+        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 cse_id is not UNSET:
+            field_dict["cse_id"] = cse_id
+        if search_type is not UNSET:
+            field_dict["search_type"] = search_type
+        if date_restrict is not UNSET:
+            field_dict["date_restrict"] = date_restrict
+
+        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)
+
+        cse_id = d.pop("cse_id", UNSET)
+
+        _search_type = d.pop("search_type", UNSET)
+        search_type: GoogleSearchConfigSearchType | Unset
+        if isinstance(_search_type, Unset):
+            search_type = UNSET
+        else:
+            search_type = GoogleSearchConfigSearchType(_search_type)
+
+        date_restrict = d.pop("date_restrict", UNSET)
+
+        google_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,
+            cse_id=cse_id,
+            search_type=search_type,
+            date_restrict=date_restrict,
+        )
+
+        google_search_config.additional_properties = d
+        return google_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/google_search_config_search_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class GoogleSearchConfigSearchType(str, Enum):
+    IMAGE = "image"
+    WEB = "web"
+
+    def __str__(self) -> str:
+        return str(self.value)