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

antfly/client_generated/models/multi_phrase_query.py

@@ -0,0 +1,131 @@
+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.fuzziness_type_1 import FuzzinessType1
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MultiPhraseQuery")
+
+
+@_attrs_define
+class MultiPhraseQuery:
+    """
+    Attributes:
+        terms (list[list[str]]):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+        fuzziness (FuzzinessType1 | int | Unset): The fuzziness of the query. Can be an integer or "auto".
+    """
+
+    terms: list[list[str]]
+    field: str | Unset = UNSET
+    boost: float | None | Unset = UNSET
+    fuzziness: FuzzinessType1 | int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        terms = []
+        for terms_item_data in self.terms:
+            terms_item = terms_item_data
+
+            terms.append(terms_item)
+
+        field = self.field
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        fuzziness: int | str | Unset
+        if isinstance(self.fuzziness, Unset):
+            fuzziness = UNSET
+        elif isinstance(self.fuzziness, FuzzinessType1):
+            fuzziness = self.fuzziness.value
+        else:
+            fuzziness = self.fuzziness
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "terms": terms,
+            }
+        )
+        if field is not UNSET:
+            field_dict["field"] = field
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+        if fuzziness is not UNSET:
+            field_dict["fuzziness"] = fuzziness
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        terms = []
+        _terms = d.pop("terms")
+        for terms_item_data in _terms:
+            terms_item = cast(list[str], terms_item_data)
+
+            terms.append(terms_item)
+
+        field = d.pop("field", UNSET)
+
+        def _parse_boost(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        boost = _parse_boost(d.pop("boost", UNSET))
+
+        def _parse_fuzziness(data: object) -> FuzzinessType1 | int | Unset:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_fuzziness_type_1 = FuzzinessType1(data)
+
+                return componentsschemas_fuzziness_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(FuzzinessType1 | int | Unset, data)
+
+        fuzziness = _parse_fuzziness(d.pop("fuzziness", UNSET))
+
+        multi_phrase_query = cls(
+            terms=terms,
+            field=field,
+            boost=boost,
+            fuzziness=fuzziness,
+        )
+
+        multi_phrase_query.additional_properties = d
+        return multi_phrase_query
+
+    @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/node_filter.py

@@ -0,0 +1,84 @@
+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.node_filter_filter_query import NodeFilterFilterQuery
+
+
+T = TypeVar("T", bound="NodeFilter")
+
+
+@_attrs_define
+class NodeFilter:
+    """Filter nodes during graph traversal using existing query primitives
+
+    Attributes:
+        filter_query (NodeFilterFilterQuery | Unset): Antfly query to filter nodes (same syntax as search filter_query)
+        filter_prefix (str | Unset): Filter by key prefix
+    """
+
+    filter_query: NodeFilterFilterQuery | Unset = UNSET
+    filter_prefix: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        filter_query: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.filter_query, Unset):
+            filter_query = self.filter_query.to_dict()
+
+        filter_prefix = self.filter_prefix
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if filter_query is not UNSET:
+            field_dict["filter_query"] = filter_query
+        if filter_prefix is not UNSET:
+            field_dict["filter_prefix"] = filter_prefix
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.node_filter_filter_query import NodeFilterFilterQuery
+
+        d = dict(src_dict)
+        _filter_query = d.pop("filter_query", UNSET)
+        filter_query: NodeFilterFilterQuery | Unset
+        if isinstance(_filter_query, Unset):
+            filter_query = UNSET
+        else:
+            filter_query = NodeFilterFilterQuery.from_dict(_filter_query)
+
+        filter_prefix = d.pop("filter_prefix", UNSET)
+
+        node_filter = cls(
+            filter_query=filter_query,
+            filter_prefix=filter_prefix,
+        )
+
+        node_filter.additional_properties = d
+        return node_filter
+
+    @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/node_filter_filter_query.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="NodeFilterFilterQuery")
+
+
+@_attrs_define
+class NodeFilterFilterQuery:
+    """Antfly query to filter nodes (same syntax as search filter_query)"""
+
+    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)
+        node_filter_filter_query = cls()
+
+        node_filter_filter_query.additional_properties = d
+        return node_filter_filter_query
+
+    @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/numeric_range_query.py

@@ -0,0 +1,163 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="NumericRangeQuery")
+
+
+@_attrs_define
+class NumericRangeQuery:
+    """
+    Attributes:
+        min_ (float | None | Unset):
+        max_ (float | None | Unset):
+        inclusive_min (bool | None | Unset):
+        inclusive_max (bool | None | Unset):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    min_: float | None | Unset = UNSET
+    max_: float | None | Unset = UNSET
+    inclusive_min: bool | None | Unset = UNSET
+    inclusive_max: bool | None | Unset = UNSET
+    field: str | Unset = UNSET
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        min_: float | None | Unset
+        if isinstance(self.min_, Unset):
+            min_ = UNSET
+        else:
+            min_ = self.min_
+
+        max_: float | None | Unset
+        if isinstance(self.max_, Unset):
+            max_ = UNSET
+        else:
+            max_ = self.max_
+
+        inclusive_min: bool | None | Unset
+        if isinstance(self.inclusive_min, Unset):
+            inclusive_min = UNSET
+        else:
+            inclusive_min = self.inclusive_min
+
+        inclusive_max: bool | None | Unset
+        if isinstance(self.inclusive_max, Unset):
+            inclusive_max = UNSET
+        else:
+            inclusive_max = self.inclusive_max
+
+        field = self.field
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if min_ is not UNSET:
+            field_dict["min"] = min_
+        if max_ is not UNSET:
+            field_dict["max"] = max_
+        if inclusive_min is not UNSET:
+            field_dict["inclusive_min"] = inclusive_min
+        if inclusive_max is not UNSET:
+            field_dict["inclusive_max"] = inclusive_max
+        if field is not UNSET:
+            field_dict["field"] = field
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_min_(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        min_ = _parse_min_(d.pop("min", UNSET))
+
+        def _parse_max_(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        max_ = _parse_max_(d.pop("max", UNSET))
+
+        def _parse_inclusive_min(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        inclusive_min = _parse_inclusive_min(d.pop("inclusive_min", UNSET))
+
+        def _parse_inclusive_max(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        inclusive_max = _parse_inclusive_max(d.pop("inclusive_max", UNSET))
+
+        field = d.pop("field", UNSET)
+
+        def _parse_boost(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        boost = _parse_boost(d.pop("boost", UNSET))
+
+        numeric_range_query = cls(
+            min_=min_,
+            max_=max_,
+            inclusive_min=inclusive_min,
+            inclusive_max=inclusive_max,
+            field=field,
+            boost=boost,
+        )
+
+        numeric_range_query.additional_properties = d
+        return numeric_range_query
+
+    @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/ollama_embedder_config.py

@@ -0,0 +1,84 @@
+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="OllamaEmbedderConfig")
+
+
+@_attrs_define
+class OllamaEmbedderConfig:
+    """Configuration for the Ollama embedding provider.
+
+    Local embeddings for privacy and offline use. URL via `url` field or `OLLAMA_HOST` env var.
+
+    **Example Models:** nomic-embed-text (768 dims), mxbai-embed-large (1024 dims), all-minilm (384 dims)
+
+    **Docs:** https://ollama.com/search?c=embedding
+
+        Example:
+            {'provider': 'ollama', 'model': 'nomic-embed-text', 'url': 'http://localhost:11434'}
+
+        Attributes:
+            model (str): The name of the Ollama model to use (e.g., 'nomic-embed-text', 'mxbai-embed-large'). Example:
+                nomic-embed-text.
+            url (str | Unset): The URL of the Ollama API endpoint. Can also be set via OLLAMA_HOST environment variable.
+                Default: 'http://localhost:11434'. Example: http://localhost:11434.
+    """
+
+    model: str
+    url: str | Unset = "http://localhost:11434"
+    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)
+
+        ollama_embedder_config = cls(
+            model=model,
+            url=url,
+        )
+
+        ollama_embedder_config.additional_properties = d
+        return ollama_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/ollama_generator_config.py

@@ -0,0 +1,118 @@
+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="OllamaGeneratorConfig")
+
+
+@_attrs_define
+class OllamaGeneratorConfig:
+    """Configuration for the Ollama generative AI provider.
+
+    Attributes:
+        model (str): The name of the Ollama model to use. Example: llama3.3:70b.
+        url (str | Unset): The URL of the Ollama API endpoint.
+        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 Ollama API calls.
+    """
+
+    model: str
+    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
+
+        url = self.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 url is not UNSET:
+            field_dict["url"] = 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")
+
+        url = d.pop("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)
+
+        ollama_generator_config = cls(
+            model=model,
+            url=url,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            timeout=timeout,
+        )
+
+        ollama_generator_config.additional_properties = d
+        return ollama_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/ollama_reranker_config.py

@@ -0,0 +1,73 @@
+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="OllamaRerankerConfig")
+
+
+@_attrs_define
+class OllamaRerankerConfig:
+    """Configuration for the Ollama reranking provider.
+
+    Attributes:
+        model (str): The name of the Ollama model to use for reranking.
+        url (str | Unset): The URL of the Ollama API endpoint.
+    """
+
+    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)
+
+        ollama_reranker_config = cls(
+            model=model,
+            url=url,
+        )
+
+        ollama_reranker_config.additional_properties = d
+        return ollama_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