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

antfly/client_generated/models/answer_agent_steps.py

@@ -0,0 +1,136 @@
+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.classification_step_config import ClassificationStepConfig
+    from ..models.confidence_step_config import ConfidenceStepConfig
+    from ..models.followup_step_config import FollowupStepConfig
+    from ..models.generation_step_config import GenerationStepConfig
+
+
+T = TypeVar("T", bound="AnswerAgentSteps")
+
+
+@_attrs_define
+class AnswerAgentSteps:
+    """DEPRECATED: Use RetrievalAgentSteps instead.
+    Configuration for the answer agent's pipeline steps.
+
+        Attributes:
+            classification (ClassificationStepConfig | Unset): Configuration for the classification step. This step analyzes
+                the query,
+                selects the optimal retrieval strategy, and generates semantic transformations.
+            answer (GenerationStepConfig | Unset): Configuration for the generation step. This step generates the final
+                response from retrieved documents using the reasoning as context.
+            followup (FollowupStepConfig | Unset): Configuration for generating follow-up questions. Uses a separate
+                generator
+                call which can use a cheaper/faster model.
+            confidence (ConfidenceStepConfig | Unset): Configuration for confidence assessment. Evaluates answer quality and
+                resource relevance. Can use a model calibrated for scoring tasks.
+    """
+
+    classification: ClassificationStepConfig | Unset = UNSET
+    answer: GenerationStepConfig | Unset = UNSET
+    followup: FollowupStepConfig | Unset = UNSET
+    confidence: ConfidenceStepConfig | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        classification: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.classification, Unset):
+            classification = self.classification.to_dict()
+
+        answer: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.answer, Unset):
+            answer = self.answer.to_dict()
+
+        followup: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.followup, Unset):
+            followup = self.followup.to_dict()
+
+        confidence: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.confidence, Unset):
+            confidence = self.confidence.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if classification is not UNSET:
+            field_dict["classification"] = classification
+        if answer is not UNSET:
+            field_dict["answer"] = answer
+        if followup is not UNSET:
+            field_dict["followup"] = followup
+        if confidence is not UNSET:
+            field_dict["confidence"] = confidence
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.classification_step_config import ClassificationStepConfig
+        from ..models.confidence_step_config import ConfidenceStepConfig
+        from ..models.followup_step_config import FollowupStepConfig
+        from ..models.generation_step_config import GenerationStepConfig
+
+        d = dict(src_dict)
+        _classification = d.pop("classification", UNSET)
+        classification: ClassificationStepConfig | Unset
+        if isinstance(_classification, Unset):
+            classification = UNSET
+        else:
+            classification = ClassificationStepConfig.from_dict(_classification)
+
+        _answer = d.pop("answer", UNSET)
+        answer: GenerationStepConfig | Unset
+        if isinstance(_answer, Unset):
+            answer = UNSET
+        else:
+            answer = GenerationStepConfig.from_dict(_answer)
+
+        _followup = d.pop("followup", UNSET)
+        followup: FollowupStepConfig | Unset
+        if isinstance(_followup, Unset):
+            followup = UNSET
+        else:
+            followup = FollowupStepConfig.from_dict(_followup)
+
+        _confidence = d.pop("confidence", UNSET)
+        confidence: ConfidenceStepConfig | Unset
+        if isinstance(_confidence, Unset):
+            confidence = UNSET
+        else:
+            confidence = ConfidenceStepConfig.from_dict(_confidence)
+
+        answer_agent_steps = cls(
+            classification=classification,
+            answer=answer,
+            followup=followup,
+            confidence=confidence,
+        )
+
+        answer_agent_steps.additional_properties = d
+        return answer_agent_steps
+
+    @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/antfly_chunker_config.py

@@ -0,0 +1,149 @@
+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.audio_chunk_options import AudioChunkOptions
+    from ..models.text_chunk_options import TextChunkOptions
+
+
+T = TypeVar("T", bound="AntflyChunkerConfig")
+
+
+@_attrs_define
+class AntflyChunkerConfig:
+    r"""Configuration for the Antfly inference chunking provider.
+
+    Antfly inference is a centralized HTTP service that provides chunking with multi-tier caching.
+    The model name maps to ONNX model directory names (similar to how Ollama works).
+
+    **Chunking Models:**
+    - fixed: Simple fixed-size chunking by token count (built-in, no ONNX required)
+    - Any other name will attempt to load from models/chunkers/{name}/ directory
+
+    **Caching:**
+    - L1: Memory cache with 2-minute TTL
+    - L2: Persistent Pebble database
+    - Singleflight deduplication for concurrent identical requests
+
+        Example:
+            {'provider': 'antfly', 'api_url': 'http://localhost:8080', 'model': 'fixed', 'max_chunks': 50, 'text':
+                {'target_tokens': 500, 'overlap_tokens': 50, 'separator': '\n\n'}}
+
+        Attributes:
+            model (str): The chunking model to use. Either 'fixed' for simple token-based chunking, or a model name from
+                models/chunkers/{name}/. Default: 'fixed'. Example: fixed.
+            max_chunks (int | Unset): Maximum number of chunks to generate per document.
+            threshold (float | Unset): Confidence threshold for model-based chunking (0.0-1.0).
+            text (TextChunkOptions | Unset): Options specific to text chunking.
+            audio (AudioChunkOptions | Unset): Options specific to audio chunking.
+            api_url (str | Unset): The URL of the Inference API endpoint (e.g., 'http://localhost:8080'). Can also be set
+                via ANTFLY_INFERENCE_URL environment variable. Example: http://localhost:8080.
+    """
+
+    model: str = "fixed"
+    max_chunks: int | Unset = UNSET
+    threshold: float | Unset = UNSET
+    text: TextChunkOptions | Unset = UNSET
+    audio: AudioChunkOptions | Unset = UNSET
+    api_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
+
+        max_chunks = self.max_chunks
+
+        threshold = self.threshold
+
+        text: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.text, Unset):
+            text = self.text.to_dict()
+
+        audio: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.audio, Unset):
+            audio = self.audio.to_dict()
+
+        api_url = self.api_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if max_chunks is not UNSET:
+            field_dict["max_chunks"] = max_chunks
+        if threshold is not UNSET:
+            field_dict["threshold"] = threshold
+        if text is not UNSET:
+            field_dict["text"] = text
+        if audio is not UNSET:
+            field_dict["audio"] = audio
+        if api_url is not UNSET:
+            field_dict["api_url"] = api_url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.audio_chunk_options import AudioChunkOptions
+        from ..models.text_chunk_options import TextChunkOptions
+
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        max_chunks = d.pop("max_chunks", UNSET)
+
+        threshold = d.pop("threshold", UNSET)
+
+        _text = d.pop("text", UNSET)
+        text: TextChunkOptions | Unset
+        if isinstance(_text, Unset):
+            text = UNSET
+        else:
+            text = TextChunkOptions.from_dict(_text)
+
+        _audio = d.pop("audio", UNSET)
+        audio: AudioChunkOptions | Unset
+        if isinstance(_audio, Unset):
+            audio = UNSET
+        else:
+            audio = AudioChunkOptions.from_dict(_audio)
+
+        api_url = d.pop("api_url", UNSET)
+
+        antfly_chunker_config = cls(
+            model=model,
+            max_chunks=max_chunks,
+            threshold=threshold,
+            text=text,
+            audio=audio,
+            api_url=api_url,
+        )
+
+        antfly_chunker_config.additional_properties = d
+        return antfly_chunker_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/antfly_embedder_config.py

@@ -0,0 +1,90 @@
+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="AntflyEmbedderConfig")
+
+
+@_attrs_define
+class AntflyEmbedderConfig:
+    """Configuration for the Antfly inference embedding provider.
+
+    Antfly inference is Antfly's built-in ML service for local embeddings using ONNX models.
+    It provides embedding generation with multi-tier caching (memory + persistent).
+
+    **Features:**
+    - Local ONNX-based embedding generation
+    - L1 memory cache with configurable TTL
+    - L2 persistent Pebble database cache
+    - Singleflight deduplication for concurrent identical requests
+
+    **Example Models:** bge-base-en-v1.5 (768 dims), all-MiniLM-L6-v2 (384 dims)
+
+    Models are loaded from the `models/embedders/{name}/` directory.
+
+        Example:
+            {'provider': 'antfly', 'model': 'bge-base-en-v1.5', 'api_url': 'http://localhost:8082'}
+
+        Attributes:
+            model (str): The embedding model name (maps to models/embedders/{name}/ directory). Example: bge-base-en-v1.5.
+            api_url (str | Unset): The URL of the Inference API endpoint. Can also be set via ANTFLY_INFERENCE_URL
+                environment variable. Example: http://localhost:8082.
+    """
+
+    model: str
+    api_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
+
+        api_url = self.api_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if api_url is not UNSET:
+            field_dict["api_url"] = api_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")
+
+        api_url = d.pop("api_url", UNSET)
+
+        antfly_embedder_config = cls(
+            model=model,
+            api_url=api_url,
+        )
+
+        antfly_embedder_config.additional_properties = d
+        return antfly_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/antfly_generator_config.py

@@ -0,0 +1,119 @@
+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="AntflyGeneratorConfig")
+
+
+@_attrs_define
+class AntflyGeneratorConfig:
+    """Configuration for the Antfly inference generative AI provider.
+
+    Attributes:
+        model (str): The name of the generator model. Example: onnxruntime/Gemma-3-ONNX.
+        api_url (str | Unset): The URL of the Inference API endpoint. Can also be set via ANTFLY_INFERENCE_URL
+            environment variable.
+        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.
+        timeout (int | Unset): HTTP response timeout in seconds for Inference API calls.
+    """
+
+    model: str
+    api_url: str | Unset = UNSET
+    temperature: float | Unset = UNSET
+    max_tokens: int | Unset = UNSET
+    top_p: float | Unset = UNSET
+    top_k: int | Unset = UNSET
+    timeout: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        api_url = self.api_url
+
+        temperature = self.temperature
+
+        max_tokens = self.max_tokens
+
+        top_p = self.top_p
+
+        top_k = self.top_k
+
+        timeout = self.timeout
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if api_url is not UNSET:
+            field_dict["api_url"] = api_url
+        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 timeout is not UNSET:
+            field_dict["timeout"] = timeout
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        api_url = d.pop("api_url", 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)
+
+        timeout = d.pop("timeout", UNSET)
+
+        antfly_generator_config = cls(
+            model=model,
+            api_url=api_url,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            timeout=timeout,
+        )
+
+        antfly_generator_config.additional_properties = d
+        return antfly_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/antfly_reranker_config.py

@@ -0,0 +1,77 @@
+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="AntflyRerankerConfig")
+
+
+@_attrs_define
+class AntflyRerankerConfig:
+    """Configuration for the Antfly inference reranking provider.
+
+    Example:
+        {'provider': 'antfly', 'model': 'mixedbread-ai/mxbai-rerank-base-v1', 'url': 'http://localhost:8080'}
+
+    Attributes:
+        model (str): The name of the reranking model (e.g., cross-encoder model name).
+        url (str | Unset): The URL of the Inference API endpoint. Can also be set via ANTFLY_INFERENCE_URL environment
+            variable.
+    """
+
+    model: str
+    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
+
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        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")
+
+        url = d.pop("url", UNSET)
+
+        antfly_reranker_config = cls(
+            model=model,
+            url=url,
+        )
+
+        antfly_reranker_config.additional_properties = d
+        return antfly_reranker_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/antfly_type.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class AntflyType(str, Enum):
+    BLOB = "blob"
+    BOOLEAN = "boolean"
+    DATETIME = "datetime"
+    EMBEDDING = "embedding"
+    GEOPOINT = "geopoint"
+    GEOSHAPE = "geoshape"
+    HTML = "html"
+    KEYWORD = "keyword"
+    LINK = "link"
+    NUMERIC = "numeric"
+    SEARCH_AS_YOU_TYPE = "search_as_you_type"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/antfly_type_2.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class AntflyType2(str, Enum):
+    BLOB = "blob"
+    BOOLEAN = "boolean"
+    DATETIME = "datetime"
+    EMBEDDING = "embedding"
+    GEOPOINT = "geopoint"
+    GEOSHAPE = "geoshape"
+    HTML = "html"
+    KEYWORD = "keyword"
+    LINK = "link"
+    NUMERIC = "numeric"
+    SEARCH_AS_YOU_TYPE = "search_as_you_type"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)