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

antfly/client_generated/models/retrieval_agent_usage.py

@@ -0,0 +1,129 @@
+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.prune_stats import PruneStats
+
+
+T = TypeVar("T", bound="RetrievalAgentUsage")
+
+
+@_attrs_define
+class RetrievalAgentUsage:
+    """Token usage and resource statistics from the retrieval agent execution
+
+    Attributes:
+        input_tokens (int | Unset): Total input tokens across all LLM calls
+        output_tokens (int | Unset): Total output tokens across all LLM calls
+        total_tokens (int | Unset): Sum of input + output tokens
+        cached_input_tokens (int | Unset): Input tokens served from cache
+        llm_calls (int | Unset): Number of LLM invocations made
+        resources_retrieved (int | Unset): Total resources found across all search queries
+        prune_stats (PruneStats | Unset): Statistics from token-based document pruning
+    """
+
+    input_tokens: int | Unset = UNSET
+    output_tokens: int | Unset = UNSET
+    total_tokens: int | Unset = UNSET
+    cached_input_tokens: int | Unset = UNSET
+    llm_calls: int | Unset = UNSET
+    resources_retrieved: int | Unset = UNSET
+    prune_stats: PruneStats | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        input_tokens = self.input_tokens
+
+        output_tokens = self.output_tokens
+
+        total_tokens = self.total_tokens
+
+        cached_input_tokens = self.cached_input_tokens
+
+        llm_calls = self.llm_calls
+
+        resources_retrieved = self.resources_retrieved
+
+        prune_stats: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.prune_stats, Unset):
+            prune_stats = self.prune_stats.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if input_tokens is not UNSET:
+            field_dict["input_tokens"] = input_tokens
+        if output_tokens is not UNSET:
+            field_dict["output_tokens"] = output_tokens
+        if total_tokens is not UNSET:
+            field_dict["total_tokens"] = total_tokens
+        if cached_input_tokens is not UNSET:
+            field_dict["cached_input_tokens"] = cached_input_tokens
+        if llm_calls is not UNSET:
+            field_dict["llm_calls"] = llm_calls
+        if resources_retrieved is not UNSET:
+            field_dict["resources_retrieved"] = resources_retrieved
+        if prune_stats is not UNSET:
+            field_dict["prune_stats"] = prune_stats
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.prune_stats import PruneStats
+
+        d = dict(src_dict)
+        input_tokens = d.pop("input_tokens", UNSET)
+
+        output_tokens = d.pop("output_tokens", UNSET)
+
+        total_tokens = d.pop("total_tokens", UNSET)
+
+        cached_input_tokens = d.pop("cached_input_tokens", UNSET)
+
+        llm_calls = d.pop("llm_calls", UNSET)
+
+        resources_retrieved = d.pop("resources_retrieved", UNSET)
+
+        _prune_stats = d.pop("prune_stats", UNSET)
+        prune_stats: PruneStats | Unset
+        if isinstance(_prune_stats, Unset):
+            prune_stats = UNSET
+        else:
+            prune_stats = PruneStats.from_dict(_prune_stats)
+
+        retrieval_agent_usage = cls(
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens,
+            cached_input_tokens=cached_input_tokens,
+            llm_calls=llm_calls,
+            resources_retrieved=resources_retrieved,
+            prune_stats=prune_stats,
+        )
+
+        retrieval_agent_usage.additional_properties = d
+        return retrieval_agent_usage
+
+    @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/retrieval_strategy.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class RetrievalStrategy(str, Enum):
+    BM25 = "bm25"
+    GRAPH = "graph"
+    HYBRID = "hybrid"
+    METADATA = "metadata"
+    SEMANTIC = "semantic"
+    TREE = "tree"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/retry_config.py

@@ -0,0 +1,89 @@
+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="RetryConfig")
+
+
+@_attrs_define
+class RetryConfig:
+    """Retry configuration for generator calls
+
+    Attributes:
+        max_attempts (int | Unset): Maximum number of retry attempts Default: 3.
+        initial_backoff_ms (int | Unset): Initial backoff delay in milliseconds Default: 1000.
+        backoff_multiplier (float | Unset): Multiplier for exponential backoff Default: 2.0.
+        max_backoff_ms (int | Unset): Maximum backoff delay in milliseconds Default: 30000.
+    """
+
+    max_attempts: int | Unset = 3
+    initial_backoff_ms: int | Unset = 1000
+    backoff_multiplier: float | Unset = 2.0
+    max_backoff_ms: int | Unset = 30000
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        max_attempts = self.max_attempts
+
+        initial_backoff_ms = self.initial_backoff_ms
+
+        backoff_multiplier = self.backoff_multiplier
+
+        max_backoff_ms = self.max_backoff_ms
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if max_attempts is not UNSET:
+            field_dict["max_attempts"] = max_attempts
+        if initial_backoff_ms is not UNSET:
+            field_dict["initial_backoff_ms"] = initial_backoff_ms
+        if backoff_multiplier is not UNSET:
+            field_dict["backoff_multiplier"] = backoff_multiplier
+        if max_backoff_ms is not UNSET:
+            field_dict["max_backoff_ms"] = max_backoff_ms
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        max_attempts = d.pop("max_attempts", UNSET)
+
+        initial_backoff_ms = d.pop("initial_backoff_ms", UNSET)
+
+        backoff_multiplier = d.pop("backoff_multiplier", UNSET)
+
+        max_backoff_ms = d.pop("max_backoff_ms", UNSET)
+
+        retry_config = cls(
+            max_attempts=max_attempts,
+            initial_backoff_ms=initial_backoff_ms,
+            backoff_multiplier=backoff_multiplier,
+            max_backoff_ms=max_backoff_ms,
+        )
+
+        retry_config.additional_properties = d
+        return retry_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/role_assignment.py

@@ -0,0 +1,61 @@
+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="RoleAssignment")
+
+
+@_attrs_define
+class RoleAssignment:
+    """
+    Attributes:
+        role (str): Role or group subject to assign, usually prefixed with role: or group:. Example: role:tenant_reader.
+    """
+
+    role: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        role = d.pop("role")
+
+        role_assignment = cls(
+            role=role,
+        )
+
+        role_assignment.additional_properties = d
+        return role_assignment
+
+    @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/route_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RouteType(str, Enum):
+    QUESTION = "question"
+    SEARCH = "search"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/row_filter_entry.py

@@ -0,0 +1,77 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.row_filter_entry_filter import RowFilterEntryFilter
+
+
+T = TypeVar("T", bound="RowFilterEntry")
+
+
+@_attrs_define
+class RowFilterEntry:
+    """A row filter policy for a user on a specific table.
+
+    Attributes:
+        table (str): Table name (or '*' for all tables). Example: orders.
+        filter_ (RowFilterEntryFilter): Antfly query JSON that documents must match to be visible. Example: {'term':
+            {'department': 'engineering'}}.
+    """
+
+    table: str
+    filter_: RowFilterEntryFilter
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        table = self.table
+
+        filter_ = self.filter_.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "table": table,
+                "filter": filter_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.row_filter_entry_filter import RowFilterEntryFilter
+
+        d = dict(src_dict)
+        table = d.pop("table")
+
+        filter_ = RowFilterEntryFilter.from_dict(d.pop("filter"))
+
+        row_filter_entry = cls(
+            table=table,
+            filter_=filter_,
+        )
+
+        row_filter_entry.additional_properties = d
+        return row_filter_entry
+
+    @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/row_filter_entry_filter.py

@@ -0,0 +1,52 @@
+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="RowFilterEntryFilter")
+
+
+@_attrs_define
+class RowFilterEntryFilter:
+    """Antfly query JSON that documents must match to be visible.
+
+    Example:
+        {'term': {'department': 'engineering'}}
+
+    """
+
+    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)
+        row_filter_entry_filter = cls()
+
+        row_filter_entry_filter.additional_properties = d
+        return row_filter_entry_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/secret_entry.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.secret_status import SecretStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SecretEntry")
+
+
+@_attrs_define
+class SecretEntry:
+    """
+    Attributes:
+        key (str): Secret name (e.g., openai.api_key)
+        status (SecretStatus): Source of the secret configuration
+        env_var (str | Unset): Corresponding environment variable name (e.g., OPENAI_API_KEY)
+        created_at (datetime.datetime | Unset):
+        updated_at (datetime.datetime | Unset):
+    """
+
+    key: str
+    status: SecretStatus
+    env_var: str | Unset = UNSET
+    created_at: datetime.datetime | Unset = UNSET
+    updated_at: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        key = self.key
+
+        status = self.status.value
+
+        env_var = self.env_var
+
+        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()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "key": key,
+                "status": status,
+            }
+        )
+        if env_var is not UNSET:
+            field_dict["env_var"] = env_var
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        key = d.pop("key")
+
+        status = SecretStatus(d.pop("status"))
+
+        env_var = d.pop("env_var", UNSET)
+
+        _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)
+
+        secret_entry = cls(
+            key=key,
+            status=status,
+            env_var=env_var,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        secret_entry.additional_properties = d
+        return secret_entry
+
+    @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/secret_list.py

@@ -0,0 +1,75 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.secret_entry import SecretEntry
+
+
+T = TypeVar("T", bound="SecretList")
+
+
+@_attrs_define
+class SecretList:
+    """
+    Attributes:
+        secrets (list[SecretEntry]):
+    """
+
+    secrets: list[SecretEntry]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        secrets = []
+        for secrets_item_data in self.secrets:
+            secrets_item = secrets_item_data.to_dict()
+            secrets.append(secrets_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "secrets": secrets,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.secret_entry import SecretEntry
+
+        d = dict(src_dict)
+        secrets = []
+        _secrets = d.pop("secrets")
+        for secrets_item_data in _secrets:
+            secrets_item = SecretEntry.from_dict(secrets_item_data)
+
+            secrets.append(secrets_item)
+
+        secret_list = cls(
+            secrets=secrets,
+        )
+
+        secret_list.additional_properties = d
+        return secret_list
+
+    @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/secret_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SecretStatus(str, Enum):
+    CONFIGURED_BOTH = "configured_both"
+    CONFIGURED_ENV = "configured_env"
+    CONFIGURED_KEYSTORE = "configured_keystore"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/secret_store_status.py

@@ -0,0 +1,62 @@
+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="SecretStoreStatus")
+
+
+@_attrs_define
+class SecretStoreStatus:
+    """Non-secret status for the local secrets file store, when one is available.
+
+    Attributes:
+        stale (bool | Unset): Whether Antfly is serving a last-known-good secrets snapshot after a failed refresh.
+    """
+
+    stale: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        stale = self.stale
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if stale is not UNSET:
+            field_dict["stale"] = stale
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        stale = d.pop("stale", UNSET)
+
+        secret_store_status = cls(
+            stale=stale,
+        )
+
+        secret_store_status.additional_properties = d
+        return secret_store_status
+
+    @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