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

antfly/client_generated/models/open_ai_embedder_config.py

@@ -0,0 +1,104 @@
+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="OpenAIEmbedderConfig")
+
+
+@_attrs_define
+class OpenAIEmbedderConfig:
+    """Configuration for the OpenAI embedding provider.
+
+    API key via `api_key` field or `OPENAI_API_KEY` environment variable.
+    Supports OpenAI-compatible APIs via `url` field.
+
+    **Example Models:** text-embedding-3-small (default, 1536 dims), text-embedding-3-large (3072 dims)
+
+    **Docs:** https://platform.openai.com/docs/guides/embeddings
+
+        Example:
+            {'provider': 'openai', 'model': 'text-embedding-3-small', 'api_key': 'sk-...'}
+
+        Attributes:
+            model (str): The name of the OpenAI model to use. Default: 'text-embedding-3-small'. Example: text-
+                embedding-3-small.
+            url (str | Unset): The URL of the OpenAI API endpoint. Defaults to OpenAI's API. Can be set via OPENAI_BASE_URL
+                environment variable. Default: 'https://api.openai.com'. Example: https://api.openai.com.
+            api_key (str | Unset): The OpenAI API key. Can also be set via OPENAI_API_KEY environment variable.
+            dimensions (int | Unset): Output dimension for the embedding (uses MRL for dimension reduction). Recommended:
+                256, 512, 1024, 1536, or 3072.
+    """
+
+    model: str = "text-embedding-3-small"
+    url: str | Unset = "https://api.openai.com"
+    api_key: str | Unset = UNSET
+    dimensions: 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
+
+        api_key = self.api_key
+
+        dimensions = self.dimensions
+
+        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 api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if dimensions is not UNSET:
+            field_dict["dimensions"] = dimensions
+
+        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)
+
+        api_key = d.pop("api_key", UNSET)
+
+        dimensions = d.pop("dimensions", UNSET)
+
+        open_ai_embedder_config = cls(
+            model=model,
+            url=url,
+            api_key=api_key,
+            dimensions=dimensions,
+        )
+
+        open_ai_embedder_config.additional_properties = d
+        return open_ai_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/open_ai_generator_config.py

@@ -0,0 +1,127 @@
+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="OpenAIGeneratorConfig")
+
+
+@_attrs_define
+class OpenAIGeneratorConfig:
+    """Configuration for the OpenAI generative AI provider.
+
+    Attributes:
+        model (str): The name of the OpenAI model to use. Default: 'gpt-4.1'. Example: gpt-4.1.
+        url (str | Unset): The URL of the OpenAI API endpoint.
+        api_key (str | Unset): The OpenAI API key.
+        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.
+        frequency_penalty (float | Unset): Penalty for token frequency (-2.0 to 2.0).
+        presence_penalty (float | Unset): Penalty for token presence (-2.0 to 2.0).
+    """
+
+    model: str = "gpt-4.1"
+    url: str | Unset = UNSET
+    api_key: str | Unset = UNSET
+    temperature: float | Unset = UNSET
+    max_tokens: int | Unset = UNSET
+    top_p: float | Unset = UNSET
+    frequency_penalty: float | Unset = UNSET
+    presence_penalty: float | 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
+
+        api_key = self.api_key
+
+        temperature = self.temperature
+
+        max_tokens = self.max_tokens
+
+        top_p = self.top_p
+
+        frequency_penalty = self.frequency_penalty
+
+        presence_penalty = self.presence_penalty
+
+        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 api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        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 frequency_penalty is not UNSET:
+            field_dict["frequency_penalty"] = frequency_penalty
+        if presence_penalty is not UNSET:
+            field_dict["presence_penalty"] = presence_penalty
+
+        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)
+
+        api_key = d.pop("api_key", UNSET)
+
+        temperature = d.pop("temperature", UNSET)
+
+        max_tokens = d.pop("max_tokens", UNSET)
+
+        top_p = d.pop("top_p", UNSET)
+
+        frequency_penalty = d.pop("frequency_penalty", UNSET)
+
+        presence_penalty = d.pop("presence_penalty", UNSET)
+
+        open_ai_generator_config = cls(
+            model=model,
+            url=url,
+            api_key=api_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+        )
+
+        open_ai_generator_config.additional_properties = d
+        return open_ai_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/open_router_embedder_config.py

@@ -0,0 +1,94 @@
+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="OpenRouterEmbedderConfig")
+
+
+@_attrs_define
+class OpenRouterEmbedderConfig:
+    """Configuration for the OpenRouter embedding provider.
+
+    OpenRouter provides a unified API for multiple embedding models from different providers.
+    API key via `api_key` field or `OPENROUTER_API_KEY` environment variable.
+
+    **Example Models:** openai/text-embedding-3-small (default), openai/text-embedding-3-large,
+    google/gemini-embedding-001, qwen/qwen3-embedding-8b
+
+    **Docs:** https://openrouter.ai/docs/api/reference/embeddings
+
+        Example:
+            {'provider': 'openrouter', 'model': 'openai/text-embedding-3-small', 'api_key': 'sk-or-...'}
+
+        Attributes:
+            model (str): The OpenRouter model identifier (e.g., 'openai/text-embedding-3-small', 'google/gemini-
+                embedding-001'). Default: 'openai/text-embedding-3-small'. Example: openai/text-embedding-3-small.
+            api_key (str | Unset): The OpenRouter API key. Can also be set via OPENROUTER_API_KEY environment variable.
+            dimensions (int | Unset): Output dimension for the embedding (if supported by the model).
+    """
+
+    model: str = "openai/text-embedding-3-small"
+    api_key: str | Unset = UNSET
+    dimensions: 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_key = self.api_key
+
+        dimensions = self.dimensions
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if dimensions is not UNSET:
+            field_dict["dimensions"] = dimensions
+
+        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_key = d.pop("api_key", UNSET)
+
+        dimensions = d.pop("dimensions", UNSET)
+
+        open_router_embedder_config = cls(
+            model=model,
+            api_key=api_key,
+            dimensions=dimensions,
+        )
+
+        open_router_embedder_config.additional_properties = d
+        return open_router_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/open_router_generator_config.py

@@ -0,0 +1,128 @@
+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="OpenRouterGeneratorConfig")
+
+
+@_attrs_define
+class OpenRouterGeneratorConfig:
+    """Configuration for the OpenRouter generative AI provider.
+
+    Attributes:
+        model (str | Unset): Single model identifier. Either model or models must be provided. Example: openai/gpt-4.1.
+        models (list[str] | Unset): Array of model identifiers for fallback routing. Either model or models must be
+            provided.
+        api_key (str | Unset): The OpenRouter API key.
+        temperature (float | Unset): Controls randomness in generation (0.0-2.0).
+        max_tokens (int | Unset): Maximum number of tokens to generate in the response.
+        top_p (float | Unset): Nucleus sampling parameter (0.0-1.0).
+        frequency_penalty (float | Unset): Penalty for token frequency (-2.0 to 2.0).
+        presence_penalty (float | Unset): Penalty for token presence (-2.0 to 2.0).
+    """
+
+    model: str | Unset = UNSET
+    models: list[str] | Unset = UNSET
+    api_key: str | Unset = UNSET
+    temperature: float | Unset = UNSET
+    max_tokens: int | Unset = UNSET
+    top_p: float | Unset = UNSET
+    frequency_penalty: float | Unset = UNSET
+    presence_penalty: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        models: list[str] | Unset = UNSET
+        if not isinstance(self.models, Unset):
+            models = self.models
+
+        api_key = self.api_key
+
+        temperature = self.temperature
+
+        max_tokens = self.max_tokens
+
+        top_p = self.top_p
+
+        frequency_penalty = self.frequency_penalty
+
+        presence_penalty = self.presence_penalty
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if model is not UNSET:
+            field_dict["model"] = model
+        if models is not UNSET:
+            field_dict["models"] = models
+        if api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        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 frequency_penalty is not UNSET:
+            field_dict["frequency_penalty"] = frequency_penalty
+        if presence_penalty is not UNSET:
+            field_dict["presence_penalty"] = presence_penalty
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model", UNSET)
+
+        models = cast(list[str], d.pop("models", UNSET))
+
+        api_key = d.pop("api_key", UNSET)
+
+        temperature = d.pop("temperature", UNSET)
+
+        max_tokens = d.pop("max_tokens", UNSET)
+
+        top_p = d.pop("top_p", UNSET)
+
+        frequency_penalty = d.pop("frequency_penalty", UNSET)
+
+        presence_penalty = d.pop("presence_penalty", UNSET)
+
+        open_router_generator_config = cls(
+            model=model,
+            models=models,
+            api_key=api_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+        )
+
+        open_router_generator_config.additional_properties = d
+        return open_router_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/path.py

@@ -0,0 +1,108 @@
+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.path_edge import PathEdge
+
+
+T = TypeVar("T", bound="Path")
+
+
+@_attrs_define
+class Path:
+    """
+    Attributes:
+        nodes (list[str] | Unset): Ordered list of node keys (base64-encoded)
+        edges (list[PathEdge] | Unset):
+        total_weight (float | Unset):
+        length (int | Unset):
+    """
+
+    nodes: list[str] | Unset = UNSET
+    edges: list[PathEdge] | Unset = UNSET
+    total_weight: float | Unset = UNSET
+    length: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        nodes: list[str] | Unset = UNSET
+        if not isinstance(self.nodes, Unset):
+            nodes = self.nodes
+
+        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)
+
+        total_weight = self.total_weight
+
+        length = self.length
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if nodes is not UNSET:
+            field_dict["nodes"] = nodes
+        if edges is not UNSET:
+            field_dict["edges"] = edges
+        if total_weight is not UNSET:
+            field_dict["total_weight"] = total_weight
+        if length is not UNSET:
+            field_dict["length"] = length
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.path_edge import PathEdge
+
+        d = dict(src_dict)
+        nodes = cast(list[str], d.pop("nodes", UNSET))
+
+        _edges = d.pop("edges", UNSET)
+        edges: list[PathEdge] | Unset = UNSET
+        if _edges is not UNSET:
+            edges = []
+            for edges_item_data in _edges:
+                edges_item = PathEdge.from_dict(edges_item_data)
+
+                edges.append(edges_item)
+
+        total_weight = d.pop("total_weight", UNSET)
+
+        length = d.pop("length", UNSET)
+
+        path = cls(
+            nodes=nodes,
+            edges=edges,
+            total_weight=total_weight,
+            length=length,
+        )
+
+        path.additional_properties = d
+        return path
+
+    @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/path_edge.py

@@ -0,0 +1,110 @@
+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.path_edge_metadata import PathEdgeMetadata
+
+
+T = TypeVar("T", bound="PathEdge")
+
+
+@_attrs_define
+class PathEdge:
+    """
+    Attributes:
+        source (str | Unset):
+        target (str | Unset):
+        type_ (str | Unset):
+        weight (float | Unset):
+        metadata (PathEdgeMetadata | Unset):
+    """
+
+    source: str | Unset = UNSET
+    target: str | Unset = UNSET
+    type_: str | Unset = UNSET
+    weight: float | Unset = UNSET
+    metadata: PathEdgeMetadata | 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
+
+        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({})
+        if source is not UNSET:
+            field_dict["source"] = source
+        if target is not UNSET:
+            field_dict["target"] = target
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if weight is not UNSET:
+            field_dict["weight"] = weight
+        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.path_edge_metadata import PathEdgeMetadata
+
+        d = dict(src_dict)
+        source = d.pop("source", UNSET)
+
+        target = d.pop("target", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        weight = d.pop("weight", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: PathEdgeMetadata | Unset
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = PathEdgeMetadata.from_dict(_metadata)
+
+        path_edge = cls(
+            source=source,
+            target=target,
+            type_=type_,
+            weight=weight,
+            metadata=metadata,
+        )
+
+        path_edge.additional_properties = d
+        return path_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