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

antfly/client_generated/models/filter_spec.py

@@ -0,0 +1,88 @@
+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.filter_spec_operator import FilterSpecOperator
+
+T = TypeVar("T", bound="FilterSpec")
+
+
+@_attrs_define
+class FilterSpec:
+    """A filter specification to apply to search queries
+
+    Attributes:
+        field (str): Field name to filter on
+        operator (FilterSpecOperator): Filter operator:
+            - eq: Equals
+            - ne: Not equals
+            - gt/gte: Greater than (or equal)
+            - lt/lte: Less than (or equal)
+            - contains: Contains substring
+            - prefix: Starts with
+            - range: Between two values (value should be array [min, max])
+            - in: Value in list (value should be array)
+        value (Any): Filter value (string, number, boolean, or array for range/in operators)
+    """
+
+    field: str
+    operator: FilterSpecOperator
+    value: Any
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field = self.field
+
+        operator = self.operator.value
+
+        value = self.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "field": field,
+                "operator": operator,
+                "value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        field = d.pop("field")
+
+        operator = FilterSpecOperator(d.pop("operator"))
+
+        value = d.pop("value")
+
+        filter_spec = cls(
+            field=field,
+            operator=operator,
+            value=value,
+        )
+
+        filter_spec.additional_properties = d
+        return filter_spec
+
+    @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/filter_spec_operator.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class FilterSpecOperator(str, Enum):
+    CONTAINS = "contains"
+    EQ = "eq"
+    GT = "gt"
+    GTE = "gte"
+    IN = "in"
+    LT = "lt"
+    LTE = "lte"
+    NE = "ne"
+    PREFIX = "prefix"
+    RANGE = "range"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/followup_step_config.py

@@ -0,0 +1,128 @@
+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.chain_link import ChainLink
+    from ..models.generator_config import GeneratorConfig
+
+
+T = TypeVar("T", bound="FollowupStepConfig")
+
+
+@_attrs_define
+class FollowupStepConfig:
+    """Configuration for generating follow-up questions. Uses a separate generator
+    call which can use a cheaper/faster model.
+
+        Attributes:
+            enabled (bool | Unset): Enable follow-up question generation Default: False.
+            generator (GeneratorConfig | Unset): A unified configuration for a generative AI provider.
+                 Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+            chain (list[ChainLink] | Unset): Chain of generators to try in order. Mutually exclusive with 'generator'.
+            count (int | Unset): Number of follow-up questions to generate Default: 3.
+            context (str | Unset): Custom guidance for follow-up question focus and style Example: Focus on implementation
+                details and edge cases.
+    """
+
+    enabled: bool | Unset = False
+    generator: GeneratorConfig | Unset = UNSET
+    chain: list[ChainLink] | Unset = UNSET
+    count: int | Unset = 3
+    context: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        enabled = self.enabled
+
+        generator: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.generator, Unset):
+            generator = self.generator.to_dict()
+
+        chain: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.chain, Unset):
+            chain = []
+            for chain_item_data in self.chain:
+                chain_item = chain_item_data.to_dict()
+                chain.append(chain_item)
+
+        count = self.count
+
+        context = self.context
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if enabled is not UNSET:
+            field_dict["enabled"] = enabled
+        if generator is not UNSET:
+            field_dict["generator"] = generator
+        if chain is not UNSET:
+            field_dict["chain"] = chain
+        if count is not UNSET:
+            field_dict["count"] = count
+        if context is not UNSET:
+            field_dict["context"] = context
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.chain_link import ChainLink
+        from ..models.generator_config import GeneratorConfig
+
+        d = dict(src_dict)
+        enabled = d.pop("enabled", UNSET)
+
+        _generator = d.pop("generator", UNSET)
+        generator: GeneratorConfig | Unset
+        if isinstance(_generator, Unset):
+            generator = UNSET
+        else:
+            generator = GeneratorConfig.from_dict(_generator)
+
+        _chain = d.pop("chain", UNSET)
+        chain: list[ChainLink] | Unset = UNSET
+        if _chain is not UNSET:
+            chain = []
+            for chain_item_data in _chain:
+                chain_item = ChainLink.from_dict(chain_item_data)
+
+                chain.append(chain_item)
+
+        count = d.pop("count", UNSET)
+
+        context = d.pop("context", UNSET)
+
+        followup_step_config = cls(
+            enabled=enabled,
+            generator=generator,
+            chain=chain,
+            count=count,
+            context=context,
+        )
+
+        followup_step_config.additional_properties = d
+        return followup_step_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/foreign_column.py

@@ -0,0 +1,82 @@
+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="ForeignColumn")
+
+
+@_attrs_define
+class ForeignColumn:
+    """
+    Attributes:
+        name (str): Column name in the foreign table. Example: email.
+        type_ (str): Column data type. Used for filter validation and type coercion.
+            Common types: text, integer, bigint, float, boolean, timestamp, uuid, jsonb.
+             Example: text.
+        nullable (bool | Unset): Whether the column allows NULL values. Default: False.
+    """
+
+    name: str
+    type_: str
+    nullable: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        type_ = self.type_
+
+        nullable = self.nullable
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "type": type_,
+            }
+        )
+        if nullable is not UNSET:
+            field_dict["nullable"] = nullable
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        type_ = d.pop("type")
+
+        nullable = d.pop("nullable", UNSET)
+
+        foreign_column = cls(
+            name=name,
+            type_=type_,
+            nullable=nullable,
+        )
+
+        foreign_column.additional_properties = d
+        return foreign_column
+
+    @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/foreign_source.py

@@ -0,0 +1,114 @@
+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 ..models.foreign_source_type import ForeignSourceType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.foreign_column import ForeignColumn
+
+
+T = TypeVar("T", bound="ForeignSource")
+
+
+@_attrs_define
+class ForeignSource:
+    """
+    Attributes:
+        type_ (ForeignSourceType): Type of the foreign data source. Currently only "postgres" is supported.
+             Example: postgres.
+        dsn (str): Data source name (connection string) for the foreign database.
+            Supports `${secret:key_name}` references that resolve from the Antfly keystore
+            or environment variables.
+             Example: ${secret:pg_dsn}.
+        postgres_table (str): Name of the table or view in the foreign PostgreSQL database to query.
+             Example: customers.
+        columns (list[ForeignColumn] | Unset): Optional column definitions for the foreign table. If omitted, columns
+            are
+            auto-discovered from `information_schema.columns` on first query.
+    """
+
+    type_: ForeignSourceType
+    dsn: str
+    postgres_table: str
+    columns: list[ForeignColumn] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        dsn = self.dsn
+
+        postgres_table = self.postgres_table
+
+        columns: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.columns, Unset):
+            columns = []
+            for columns_item_data in self.columns:
+                columns_item = columns_item_data.to_dict()
+                columns.append(columns_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "dsn": dsn,
+                "postgres_table": postgres_table,
+            }
+        )
+        if columns is not UNSET:
+            field_dict["columns"] = columns
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.foreign_column import ForeignColumn
+
+        d = dict(src_dict)
+        type_ = ForeignSourceType(d.pop("type"))
+
+        dsn = d.pop("dsn")
+
+        postgres_table = d.pop("postgres_table")
+
+        _columns = d.pop("columns", UNSET)
+        columns: list[ForeignColumn] | Unset = UNSET
+        if _columns is not UNSET:
+            columns = []
+            for columns_item_data in _columns:
+                columns_item = ForeignColumn.from_dict(columns_item_data)
+
+                columns.append(columns_item)
+
+        foreign_source = cls(
+            type_=type_,
+            dsn=dsn,
+            postgres_table=postgres_table,
+            columns=columns,
+        )
+
+        foreign_source.additional_properties = d
+        return foreign_source
+
+    @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/foreign_source_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ForeignSourceType(str, Enum):
+    POSTGRES = "postgres"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/full_text_index_config.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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="FullTextIndexConfig")
+
+
+@_attrs_define
+class FullTextIndexConfig:
+    """
+    Attributes:
+        mem_only (bool | Unset): Whether to use memory-only storage
+    """
+
+    mem_only: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        mem_only = self.mem_only
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if mem_only is not UNSET:
+            field_dict["mem_only"] = mem_only
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        mem_only = d.pop("mem_only", UNSET)
+
+        full_text_index_config = cls(
+            mem_only=mem_only,
+        )
+
+        full_text_index_config.additional_properties = d
+        return full_text_index_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/full_text_index_stats.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 ..models.full_text_index_stats_index_type import FullTextIndexStatsIndexType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="FullTextIndexStats")
+
+
+@_attrs_define
+class FullTextIndexStats:
+    """
+    Attributes:
+        index_type (FullTextIndexStatsIndexType): Discriminator for the index stats variant.
+        error (str | Unset): Error message if stats could not be retrieved
+        total_indexed (int | Unset): Number of documents in the index
+        disk_usage (int | Unset): Size of the index in bytes
+        rebuilding (bool | Unset): Whether the index is currently rebuilding
+        backfill_progress (float | Unset): Progress of ongoing rebuild as fraction [0.0, 1.0]
+        backfill_items_processed (int | Unset): Number of documents indexed during current rebuild
+    """
+
+    index_type: FullTextIndexStatsIndexType
+    error: str | Unset = UNSET
+    total_indexed: int | Unset = UNSET
+    disk_usage: int | Unset = UNSET
+    rebuilding: bool | Unset = UNSET
+    backfill_progress: float | Unset = UNSET
+    backfill_items_processed: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        index_type = self.index_type.value
+
+        error = self.error
+
+        total_indexed = self.total_indexed
+
+        disk_usage = self.disk_usage
+
+        rebuilding = self.rebuilding
+
+        backfill_progress = self.backfill_progress
+
+        backfill_items_processed = self.backfill_items_processed
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "index_type": index_type,
+            }
+        )
+        if error is not UNSET:
+            field_dict["error"] = error
+        if total_indexed is not UNSET:
+            field_dict["total_indexed"] = total_indexed
+        if disk_usage is not UNSET:
+            field_dict["disk_usage"] = disk_usage
+        if rebuilding is not UNSET:
+            field_dict["rebuilding"] = rebuilding
+        if backfill_progress is not UNSET:
+            field_dict["backfill_progress"] = backfill_progress
+        if backfill_items_processed is not UNSET:
+            field_dict["backfill_items_processed"] = backfill_items_processed
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        index_type = FullTextIndexStatsIndexType(d.pop("index_type"))
+
+        error = d.pop("error", UNSET)
+
+        total_indexed = d.pop("total_indexed", UNSET)
+
+        disk_usage = d.pop("disk_usage", UNSET)
+
+        rebuilding = d.pop("rebuilding", UNSET)
+
+        backfill_progress = d.pop("backfill_progress", UNSET)
+
+        backfill_items_processed = d.pop("backfill_items_processed", UNSET)
+
+        full_text_index_stats = cls(
+            index_type=index_type,
+            error=error,
+            total_indexed=total_indexed,
+            disk_usage=disk_usage,
+            rebuilding=rebuilding,
+            backfill_progress=backfill_progress,
+            backfill_items_processed=backfill_items_processed,
+        )
+
+        full_text_index_stats.additional_properties = d
+        return full_text_index_stats
+
+    @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/full_text_index_stats_index_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class FullTextIndexStatsIndexType(str, Enum):
+    FULL_TEXT = "full_text"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/fuzziness_type_1.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class FuzzinessType1(str, Enum):
+    AUTO = "auto"
+
+    def __str__(self) -> str:
+        return str(self.value)