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

antfly/client_generated/models/eval_config.py

@@ -0,0 +1,135 @@
+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.evaluator_name import EvaluatorName
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.eval_options import EvalOptions
+    from ..models.generator_config import GeneratorConfig
+    from ..models.ground_truth import GroundTruth
+
+
+T = TypeVar("T", bound="EvalConfig")
+
+
+@_attrs_define
+class EvalConfig:
+    """Configuration for inline evaluation of query results.
+    Add to RAGRequest, QueryRequest, or AnswerAgentRequest.
+
+        Attributes:
+            evaluators (list[EvaluatorName] | Unset): List of evaluators to run
+            judge (GeneratorConfig | Unset): A unified configuration for a generative AI provider.
+                 Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+            ground_truth (GroundTruth | Unset): Ground truth data for evaluation
+            options (EvalOptions | Unset): Options for evaluation behavior
+    """
+
+    evaluators: list[EvaluatorName] | Unset = UNSET
+    judge: GeneratorConfig | Unset = UNSET
+    ground_truth: GroundTruth | Unset = UNSET
+    options: EvalOptions | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        evaluators: list[str] | Unset = UNSET
+        if not isinstance(self.evaluators, Unset):
+            evaluators = []
+            for evaluators_item_data in self.evaluators:
+                evaluators_item = evaluators_item_data.value
+                evaluators.append(evaluators_item)
+
+        judge: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.judge, Unset):
+            judge = self.judge.to_dict()
+
+        ground_truth: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.ground_truth, Unset):
+            ground_truth = self.ground_truth.to_dict()
+
+        options: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if evaluators is not UNSET:
+            field_dict["evaluators"] = evaluators
+        if judge is not UNSET:
+            field_dict["judge"] = judge
+        if ground_truth is not UNSET:
+            field_dict["ground_truth"] = ground_truth
+        if options is not UNSET:
+            field_dict["options"] = options
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.eval_options import EvalOptions
+        from ..models.generator_config import GeneratorConfig
+        from ..models.ground_truth import GroundTruth
+
+        d = dict(src_dict)
+        _evaluators = d.pop("evaluators", UNSET)
+        evaluators: list[EvaluatorName] | Unset = UNSET
+        if _evaluators is not UNSET:
+            evaluators = []
+            for evaluators_item_data in _evaluators:
+                evaluators_item = EvaluatorName(evaluators_item_data)
+
+                evaluators.append(evaluators_item)
+
+        _judge = d.pop("judge", UNSET)
+        judge: GeneratorConfig | Unset
+        if isinstance(_judge, Unset):
+            judge = UNSET
+        else:
+            judge = GeneratorConfig.from_dict(_judge)
+
+        _ground_truth = d.pop("ground_truth", UNSET)
+        ground_truth: GroundTruth | Unset
+        if isinstance(_ground_truth, Unset):
+            ground_truth = UNSET
+        else:
+            ground_truth = GroundTruth.from_dict(_ground_truth)
+
+        _options = d.pop("options", UNSET)
+        options: EvalOptions | Unset
+        if isinstance(_options, Unset):
+            options = UNSET
+        else:
+            options = EvalOptions.from_dict(_options)
+
+        eval_config = cls(
+            evaluators=evaluators,
+            judge=judge,
+            ground_truth=ground_truth,
+            options=options,
+        )
+
+        eval_config.additional_properties = d
+        return eval_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/eval_options.py

@@ -0,0 +1,80 @@
+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="EvalOptions")
+
+
+@_attrs_define
+class EvalOptions:
+    """Options for evaluation behavior
+
+    Attributes:
+        k (int | Unset): K value for @K metrics (precision@k, recall@k, ndcg@k) Default: 10.
+        pass_threshold (float | Unset): Score threshold for pass/fail determination Default: 0.5.
+        timeout_seconds (int | Unset): Timeout for evaluation in seconds Default: 30.
+    """
+
+    k: int | Unset = 10
+    pass_threshold: float | Unset = 0.5
+    timeout_seconds: int | Unset = 30
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        k = self.k
+
+        pass_threshold = self.pass_threshold
+
+        timeout_seconds = self.timeout_seconds
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if k is not UNSET:
+            field_dict["k"] = k
+        if pass_threshold is not UNSET:
+            field_dict["pass_threshold"] = pass_threshold
+        if timeout_seconds is not UNSET:
+            field_dict["timeout_seconds"] = timeout_seconds
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        k = d.pop("k", UNSET)
+
+        pass_threshold = d.pop("pass_threshold", UNSET)
+
+        timeout_seconds = d.pop("timeout_seconds", UNSET)
+
+        eval_options = cls(
+            k=k,
+            pass_threshold=pass_threshold,
+            timeout_seconds=timeout_seconds,
+        )
+
+        eval_options.additional_properties = d
+        return eval_options
+
+    @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/eval_request.py

@@ -0,0 +1,185 @@
+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 ..models.evaluator_name import EvaluatorName
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.eval_options import EvalOptions
+    from ..models.eval_request_context_item import EvalRequestContextItem
+    from ..models.generator_config import GeneratorConfig
+    from ..models.ground_truth import GroundTruth
+
+
+T = TypeVar("T", bound="EvalRequest")
+
+
+@_attrs_define
+class EvalRequest:
+    """Standalone evaluation request for POST /eval endpoint.
+    Useful for testing evaluators without running a query.
+
+        Attributes:
+            evaluators (list[EvaluatorName]): List of evaluators to run
+            judge (GeneratorConfig | Unset): A unified configuration for a generative AI provider.
+                 Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+            ground_truth (GroundTruth | Unset): Ground truth data for evaluation
+            options (EvalOptions | Unset): Options for evaluation behavior
+            query (str | Unset): Original query/input to evaluate
+            output (str | Unset): Generated output to evaluate (optional for retrieval-only)
+            context (list[EvalRequestContextItem] | Unset): Retrieved documents/context
+            retrieved_ids (list[str] | Unset): IDs of retrieved documents (for retrieval metrics)
+    """
+
+    evaluators: list[EvaluatorName]
+    judge: GeneratorConfig | Unset = UNSET
+    ground_truth: GroundTruth | Unset = UNSET
+    options: EvalOptions | Unset = UNSET
+    query: str | Unset = UNSET
+    output: str | Unset = UNSET
+    context: list[EvalRequestContextItem] | Unset = UNSET
+    retrieved_ids: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        evaluators = []
+        for evaluators_item_data in self.evaluators:
+            evaluators_item = evaluators_item_data.value
+            evaluators.append(evaluators_item)
+
+        judge: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.judge, Unset):
+            judge = self.judge.to_dict()
+
+        ground_truth: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.ground_truth, Unset):
+            ground_truth = self.ground_truth.to_dict()
+
+        options: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options.to_dict()
+
+        query = self.query
+
+        output = self.output
+
+        context: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.context, Unset):
+            context = []
+            for context_item_data in self.context:
+                context_item = context_item_data.to_dict()
+                context.append(context_item)
+
+        retrieved_ids: list[str] | Unset = UNSET
+        if not isinstance(self.retrieved_ids, Unset):
+            retrieved_ids = self.retrieved_ids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "evaluators": evaluators,
+            }
+        )
+        if judge is not UNSET:
+            field_dict["judge"] = judge
+        if ground_truth is not UNSET:
+            field_dict["ground_truth"] = ground_truth
+        if options is not UNSET:
+            field_dict["options"] = options
+        if query is not UNSET:
+            field_dict["query"] = query
+        if output is not UNSET:
+            field_dict["output"] = output
+        if context is not UNSET:
+            field_dict["context"] = context
+        if retrieved_ids is not UNSET:
+            field_dict["retrieved_ids"] = retrieved_ids
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.eval_options import EvalOptions
+        from ..models.eval_request_context_item import EvalRequestContextItem
+        from ..models.generator_config import GeneratorConfig
+        from ..models.ground_truth import GroundTruth
+
+        d = dict(src_dict)
+        evaluators = []
+        _evaluators = d.pop("evaluators")
+        for evaluators_item_data in _evaluators:
+            evaluators_item = EvaluatorName(evaluators_item_data)
+
+            evaluators.append(evaluators_item)
+
+        _judge = d.pop("judge", UNSET)
+        judge: GeneratorConfig | Unset
+        if isinstance(_judge, Unset):
+            judge = UNSET
+        else:
+            judge = GeneratorConfig.from_dict(_judge)
+
+        _ground_truth = d.pop("ground_truth", UNSET)
+        ground_truth: GroundTruth | Unset
+        if isinstance(_ground_truth, Unset):
+            ground_truth = UNSET
+        else:
+            ground_truth = GroundTruth.from_dict(_ground_truth)
+
+        _options = d.pop("options", UNSET)
+        options: EvalOptions | Unset
+        if isinstance(_options, Unset):
+            options = UNSET
+        else:
+            options = EvalOptions.from_dict(_options)
+
+        query = d.pop("query", UNSET)
+
+        output = d.pop("output", UNSET)
+
+        _context = d.pop("context", UNSET)
+        context: list[EvalRequestContextItem] | Unset = UNSET
+        if _context is not UNSET:
+            context = []
+            for context_item_data in _context:
+                context_item = EvalRequestContextItem.from_dict(context_item_data)
+
+                context.append(context_item)
+
+        retrieved_ids = cast(list[str], d.pop("retrieved_ids", UNSET))
+
+        eval_request = cls(
+            evaluators=evaluators,
+            judge=judge,
+            ground_truth=ground_truth,
+            options=options,
+            query=query,
+            output=output,
+            context=context,
+            retrieved_ids=retrieved_ids,
+        )
+
+        eval_request.additional_properties = d
+        return eval_request
+
+    @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/eval_request_context_item.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="EvalRequestContextItem")
+
+
+@_attrs_define
+class EvalRequestContextItem:
+    """ """
+
+    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)
+        eval_request_context_item = cls()
+
+        eval_request_context_item.additional_properties = d
+        return eval_request_context_item
+
+    @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/eval_result.py

@@ -0,0 +1,102 @@
+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.eval_scores import EvalScores
+    from ..models.eval_summary import EvalSummary
+
+
+T = TypeVar("T", bound="EvalResult")
+
+
+@_attrs_define
+class EvalResult:
+    """Complete evaluation result
+
+    Attributes:
+        scores (EvalScores | Unset): Scores organized by category
+        summary (EvalSummary | Unset): Aggregate statistics across all evaluators
+        duration_ms (int | Unset): Total evaluation duration in milliseconds
+    """
+
+    scores: EvalScores | Unset = UNSET
+    summary: EvalSummary | Unset = UNSET
+    duration_ms: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        scores: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.scores, Unset):
+            scores = self.scores.to_dict()
+
+        summary: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.summary, Unset):
+            summary = self.summary.to_dict()
+
+        duration_ms = self.duration_ms
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if scores is not UNSET:
+            field_dict["scores"] = scores
+        if summary is not UNSET:
+            field_dict["summary"] = summary
+        if duration_ms is not UNSET:
+            field_dict["duration_ms"] = duration_ms
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.eval_scores import EvalScores
+        from ..models.eval_summary import EvalSummary
+
+        d = dict(src_dict)
+        _scores = d.pop("scores", UNSET)
+        scores: EvalScores | Unset
+        if isinstance(_scores, Unset):
+            scores = UNSET
+        else:
+            scores = EvalScores.from_dict(_scores)
+
+        _summary = d.pop("summary", UNSET)
+        summary: EvalSummary | Unset
+        if isinstance(_summary, Unset):
+            summary = UNSET
+        else:
+            summary = EvalSummary.from_dict(_summary)
+
+        duration_ms = d.pop("duration_ms", UNSET)
+
+        eval_result = cls(
+            scores=scores,
+            summary=summary,
+            duration_ms=duration_ms,
+        )
+
+        eval_result.additional_properties = d
+        return eval_result
+
+    @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/eval_scores.py

@@ -0,0 +1,93 @@
+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.eval_scores_generation import EvalScoresGeneration
+    from ..models.eval_scores_retrieval import EvalScoresRetrieval
+
+
+T = TypeVar("T", bound="EvalScores")
+
+
+@_attrs_define
+class EvalScores:
+    """Scores organized by category
+
+    Attributes:
+        retrieval (EvalScoresRetrieval | Unset): Retrieval metric scores (recall, precision, ndcg, etc.)
+        generation (EvalScoresGeneration | Unset): Generation quality scores (faithfulness, relevance, etc.)
+    """
+
+    retrieval: EvalScoresRetrieval | Unset = UNSET
+    generation: EvalScoresGeneration | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        retrieval: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.retrieval, Unset):
+            retrieval = self.retrieval.to_dict()
+
+        generation: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.generation, Unset):
+            generation = self.generation.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if retrieval is not UNSET:
+            field_dict["retrieval"] = retrieval
+        if generation is not UNSET:
+            field_dict["generation"] = generation
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.eval_scores_generation import EvalScoresGeneration
+        from ..models.eval_scores_retrieval import EvalScoresRetrieval
+
+        d = dict(src_dict)
+        _retrieval = d.pop("retrieval", UNSET)
+        retrieval: EvalScoresRetrieval | Unset
+        if isinstance(_retrieval, Unset):
+            retrieval = UNSET
+        else:
+            retrieval = EvalScoresRetrieval.from_dict(_retrieval)
+
+        _generation = d.pop("generation", UNSET)
+        generation: EvalScoresGeneration | Unset
+        if isinstance(_generation, Unset):
+            generation = UNSET
+        else:
+            generation = EvalScoresGeneration.from_dict(_generation)
+
+        eval_scores = cls(
+            retrieval=retrieval,
+            generation=generation,
+        )
+
+        eval_scores.additional_properties = d
+        return eval_scores
+
+    @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/eval_scores_generation.py

@@ -0,0 +1,60 @@
+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.evaluator_score import EvaluatorScore
+
+
+T = TypeVar("T", bound="EvalScoresGeneration")
+
+
+@_attrs_define
+class EvalScoresGeneration:
+    """Generation quality scores (faithfulness, relevance, etc.)"""
+
+    additional_properties: dict[str, EvaluatorScore] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.evaluator_score import EvaluatorScore
+
+        d = dict(src_dict)
+        eval_scores_generation = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = EvaluatorScore.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        eval_scores_generation.additional_properties = additional_properties
+        return eval_scores_generation
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> EvaluatorScore:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: EvaluatorScore) -> 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