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

antfly/client_generated/models/document_schema.py

@@ -0,0 +1,85 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.document_schema_schema import DocumentSchemaSchema
+
+
+T = TypeVar("T", bound="DocumentSchema")
+
+
+@_attrs_define
+class DocumentSchema:
+    """Defines the structure of a document type
+
+    Attributes:
+        description (str | Unset): A description of the document type.
+        schema (DocumentSchemaSchema | Unset): A valid JSON Schema defining the document's structure.
+            This is used to infer indexing rules and field types.
+    """
+
+    description: str | Unset = UNSET
+    schema: DocumentSchemaSchema | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        description = self.description
+
+        schema: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.schema, Unset):
+            schema = self.schema.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if description is not UNSET:
+            field_dict["description"] = description
+        if schema is not UNSET:
+            field_dict["schema"] = schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.document_schema_schema import DocumentSchemaSchema
+
+        d = dict(src_dict)
+        description = d.pop("description", UNSET)
+
+        _schema = d.pop("schema", UNSET)
+        schema: DocumentSchemaSchema | Unset
+        if isinstance(_schema, Unset):
+            schema = UNSET
+        else:
+            schema = DocumentSchemaSchema.from_dict(_schema)
+
+        document_schema = cls(
+            description=description,
+            schema=schema,
+        )
+
+        document_schema.additional_properties = d
+        return document_schema
+
+    @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/document_schema_schema.py

@@ -0,0 +1,50 @@
+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="DocumentSchemaSchema")
+
+
+@_attrs_define
+class DocumentSchemaSchema:
+    """A valid JSON Schema defining the document's structure.
+    This is used to infer indexing rules and field types.
+
+    """
+
+    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)
+        document_schema_schema = cls()
+
+        document_schema_schema.additional_properties = d
+        return document_schema_schema
+
+    @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/duck_duck_go_search_config.py

@@ -0,0 +1,143 @@
+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.web_search_provider import WebSearchProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DuckDuckGoSearchConfig")
+
+
+@_attrs_define
+class DuckDuckGoSearchConfig:
+    """Configuration for DuckDuckGo Instant Answer API.
+
+    DuckDuckGo provides limited free search without requiring an API key.
+    Best for simple queries; may not return results for all searches.
+
+    **Note:** This uses the Instant Answer API which has limitations.
+    For production use, consider other providers.
+
+    **Docs:** https://duckduckgo.com/api
+
+        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.
+            no_redirect (bool | Unset): Skip HTTP redirect for bang queries Default: True.
+            no_html (bool | Unset): Remove HTML from results 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
+    no_redirect: bool | Unset = True
+    no_html: 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
+
+        no_redirect = self.no_redirect
+
+        no_html = self.no_html
+
+        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 no_redirect is not UNSET:
+            field_dict["no_redirect"] = no_redirect
+        if no_html is not UNSET:
+            field_dict["no_html"] = no_html
+
+        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)
+
+        no_redirect = d.pop("no_redirect", UNSET)
+
+        no_html = d.pop("no_html", UNSET)
+
+        duck_duck_go_search_config = cls(
+            provider=provider,
+            max_results=max_results,
+            timeout_ms=timeout_ms,
+            safe_search=safe_search,
+            language=language,
+            region=region,
+            no_redirect=no_redirect,
+            no_html=no_html,
+        )
+
+        duck_duck_go_search_config.additional_properties = d
+        return duck_duck_go_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/dynamic_template.py

@@ -0,0 +1,141 @@
+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.dynamic_template_match_mapping_type import DynamicTemplateMatchMappingType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.template_field_mapping import TemplateFieldMapping
+
+
+T = TypeVar("T", bound="DynamicTemplate")
+
+
+@_attrs_define
+class DynamicTemplate:
+    """A rule for mapping dynamically detected fields. Templates are checked in order
+    and the first matching template's mapping is used.
+
+        Attributes:
+            name (str | Unset): Optional identifier for the template (useful for debugging)
+            match (str | Unset): Glob pattern for field name (last path element).
+                Supports * and ** wildcards. Example: "*_text" matches "title_text", "body_text"
+            unmatch (str | Unset): Exclusion pattern for field name. If it matches, the template is skipped.
+                Example: "skip_*" would exclude fields like "skip_this"
+            path_match (str | Unset): Glob pattern for the full dotted path. Supports ** for matching multiple segments.
+                Example: "metadata.**" matches "metadata.author", "metadata.tags.primary"
+            path_unmatch (str | Unset): Path exclusion pattern. If it matches the full path, the template is skipped.
+            match_mapping_type (DynamicTemplateMatchMappingType | Unset): Filter by detected JSON type
+            mapping (TemplateFieldMapping | Unset): Field mapping to apply when a dynamic template matches
+    """
+
+    name: str | Unset = UNSET
+    match: str | Unset = UNSET
+    unmatch: str | Unset = UNSET
+    path_match: str | Unset = UNSET
+    path_unmatch: str | Unset = UNSET
+    match_mapping_type: DynamicTemplateMatchMappingType | Unset = UNSET
+    mapping: TemplateFieldMapping | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        match = self.match
+
+        unmatch = self.unmatch
+
+        path_match = self.path_match
+
+        path_unmatch = self.path_unmatch
+
+        match_mapping_type: str | Unset = UNSET
+        if not isinstance(self.match_mapping_type, Unset):
+            match_mapping_type = self.match_mapping_type.value
+
+        mapping: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.mapping, Unset):
+            mapping = self.mapping.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if match is not UNSET:
+            field_dict["match"] = match
+        if unmatch is not UNSET:
+            field_dict["unmatch"] = unmatch
+        if path_match is not UNSET:
+            field_dict["path_match"] = path_match
+        if path_unmatch is not UNSET:
+            field_dict["path_unmatch"] = path_unmatch
+        if match_mapping_type is not UNSET:
+            field_dict["match_mapping_type"] = match_mapping_type
+        if mapping is not UNSET:
+            field_dict["mapping"] = mapping
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.template_field_mapping import TemplateFieldMapping
+
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        match = d.pop("match", UNSET)
+
+        unmatch = d.pop("unmatch", UNSET)
+
+        path_match = d.pop("path_match", UNSET)
+
+        path_unmatch = d.pop("path_unmatch", UNSET)
+
+        _match_mapping_type = d.pop("match_mapping_type", UNSET)
+        match_mapping_type: DynamicTemplateMatchMappingType | Unset
+        if isinstance(_match_mapping_type, Unset):
+            match_mapping_type = UNSET
+        else:
+            match_mapping_type = DynamicTemplateMatchMappingType(_match_mapping_type)
+
+        _mapping = d.pop("mapping", UNSET)
+        mapping: TemplateFieldMapping | Unset
+        if isinstance(_mapping, Unset):
+            mapping = UNSET
+        else:
+            mapping = TemplateFieldMapping.from_dict(_mapping)
+
+        dynamic_template = cls(
+            name=name,
+            match=match,
+            unmatch=unmatch,
+            path_match=path_match,
+            path_unmatch=path_unmatch,
+            match_mapping_type=match_mapping_type,
+            mapping=mapping,
+        )
+
+        dynamic_template.additional_properties = d
+        return dynamic_template
+
+    @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/dynamic_template_match_mapping_type.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class DynamicTemplateMatchMappingType(str, Enum):
+    BOOLEAN = "boolean"
+    DATE = "date"
+    NUMBER = "number"
+    OBJECT = "object"
+    STRING = "string"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/edge.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.edge_metadata import EdgeMetadata
+
+
+T = TypeVar("T", bound="Edge")
+
+
+@_attrs_define
+class Edge:
+    """A typed, weighted connection between documents
+
+    Attributes:
+        source (str): Base64-encoded source document key
+        target (str): Base64-encoded target document key
+        type_ (str): Edge type (e.g., "cites", "similar_to", "authored_by")
+        weight (float): Edge weight/confidence (0.0 to 1.0)
+        created_at (datetime.datetime | Unset): When the edge was created
+        updated_at (datetime.datetime | Unset): When the edge was last updated
+        metadata (EdgeMetadata | Unset): Optional edge metadata
+    """
+
+    source: str
+    target: str
+    type_: str
+    weight: float
+    created_at: datetime.datetime | Unset = UNSET
+    updated_at: datetime.datetime | Unset = UNSET
+    metadata: EdgeMetadata | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        source = self.source
+
+        target = self.target
+
+        type_ = self.type_
+
+        weight = self.weight
+
+        created_at: str | Unset = UNSET
+        if not isinstance(self.created_at, Unset):
+            created_at = self.created_at.isoformat()
+
+        updated_at: str | Unset = UNSET
+        if not isinstance(self.updated_at, Unset):
+            updated_at = self.updated_at.isoformat()
+
+        metadata: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.metadata, Unset):
+            metadata = self.metadata.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "source": source,
+                "target": target,
+                "type": type_,
+                "weight": weight,
+            }
+        )
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+        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.edge_metadata import EdgeMetadata
+
+        d = dict(src_dict)
+        source = d.pop("source")
+
+        target = d.pop("target")
+
+        type_ = d.pop("type")
+
+        weight = d.pop("weight")
+
+        _created_at = d.pop("created_at", UNSET)
+        created_at: datetime.datetime | Unset
+        if isinstance(_created_at, Unset):
+            created_at = UNSET
+        else:
+            created_at = isoparse(_created_at)
+
+        _updated_at = d.pop("updated_at", UNSET)
+        updated_at: datetime.datetime | Unset
+        if isinstance(_updated_at, Unset):
+            updated_at = UNSET
+        else:
+            updated_at = isoparse(_updated_at)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: EdgeMetadata | Unset
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = EdgeMetadata.from_dict(_metadata)
+
+        edge = cls(
+            source=source,
+            target=target,
+            type_=type_,
+            weight=weight,
+            created_at=created_at,
+            updated_at=updated_at,
+            metadata=metadata,
+        )
+
+        edge.additional_properties = d
+        return edge
+
+    @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/edge_direction.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class EdgeDirection(str, Enum):
+    BOTH = "both"
+    IN = "in"
+    OUT = "out"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/edge_metadata.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="EdgeMetadata")
+
+
+@_attrs_define
+class EdgeMetadata:
+    """Optional edge metadata"""
+
+    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)
+        edge_metadata = cls()
+
+        edge_metadata.additional_properties = d
+        return edge_metadata
+
+    @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