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

antfly/client_generated/models/edge_type_config.py

@@ -0,0 +1,133 @@
+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
+
+from ..models.edge_type_config_topology import EdgeTypeConfigTopology
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="EdgeTypeConfig")
+
+
+@_attrs_define
+class EdgeTypeConfig:
+    """Configuration for a specific edge type
+
+    Attributes:
+        name (str): Edge type name (e.g., 'cites', 'similar_to')
+        field (str | Unset): Document field containing target node key(s) for automatic edge creation.
+            Supports string (single target) or array of strings (multiple targets).
+            When omitted, edges must be provided explicitly via _edges.
+        topology (EdgeTypeConfigTopology | Unset): Topology constraint for this edge type:
+            - tree: Single parent per node, no cycles
+            - graph: No constraints (default)
+             Default: EdgeTypeConfigTopology.GRAPH.
+        max_weight (float | Unset): Maximum allowed edge weight Default: 1.0.
+        min_weight (float | Unset): Minimum allowed edge weight Default: 0.0.
+        allow_self_loops (bool | Unset): Whether to allow edges from a node to itself Default: True.
+        required_metadata (list[str] | Unset): Required metadata fields for this edge type
+    """
+
+    name: str
+    field: str | Unset = UNSET
+    topology: EdgeTypeConfigTopology | Unset = EdgeTypeConfigTopology.GRAPH
+    max_weight: float | Unset = 1.0
+    min_weight: float | Unset = 0.0
+    allow_self_loops: bool | Unset = True
+    required_metadata: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field = self.field
+
+        topology: str | Unset = UNSET
+        if not isinstance(self.topology, Unset):
+            topology = self.topology.value
+
+        max_weight = self.max_weight
+
+        min_weight = self.min_weight
+
+        allow_self_loops = self.allow_self_loops
+
+        required_metadata: list[str] | Unset = UNSET
+        if not isinstance(self.required_metadata, Unset):
+            required_metadata = self.required_metadata
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if field is not UNSET:
+            field_dict["field"] = field
+        if topology is not UNSET:
+            field_dict["topology"] = topology
+        if max_weight is not UNSET:
+            field_dict["max_weight"] = max_weight
+        if min_weight is not UNSET:
+            field_dict["min_weight"] = min_weight
+        if allow_self_loops is not UNSET:
+            field_dict["allow_self_loops"] = allow_self_loops
+        if required_metadata is not UNSET:
+            field_dict["required_metadata"] = required_metadata
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        field = d.pop("field", UNSET)
+
+        _topology = d.pop("topology", UNSET)
+        topology: EdgeTypeConfigTopology | Unset
+        if isinstance(_topology, Unset):
+            topology = UNSET
+        else:
+            topology = EdgeTypeConfigTopology(_topology)
+
+        max_weight = d.pop("max_weight", UNSET)
+
+        min_weight = d.pop("min_weight", UNSET)
+
+        allow_self_loops = d.pop("allow_self_loops", UNSET)
+
+        required_metadata = cast(list[str], d.pop("required_metadata", UNSET))
+
+        edge_type_config = cls(
+            name=name,
+            field=field,
+            topology=topology,
+            max_weight=max_weight,
+            min_weight=min_weight,
+            allow_self_loops=allow_self_loops,
+            required_metadata=required_metadata,
+        )
+
+        edge_type_config.additional_properties = d
+        return edge_type_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/edge_type_config_topology.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class EdgeTypeConfigTopology(str, Enum):
+    GRAPH = "graph"
+    TREE = "tree"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/edges_response.py

@@ -0,0 +1,88 @@
+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.edge import Edge
+
+
+T = TypeVar("T", bound="EdgesResponse")
+
+
+@_attrs_define
+class EdgesResponse:
+    """
+    Attributes:
+        edges (list[Edge] | Unset):
+        count (int | Unset): Total number of edges returned
+    """
+
+    edges: list[Edge] | Unset = UNSET
+    count: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        edges: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.edges, Unset):
+            edges = []
+            for edges_item_data in self.edges:
+                edges_item = edges_item_data.to_dict()
+                edges.append(edges_item)
+
+        count = self.count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if edges is not UNSET:
+            field_dict["edges"] = edges
+        if count is not UNSET:
+            field_dict["count"] = count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.edge import Edge
+
+        d = dict(src_dict)
+        _edges = d.pop("edges", UNSET)
+        edges: list[Edge] | Unset = UNSET
+        if _edges is not UNSET:
+            edges = []
+            for edges_item_data in _edges:
+                edges_item = Edge.from_dict(edges_item_data)
+
+                edges.append(edges_item)
+
+        count = d.pop("count", UNSET)
+
+        edges_response = cls(
+            edges=edges,
+            count=count,
+        )
+
+        edges_response.additional_properties = d
+        return edges_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/embedder_config.py

@@ -0,0 +1,267 @@
+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.embedder_provider import EmbedderProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="EmbedderConfig")
+
+
+@_attrs_define
+class EmbedderConfig:
+    r"""A unified configuration for an embedding provider.
+
+    Embedders can be configured with templates to customize how documents are
+    converted to text before embedding. Templates use Handlebars syntax and
+    support various built-in helpers.
+
+    **Template System:**
+    - **Syntax**: Handlebars templating (https://handlebarsjs.com/guide/)
+    - **Caching**: Templates are automatically cached with configurable TTL (default: 5 minutes)
+    - **Context**: Templates receive the full document as context
+
+    **Built-in Helpers:**
+
+    1. **scrubHtml** - Remove script/style tags and extract clean text from HTML
+       ```handlebars
+       {{scrubHtml html_content}}
+       ```
+       - Removes `<script>` and `<style>` tags
+       - Adds newlines after block elements (p, div, h1-h6, li, etc.)
+       - Returns plain text with preserved readability
+
+    2. **eq** - Equality comparison for conditionals
+       ```handlebars
+       {{#if (eq status "active")}}Active user{{/if}}
+       {{#if (eq @key "special")}}Special field{{/if}}
+       ```
+
+    3. **media** - GenKit dotprompt media directive for multimodal content
+       ```handlebars
+       {{media url=imageDataURI}}
+       {{media url=this.image_url}}
+       {{media url="https://example.com/image.jpg"}}
+       {{media url="s3://endpoint/bucket/image.png"}}
+       {{media url="file:///path/to/image.jpg"}}
+       ```
+
+       **Supported URL Schemes:**
+       - `data:` - Base64 encoded data URIs (e.g., `data:image/jpeg;base64,...`)
+       - `http://` / `https://` - Web URLs with automatic content type detection
+       - `file://` - Local filesystem paths
+       - `s3://` - S3-compatible storage (format: `s3://endpoint/bucket/key`)
+
+       **Automatic Content Processing:**
+       - **Images**: Downloaded, resized (if needed), converted to data URIs
+       - **PDFs**: Text extracted or first page rendered as image
+       - **HTML**: Readable text extracted using Mozilla Readability
+
+       **Security Controls:**
+       Downloads are protected by content security settings (see Configuration Reference):
+       - Allowed host whitelist
+       - Private IP blocking (prevents SSRF attacks)
+       - Download size limits (default: 100MB)
+       - Download timeouts (default: 30s)
+       - Image dimension limits (default: 2048px, auto-resized)
+
+       See: https://antfly.io/docs/configuration#security--cors
+
+    4. **encodeToon** - Encode data in TOON format (Token-Oriented Object Notation)
+       ```handlebars
+       {{encodeToon this.fields}}
+       {{encodeToon this.fields lengthMarker=false indent=4}}
+       {{encodeToon this.fields delimiter="\t"}}
+       ```
+
+       **What is TOON?**
+       TOON is a compact, human-readable format designed for passing structured data to LLMs.
+       It provides **30-60% token reduction** compared to JSON while maintaining high LLM
+       comprehension accuracy.
+
+       **Key Features:**
+       - Compact syntax using `:` for key-value pairs
+       - Array length markers: `tags[#3]: ai,search,ml`
+       - Tabular format for uniform data structures
+       - Optimized for LLM parsing and understanding
+       - Maintains human readability
+
+       **Benefits:**
+       - **Lower API costs** - Reduced token usage means lower LLM API costs
+       - **Faster responses** - Less tokens to process
+       - **More context** - Fit more documents within token limits
+
+       **Options:**
+       - `lengthMarker` (bool): Add # prefix to array counts like `[#3]` (default: true)
+       - `indent` (int): Indentation spacing for nested objects (default: 2)
+       - `delimiter` (string): Field separator for tabular arrays (default: none, use `"\t"` for tabs)
+
+       **Example output:**
+       ```
+       title: Introduction to Vector Search
+       author: Jane Doe
+       tags[#3]: ai,search,ml
+       metadata:
+         edition: 2
+         pages: 450
+       ```
+
+       **Default in RAG:** TOON is the default format for document rendering in RAG queries.
+
+       **References:**
+       - TOON Specification: https://github.com/toon-format/toon
+       - Go Implementation: https://github.com/alpkeskin/gotoon
+
+    **Template Examples:**
+
+    Document with metadata:
+    ```handlebars
+    Title: {{metadata.title}}
+    Date: {{metadata.date}}
+    Tags: {{#each metadata.tags}}{{this}}, {{/each}}
+
+    {{content}}
+    ```
+
+    HTML content extraction:
+    ```handlebars
+    Product: {{name}}
+    Description: {{scrubHtml description_html}}
+    Price: ${{price}}
+    ```
+
+    Multimodal with image:
+    ```handlebars
+    Product: {{title}}
+    {{media url=image}}
+    Description: {{description}}
+    ```
+
+    Conditional formatting:
+    ```handlebars
+    {{title}}
+    {{#if author}}By: {{author}}{{/if}}
+    {{#if (eq category "premium")}}⭐ Premium Content{{/if}}
+    {{body}}
+    ```
+
+    **Environment Variables:**
+    - `GEMINI_API_KEY` - API key for Google AI
+    - `OPENAI_API_KEY` - API key for OpenAI
+    - `OPENAI_BASE_URL` - Base URL for OpenAI-compatible APIs
+    - `OLLAMA_HOST` - Ollama server URL (e.g., http://localhost:11434)
+
+    **Importing Pre-computed Embeddings:**
+
+    You can import existing embeddings (from OpenAI, Cohere, or any provider), but only
+    for indexes configured with `external: true`. External indexes accept vectors written
+    directly through the document `_embeddings` field and do not generate prompts from
+    `field` or `template`.
+
+    **Steps:**
+    1. Create an embeddings index with `external: true`
+    2. For dense indexes, set the index `dimension`
+    3. Write documents with `_embeddings: { "<indexName>": [...<embedding>...] }`
+
+    **Example:**
+    ```json
+    {
+      "title": "My Document",
+      "content": "Document text...",
+      "_embeddings": {
+        "my_vector_index": [0.1, 0.2, 0.3, ...]
+      }
+    }
+    ```
+
+    **Delete Behavior:**
+    - Use `"_embeddings": { "<indexName>": null }` to delete a stored external vector
+    - Omitting `_embeddings[<indexName>]` leaves the existing vector unchanged
+
+    **Use Cases:**
+    - Migrating from another vector database with existing embeddings
+    - Using embeddings generated by external systems
+    - Importing pre-computed OpenAI, Cohere, or other provider embeddings
+    - Batch processing embeddings offline before ingestion
+
+        Example:
+            {'provider': 'openai', 'model': 'text-embedding-3-small'}
+
+        Attributes:
+            provider (EmbedderProvider): The embedding provider to use.
+            multimodal (bool | Unset): Declare that this model supports non-text content (images, audio, video, PDFs),
+                even if the model isn't in Antfly's built-in model registry yet.
+
+                When `true`, Antfly treats the model as multimodal and will send binary content
+                (images, audio, etc.) to the provider instead of extracting text. The provider's
+                API is still responsible for accepting the content — this flag just tells Antfly
+                not to strip it.
+
+                Not needed for models already in the registry (e.g., `multimodalembedding`,
+                `gemini-embedding-2-preview`, `clip-*`, `clipclap`).
+
+                **Example:**
+                ```json
+                {
+                  "provider": "vertex",
+                  "model": "some-future-multimodal-model",
+                  "multimodal": true
+                }
+                ```
+    """
+
+    provider: EmbedderProvider
+    multimodal: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        provider = self.provider.value
+
+        multimodal = self.multimodal
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "provider": provider,
+            }
+        )
+        if multimodal is not UNSET:
+            field_dict["multimodal"] = multimodal
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        provider = EmbedderProvider(d.pop("provider"))
+
+        multimodal = d.pop("multimodal", UNSET)
+
+        embedder_config = cls(
+            provider=provider,
+            multimodal=multimodal,
+        )
+
+        embedder_config.additional_properties = d
+        return 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/embedder_provider.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class EmbedderProvider(str, Enum):
+    ANTFLY = "antfly"
+    BEDROCK = "bedrock"
+    COHERE = "cohere"
+    GEMINI = "gemini"
+    MOCK = "mock"
+    OLLAMA = "ollama"
+    OPENAI = "openai"
+    OPENROUTER = "openrouter"
+    VERTEX = "vertex"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/embedding_type_1.py

@@ -0,0 +1,70 @@
+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="EmbeddingType1")
+
+
+@_attrs_define
+class EmbeddingType1:
+    """Sparse embedding with `indices` and `values` arrays
+
+    Attributes:
+        indices (list[int]):
+        values (list[float]):
+    """
+
+    indices: list[int]
+    values: list[float]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        indices = self.indices
+
+        values = self.values
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "indices": indices,
+                "values": values,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        indices = cast(list[int], d.pop("indices"))
+
+        values = cast(list[float], d.pop("values"))
+
+        embedding_type_1 = cls(
+            indices=indices,
+            values=values,
+        )
+
+        embedding_type_1.additional_properties = d
+        return embedding_type_1
+
+    @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/embedding_type_3.py

@@ -0,0 +1,71 @@
+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="EmbeddingType3")
+
+
+@_attrs_define
+class EmbeddingType3:
+    """Packed sparse embedding with base64-encoded indices and values.
+    Same semantics as the sparse object format but more compact on the wire.
+
+        Attributes:
+            packed_indices (str): Base64-encoded little-endian uint32 bytes for sparse indices
+            packed_values (str): Base64-encoded little-endian float32 bytes for sparse values
+    """
+
+    packed_indices: str
+    packed_values: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        packed_indices = self.packed_indices
+
+        packed_values = self.packed_values
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "packed_indices": packed_indices,
+                "packed_values": packed_values,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        packed_indices = d.pop("packed_indices")
+
+        packed_values = d.pop("packed_values")
+
+        embedding_type_3 = cls(
+            packed_indices=packed_indices,
+            packed_values=packed_values,
+        )
+
+        embedding_type_3.additional_properties = d
+        return embedding_type_3
+
+    @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