From 39819b9a17450dbd21fe05444864af5d59a6cf9d Mon Sep 17 00:00:00 2001 From: etserend Date: Mon, 20 Jul 2026 14:00:58 -0500 Subject: [PATCH 1/2] feat(annotation-queues): add annotation queue SDK support (HYBIM-882) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Port upstream commit e34a5b19 from rungalileo/galileo-python. - Add src/splunk_ao/annotation_queues.py — full AnnotationQueues SDK class with create/get/list/update/delete/share/query operations, AnnotationField management, and record add/remove/search support - Export all AnnotationQueue* symbols from splunk_ao/__init__.py - integration.py: switch from IntegrationName → IntegrationProvider, use provider_name from integration_db.provider field - project.py: remove stale created_by docstring references (server-managed) - provider.py: rename _get_integration_name → _get_integration_provider, add LLMIntegration import for models endpoint Note: query_annotation_queues_annotation_queues_query_post generated module is missing from resources/ — needs regen workflow run to produce it from the existing openapi.yaml definition. Upstream: https://github.com/rungalileo/galileo-python/commit/e34a5b19e0f01f8b3709d7de77b8a2b693f91059 Co-Authored-By: Claude Opus 4.7 --- src/splunk_ao/__init__.py | 44 ++ src/splunk_ao/annotation_queues.py | 1175 ++++++++++++++++++++++++++++ src/splunk_ao/integration.py | 20 +- src/splunk_ao/project.py | 12 +- src/splunk_ao/provider.py | 43 +- 5 files changed, 1257 insertions(+), 37 deletions(-) create mode 100644 src/splunk_ao/annotation_queues.py diff --git a/src/splunk_ao/__init__.py b/src/splunk_ao/__init__.py index 38b0611c..ee9adeac 100644 --- a/src/splunk_ao/__init__.py +++ b/src/splunk_ao/__init__.py @@ -16,6 +16,29 @@ from galileo_core.schemas.logging.step import StepType from galileo_core.schemas.logging.trace import Trace from splunk_ao.agent_control import AgentControlTarget, AgentControlTargetUnresolvedError, get_agent_control_target +from splunk_ao.annotation_queues import ( + AnnotationField, + AnnotationQueue, + AnnotationQueueRecordSelector, + AnnotationQueues, + AnnotationQueueUser, + add_records_to_annotation_queue, + create_annotation_queue, + create_annotation_queue_field, + delete_annotation_queue, + delete_annotation_queue_field, + get_annotation_queue, + get_annotation_queue_records, + list_annotation_queue_fields, + list_annotation_queue_users, + list_annotation_queues, + remove_annotation_queue_user, + remove_records_from_annotation_queue, + share_annotation_queue, + update_annotation_queue, + update_annotation_queue_field, + update_annotation_queue_user, +) from splunk_ao.collaborator import Collaborator, CollaboratorRole from splunk_ao.configuration import Configuration from splunk_ao.dataset import Dataset @@ -69,6 +92,11 @@ "AgentControlTargetUnresolvedError", "AgentSpan", "AmbiguousConfigurationError", + "AnnotationField", + "AnnotationQueue", + "AnnotationQueueRecordSelector", + "AnnotationQueueUser", + "AnnotationQueues", "AnthropicProvider", "AuthenticationError", "AzureProvider", @@ -129,15 +157,31 @@ "Trace", "ValidationError", "WorkflowSpan", + "add_records_to_annotation_queue", + "create_annotation_queue", + "create_annotation_queue_field", "create_api_key", + "delete_annotation_queue", + "delete_annotation_queue_field", "delete_api_key", "enable_console_logging", "get_agent_control_target", + "get_annotation_queue", + "get_annotation_queue_records", "get_tracing_headers", "is_dependency_available", + "list_annotation_queue_fields", + "list_annotation_queue_users", + "list_annotation_queues", "list_api_keys", "log", + "remove_annotation_queue_user", + "remove_records_from_annotation_queue", "setup_agent_control_bridge", + "share_annotation_queue", "splunk_ao_context", "start_session", + "update_annotation_queue", + "update_annotation_queue_field", + "update_annotation_queue_user", ] diff --git a/src/splunk_ao/annotation_queues.py b/src/splunk_ao/annotation_queues.py new file mode 100644 index 00000000..1ce628ce --- /dev/null +++ b/src/splunk_ao/annotation_queues.py @@ -0,0 +1,1175 @@ +from __future__ import annotations + +import builtins +import datetime +from typing import TypeAlias, TypeVar, cast, overload + +from splunk_ao.config import SplunkAOConfig +from splunk_ao.exceptions import NotFoundError +from splunk_ao.resources.api.annotation_queue import ( + create_annotation_queue_annotation_queues_post, + create_queue_template_annotation_queues_queue_id_templates_post, + delete_annotation_queue_annotation_queues_queue_id_delete, + delete_queue_template_annotation_queues_queue_id_templates_template_id_delete, + get_annotation_queue_annotation_queues_queue_id_get, + get_queue_templates_annotation_queues_queue_id_templates_get, + list_annotation_queue_users_annotation_queues_queue_id_users_get, + query_annotation_queues_annotation_queues_query_post, + remove_annotation_queue_user_annotation_queues_queue_id_users_user_id_delete, + share_annotation_queue_with_users_annotation_queues_queue_id_users_post, + update_annotation_queue_annotation_queues_queue_id_patch, + update_annotation_queue_user_role_annotation_queues_queue_id_users_user_id_patch, + update_queue_template_annotation_queues_queue_id_templates_template_id_patch, +) +from splunk_ao.resources.api.annotation_queue_records import ( + add_records_to_annotation_queue_annotation_queues_queue_id_records_post, + partial_search_annotation_queue_records_annotation_queues_queue_id_partial_search_post, + remove_records_from_annotation_queue_annotation_queues_queue_id_records_remove_post, +) +from splunk_ao.resources.models.add_records_to_queue_request import AddRecordsToQueueRequest +from splunk_ao.resources.models.add_records_to_queue_response import AddRecordsToQueueResponse +from splunk_ao.resources.models.and_node_log_records_filter import AndNodeLogRecordsFilter +from splunk_ao.resources.models.annotation_queue_name_filter import AnnotationQueueNameFilter +from splunk_ao.resources.models.annotation_queue_name_filter_operator import AnnotationQueueNameFilterOperator +from splunk_ao.resources.models.annotation_queue_partial_search_request import AnnotationQueuePartialSearchRequest +from splunk_ao.resources.models.annotation_queue_records_by_filter_tree import AnnotationQueueRecordsByFilterTree +from splunk_ao.resources.models.annotation_queue_records_by_record_i_ds import AnnotationQueueRecordsByRecordIDs +from splunk_ao.resources.models.annotation_queue_response import AnnotationQueueResponse +from splunk_ao.resources.models.annotation_queue_updated_at_sort import AnnotationQueueUpdatedAtSort +from splunk_ao.resources.models.annotation_queue_user_collaborator_create import AnnotationQueueUserCollaboratorCreate +from splunk_ao.resources.models.annotation_queue_user_collaborator_update import AnnotationQueueUserCollaboratorUpdate +from splunk_ao.resources.models.annotation_template_create import AnnotationTemplateCreate +from splunk_ao.resources.models.annotation_template_db import AnnotationTemplateDB +from splunk_ao.resources.models.annotation_template_update import AnnotationTemplateUpdate +from splunk_ao.resources.models.choice_constraints import ChoiceConstraints +from splunk_ao.resources.models.collaborator_role import CollaboratorRole +from splunk_ao.resources.models.create_annotation_queue_request import CreateAnnotationQueueRequest +from splunk_ao.resources.models.create_queue_template_request import CreateQueueTemplateRequest +from splunk_ao.resources.models.filter_leaf_log_records_filter import FilterLeafLogRecordsFilter +from splunk_ao.resources.models.http_validation_error import HTTPValidationError +from splunk_ao.resources.models.like_dislike_constraints import LikeDislikeConstraints +from splunk_ao.resources.models.list_annotation_queue_collaborators_response import ( + ListAnnotationQueueCollaboratorsResponse, +) +from splunk_ao.resources.models.list_annotation_queue_params import ListAnnotationQueueParams +from splunk_ao.resources.models.list_annotation_queue_response import ListAnnotationQueueResponse +from splunk_ao.resources.models.log_records_partial_query_response import LogRecordsPartialQueryResponse +from splunk_ao.resources.models.log_records_sort_clause import LogRecordsSortClause +from splunk_ao.resources.models.name import Name +from splunk_ao.resources.models.not_node_log_records_filter import NotNodeLogRecordsFilter +from splunk_ao.resources.models.or_node_log_records_filter import OrNodeLogRecordsFilter +from splunk_ao.resources.models.permission import Permission +from splunk_ao.resources.models.remove_records_from_queue_request import RemoveRecordsFromQueueRequest +from splunk_ao.resources.models.remove_records_from_queue_response import RemoveRecordsFromQueueResponse +from splunk_ao.resources.models.score_constraints import ScoreConstraints +from splunk_ao.resources.models.select_columns import SelectColumns +from splunk_ao.resources.models.star_constraints import StarConstraints +from splunk_ao.resources.models.tags_constraints import TagsConstraints +from splunk_ao.resources.models.text_constraints import TextConstraints +from splunk_ao.resources.models.tree_choice_constraints import TreeChoiceConstraints +from splunk_ao.resources.models.tree_choice_db_constraints import TreeChoiceDBConstraints +from splunk_ao.resources.models.update_annotation_queue_request import UpdateAnnotationQueueRequest +from splunk_ao.resources.models.user_annotation_queue_collaborator import UserAnnotationQueueCollaborator +from splunk_ao.resources.models.user_info import UserInfo +from splunk_ao.resources.types import UNSET, Unset +from splunk_ao.utils.exceptions import APIException + + +class AnnotationQueuesAPIException(APIException): + pass + + +AnnotationFieldConstraints: TypeAlias = ( + ChoiceConstraints + | LikeDislikeConstraints + | ScoreConstraints + | StarConstraints + | TagsConstraints + | TextConstraints + | TreeChoiceConstraints +) +_AnnotationFieldResponseConstraints: TypeAlias = AnnotationFieldConstraints | TreeChoiceDBConstraints +AnnotationQueueRecordSelector: TypeAlias = AnnotationQueueRecordsByRecordIDs | AnnotationQueueRecordsByFilterTree +AnnotationQueueRecordsFilter: TypeAlias = ( + AndNodeLogRecordsFilter | FilterLeafLogRecordsFilter | NotNodeLogRecordsFilter | OrNodeLogRecordsFilter +) +_ResponseT = TypeVar("_ResponseT") + + +class AnnotationField: + """Represents an annotation field in an annotation queue.""" + + id: str + name: str + include_explanation: bool + constraints: AnnotationFieldConstraints + created_at: datetime.datetime + created_by: str | None + position: int + usage_count: int + criteria: str | None | Unset + + def __init__(self, field: AnnotationTemplateDB) -> None: + self.id = field.id + self.name = field.name + self.include_explanation = field.include_explanation + self.constraints = _to_annotation_field_constraints(field.constraints) + self.created_at = field.created_at + self.created_by = field.created_by + self.position = field.position + self.usage_count = field.usage_count + self.criteria = field.criteria + + +class AnnotationQueueUser: + """Represents a user with access to an annotation queue.""" + + id: str + user_id: str + annotation_queue_id: str + role: CollaboratorRole + created_at: datetime.datetime + first_name: str | None + last_name: str | None + email: str + permissions: Unset | list[Permission] + track_progress: Unset | bool + progress: None | Unset | float + + def __init__(self, collaborator: UserAnnotationQueueCollaborator) -> None: + self.id = collaborator.id + self.user_id = collaborator.user_id + self.annotation_queue_id = collaborator.annotation_queue_id + self.role = collaborator.role + self.created_at = collaborator.created_at + self.first_name = collaborator.first_name + self.last_name = collaborator.last_name + self.email = collaborator.email + self.permissions = collaborator.permissions + self.track_progress = collaborator.track_progress + self.progress = collaborator.progress + + +class AnnotationQueue: + """ + Represents an annotation queue in the Galileo platform. + + Annotation queues are organization-level resources used to assign log records + to annotators and track annotation progress. + """ + + id: str + name: str + description: str | None + created_at: datetime.datetime + updated_at: datetime.datetime + created_by_user: UserInfo | None + permissions: Unset | list[Permission] + num_log_records: Unset | int + num_annotators: Unset | int + num_users: Unset | int + num_fields: Unset | int + overall_progress: None | Unset | float + fields: Unset | list[AnnotationField] + + def __init__(self, queue: AnnotationQueueResponse) -> None: + self.id = queue.id + self.name = queue.name + self.description = queue.description + self.created_at = queue.created_at + self.updated_at = queue.updated_at + self.created_by_user = queue.created_by_user + self.permissions = queue.permissions + self.num_log_records = queue.num_log_records + self.num_annotators = queue.num_annotators + self.num_users = queue.num_users + self.num_fields = queue.num_templates + self.overall_progress = queue.overall_progress + self.fields = ( + UNSET if isinstance(queue.templates, Unset) else [AnnotationField(field=field) for field in queue.templates] + ) + + +class AnnotationQueues: + config: SplunkAOConfig + + def __init__(self) -> None: + self.config = SplunkAOConfig.get() + + def list(self, limit: Unset | int = 100) -> list[AnnotationQueue]: + """ + List annotation queues. + + Parameters + ---------- + limit : Union[Unset, int] + The maximum number of annotation queues to request per page. Default is 100. + + Returns + ------- + list[AnnotationQueue] + A list of annotation queues. + """ + queues: builtins.list[AnnotationQueue] = [] + starting_token: int | None = 0 + + while starting_token is not None: + response = query_annotation_queues_annotation_queues_query_post.sync( + client=self.config.api_client, + body=ListAnnotationQueueParams(), + starting_token=starting_token, + limit=limit, + ) + list_response = _to_annotation_queue_list(response) + queues.extend(AnnotationQueue(queue=queue) for queue in list_response.annotation_queues) + + starting_token = _next_starting_token( + paginated=list_response.paginated, + next_starting_token=list_response.next_starting_token, + current_starting_token=starting_token, + ) + + return queues + + def list_users(self, queue_id: str) -> builtins.list[AnnotationQueueUser]: + """ + List users who have access to an annotation queue. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + + Returns + ------- + list[AnnotationQueueUser] + A list of annotation queue users. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + users: builtins.list[AnnotationQueueUser] = [] + starting_token: int | None = 0 + + while starting_token is not None: + response = list_annotation_queue_users_annotation_queues_queue_id_users_get.sync( + queue_id=queue_id, client=self.config.api_client, starting_token=starting_token + ) + list_response = _to_annotation_queue_user_list(response) + users.extend(AnnotationQueueUser(collaborator=collaborator) for collaborator in list_response.collaborators) + + starting_token = _next_starting_token( + paginated=list_response.paginated, + next_starting_token=list_response.next_starting_token, + current_starting_token=starting_token, + ) + + return users + + def list_fields(self, queue_id: str) -> builtins.list[AnnotationField]: + """ + List fields for an annotation queue. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + + Returns + ------- + list[AnnotationField] + A list of annotation fields. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + response = get_queue_templates_annotation_queues_queue_id_templates_get.sync( + queue_id=queue_id, client=self.config.api_client + ) + return _to_annotation_field_list(response, "list") + + @overload + def get(self, *, id: str) -> AnnotationQueue | None: ... + + @overload + def get(self, *, name: str) -> AnnotationQueue | None: ... + + def get(self, *, id: str | None = None, name: str | None = None) -> AnnotationQueue | None: + """ + Retrieves an annotation queue by id or name. + + Exactly one of `id` or `name` must be provided. + + Parameters + ---------- + id : str + The id of the annotation queue. + name : str + The name of the annotation queue. + + Returns + ------- + AnnotationQueue | None + The annotation queue, or None if the API returns no matching queue. + """ + if (id is None) == (name is None): + raise ValueError("Exactly one of 'id' or 'name' must be provided") + + if id is not None: + id = id.strip() + if not id: + raise ValueError("'id' must be provided.") + + try: + response = get_annotation_queue_annotation_queues_queue_id_get.sync( + queue_id=id, client=self.config.api_client + ) + except NotFoundError: + return None + if response is None: + return None + return _to_annotation_queue(response, "get") + + assert name is not None + name = name.strip() + if not name: + raise ValueError("'name' must be provided.") + + filter = AnnotationQueueNameFilter(operator=AnnotationQueueNameFilterOperator.EQ, value=name) + params = ListAnnotationQueueParams(filters=[filter], sort=AnnotationQueueUpdatedAtSort(ascending=False)) + response = query_annotation_queues_annotation_queues_query_post.sync( + client=self.config.api_client, body=params, limit=1 + ) + list_response = _to_annotation_queue_list(response) + if not list_response.annotation_queues: + return None + + return AnnotationQueue(queue=list_response.annotation_queues[0]) + + def create( + self, + name: str, + description: str | None = None, + annotator_emails: builtins.list[str] | None = None, + copy_fields_from_queue_id: str | None = None, + ) -> AnnotationQueue: + """ + Create an annotation queue. + + Parameters + ---------- + name : str + The name of the annotation queue. + description : str | None + Optional annotation queue description. + annotator_emails : list[str] | None + Optional annotator emails to invite or assign. + copy_fields_from_queue_id : str | None + Optional annotation queue ID to copy fields from. + + Returns + ------- + AnnotationQueue + The created annotation queue. + """ + name = name.strip() + if not name: + raise ValueError("'name' must be provided.") + + body = CreateAnnotationQueueRequest( + name=Name(value=name), + description=description if description is not None else UNSET, + annotator_emails=annotator_emails if annotator_emails is not None else UNSET, + copy_templates_from_queue_id=copy_fields_from_queue_id if copy_fields_from_queue_id is not None else UNSET, + ) + + response = create_annotation_queue_annotation_queues_post.sync(client=self.config.api_client, body=body) + return _to_annotation_queue(response, "create") + + def add_records( + self, + queue_id: str, + *, + project_id: str, + log_stream_id: str | None = None, + experiment_id: str | None = None, + record_ids: builtins.list[str] | None = None, + record_selector: AnnotationQueueRecordSelector | None = None, + ) -> int: + """ + Add records to an annotation queue. + + Exactly one of `record_ids` or `record_selector` must be provided. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + project_id : str + The ID of the project containing the records. + log_stream_id : str | None + The ID of the log stream containing the records. + experiment_id : str | None + The ID of the experiment containing the records. + record_ids : list[str] | None + Optional list of record IDs to add. + record_selector : AnnotationQueueRecordSelector | None + Optional generated selector for adding records by record IDs or filter tree. + + Returns + ------- + int + The number of records added to the queue. + """ + queue_id = _validate_required_string("queue_id", queue_id) + project_id = _validate_required_string("project_id", project_id) + run_id = _to_annotation_queue_run_id(log_stream_id=log_stream_id, experiment_id=experiment_id) + selector = _to_annotation_queue_record_selector(record_ids=record_ids, record_selector=record_selector) + + body = AddRecordsToQueueRequest(project_id=project_id, run_id=run_id, record_selector=selector) + response = add_records_to_annotation_queue_annotation_queues_queue_id_records_post.sync( + queue_id=queue_id, client=self.config.api_client, body=body + ) + return _to_add_records_response(response) + + def remove_records( + self, + queue_id: str, + *, + record_ids: builtins.list[str] | None = None, + record_selector: AnnotationQueueRecordSelector | None = None, + ) -> int: + """ + Remove records from an annotation queue. + + Exactly one of `record_ids` or `record_selector` must be provided. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + record_ids : list[str] | None + Optional list of record IDs to remove. + record_selector : AnnotationQueueRecordSelector | None + Optional generated selector for removing records by record IDs or filter tree. + + Returns + ------- + int + The number of records removed from the queue. + """ + queue_id = _validate_required_string("queue_id", queue_id) + selector = _to_annotation_queue_record_selector(record_ids=record_ids, record_selector=record_selector) + + body = RemoveRecordsFromQueueRequest(record_selector=selector) + response = remove_records_from_annotation_queue_annotation_queues_queue_id_records_remove_post.sync( + queue_id=queue_id, client=self.config.api_client, body=body + ) + return _to_remove_records_response(response) + + def get_records( + self, + queue_id: str, + *, + starting_token: Unset | int = 0, + limit: Unset | int = 100, + previous_last_row_id: None | Unset | str = UNSET, + filter_tree: AnnotationQueueRecordsFilter | None | Unset = UNSET, + sort: LogRecordsSortClause | None | Unset = UNSET, + ) -> LogRecordsPartialQueryResponse: + """ + Get records from an annotation queue. + + This uses the queue-scoped partial search endpoint. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + starting_token : Union[Unset, int] + The page starting token. Default is 0. + limit : Union[Unset, int] + The maximum number of records to return. Default is 100. + previous_last_row_id : Union[None, Unset, str] + Cursor value from the previous page. + filter_tree : Union[AnnotationQueueRecordsFilter, None, Unset] + Optional filter tree to apply to queue records. + sort : Union[LogRecordsSortClause, None, Unset] + Optional sort clause. + + Returns + ------- + LogRecordsPartialQueryResponse + The matching records and pagination metadata. + """ + queue_id = _validate_required_string("queue_id", queue_id) + body = AnnotationQueuePartialSearchRequest( + select_columns=SelectColumns( + column_ids=["id", "input", "output"], include_all_metrics=True, include_all_feedback=True + ), + starting_token=starting_token, + limit=limit, + previous_last_row_id=previous_last_row_id, + filter_tree=filter_tree, + sort=sort, + ) + response = partial_search_annotation_queue_records_annotation_queues_queue_id_partial_search_post.sync( + queue_id=queue_id, client=self.config.api_client, body=body + ) + return _to_annotation_queue_records_response(response) + + def share( + self, + queue_id: str, + *, + user_id: str | None = None, + user_email: str | None = None, + role: CollaboratorRole = CollaboratorRole.ANNOTATOR, + track_progress: bool = True, + ) -> AnnotationQueueUser: + """ + Share an annotation queue with a user. + + Exactly one of `user_id` or `user_email` must be provided. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + user_id : str | None + The ID of the user to share with. + user_email : str | None + The email of the user to share with. + role : CollaboratorRole + The role to grant. Default is CollaboratorRole.ANNOTATOR. + track_progress : bool + Whether to track annotation progress for the user. + + Returns + ------- + AnnotationQueueUser + The created annotation queue user. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + if (user_id is None) == (user_email is None): + raise ValueError("Exactly one of 'user_id' or 'user_email' must be provided") + + if user_id is not None: + user_id = user_id.strip() + if not user_id: + raise ValueError("'user_id' must be provided.") + + if user_email is not None: + user_email = user_email.strip() + if not user_email: + raise ValueError("'user_email' must be provided.") + + body = [ + AnnotationQueueUserCollaboratorCreate( + user_id=user_id if user_id is not None else UNSET, + user_email=user_email if user_email is not None else UNSET, + role=role, + track_progress=track_progress, + ) + ] + response = share_annotation_queue_with_users_annotation_queues_queue_id_users_post.sync( + queue_id=queue_id, client=self.config.api_client, body=body + ) + return _to_annotation_queue_user_create_response(response) + + def create_field( + self, + queue_id: str, + *, + name: str, + constraints: AnnotationFieldConstraints, + include_explanation: bool = False, + criteria: str | None | Unset = UNSET, + ) -> AnnotationField: + """ + Create a field in an annotation queue. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + name : str + The name of the annotation field. + constraints : AnnotationFieldConstraints + The annotation field constraints. + include_explanation : bool + Whether annotators should include explanations. + criteria : str | None | Unset + Optional annotation criteria. Pass None to clear it; omit to leave unset. + + Returns + ------- + AnnotationField + The created annotation field. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + name = name.strip() + if not name: + raise ValueError("'name' must be provided.") + + body = CreateQueueTemplateRequest( + template=AnnotationTemplateCreate( + name=name, constraints=constraints, include_explanation=include_explanation, criteria=criteria + ) + ) + response = create_queue_template_annotation_queues_queue_id_templates_post.sync( + queue_id=queue_id, client=self.config.api_client, body=body + ) + return _to_annotation_field_create_response(response, name=name) + + def update(self, id: str, *, name: str | None = None, description: str | None | Unset = UNSET) -> AnnotationQueue: + """ + Update an annotation queue. + + Parameters + ---------- + id : str + The ID of the annotation queue. + name : str | None + Optional new queue name. Omit to leave unchanged. + description : str | None | Unset + Optional new description. Pass None to clear it; omit to leave unchanged. + + Returns + ------- + AnnotationQueue + The updated annotation queue. + """ + id = id.strip() + if not id: + raise ValueError("'id' must be provided.") + + name_value: Name | None | Unset + if name is None: + name_value = UNSET + else: + name = name.strip() + if not name: + raise ValueError("'name' must not be empty.") + name_value = Name(value=name) + + if isinstance(name_value, Unset) and isinstance(description, Unset): + raise ValueError("At least one of 'name' or 'description' must be provided.") + + body = UpdateAnnotationQueueRequest(name=name_value, description=description) + response = update_annotation_queue_annotation_queues_queue_id_patch.sync( + queue_id=id, client=self.config.api_client, body=body + ) + return _to_annotation_queue(response, "update") + + def update_user( + self, queue_id: str, user_id: str, *, role: CollaboratorRole, track_progress: bool | None | Unset = UNSET + ) -> AnnotationQueueUser: + """ + Update a user's role for an annotation queue. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + user_id : str + The ID of the user. + role : CollaboratorRole + The new role for the user. + track_progress : bool | None | Unset + Optional progress tracking value. + + Returns + ------- + AnnotationQueueUser + The updated annotation queue user. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + user_id = user_id.strip() + if not user_id: + raise ValueError("'user_id' must be provided.") + + body = AnnotationQueueUserCollaboratorUpdate(role=role, track_progress=track_progress) + response = update_annotation_queue_user_role_annotation_queues_queue_id_users_user_id_patch.sync( + queue_id=queue_id, user_id=user_id, client=self.config.api_client, body=body + ) + return _to_annotation_queue_user(response, "update") + + def update_field(self, queue_id: str, field_id: str, *, name: str, criteria: str | None) -> AnnotationField: + """ + Update a field in an annotation queue. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + field_id : str + The ID of the annotation field. + name : str + The new name for the annotation field. + criteria : str | None + The new criteria for the annotation field. + + Returns + ------- + AnnotationField + The updated annotation field. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + field_id = field_id.strip() + if not field_id: + raise ValueError("'field_id' must be provided.") + + name = name.strip() + if not name: + raise ValueError("'name' must be provided.") + + body = AnnotationTemplateUpdate(name=name, criteria=criteria) + response = update_queue_template_annotation_queues_queue_id_templates_template_id_patch.sync( + queue_id=queue_id, template_id=field_id, client=self.config.api_client, body=body + ) + return _to_annotation_field(response, "update") + + @overload + def delete(self, *, id: str) -> None: ... + + @overload + def delete(self, *, name: str) -> None: ... + + def delete(self, *, id: str | None = None, name: str | None = None) -> None: + """ + Delete an annotation queue by id or name. + + Parameters + ---------- + id : str + The ID of the annotation queue. + name : str + The name of the annotation queue. + """ + if (id is None) == (name is None): + raise ValueError("Exactly one of 'id' or 'name' must be provided") + + queue_id: str + if id is not None: + queue_id = _validate_required_string("id", id) + else: + assert name is not None + queue = self.get(name=name) + if not queue: + queue_identifier = name.strip() + raise NotFoundError(f"Annotation queue {queue_identifier} not found") + queue_id = queue.id + + response = delete_annotation_queue_annotation_queues_queue_id_delete.sync( + queue_id=queue_id, client=self.config.api_client + ) + _require_response(response, "Failed to delete annotation queue") + return + + def remove_user(self, queue_id: str, user_id: str) -> None: + """ + Remove a user's access to an annotation queue. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + user_id : str + The ID of the user to remove. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + user_id = user_id.strip() + if not user_id: + raise ValueError("'user_id' must be provided.") + + response = remove_annotation_queue_user_annotation_queues_queue_id_users_user_id_delete.sync( + queue_id=queue_id, user_id=user_id, client=self.config.api_client + ) + _require_response(response, "Failed to remove annotation queue user") + return + + def delete_field(self, queue_id: str, field_id: str) -> None: + """ + Delete a field from an annotation queue. + + Parameters + ---------- + queue_id : str + The ID of the annotation queue. + field_id : str + The ID of the annotation field. + """ + queue_id = queue_id.strip() + if not queue_id: + raise ValueError("'queue_id' must be provided.") + + field_id = field_id.strip() + if not field_id: + raise ValueError("'field_id' must be provided.") + + response = delete_queue_template_annotation_queues_queue_id_templates_template_id_delete.sync( + queue_id=queue_id, template_id=field_id, client=self.config.api_client + ) + _require_response(response, "Failed to delete annotation queue field") + return + + +def create_annotation_queue( + name: str, + description: str | None = None, + annotator_emails: list[str] | None = None, + copy_fields_from_queue_id: str | None = None, +) -> AnnotationQueue: + """Create an annotation queue.""" + queues = AnnotationQueues() + return queues.create( + name=name, + description=description, + annotator_emails=annotator_emails, + copy_fields_from_queue_id=copy_fields_from_queue_id, + ) + + +def create_annotation_queue_field( + queue_id: str, + *, + name: str, + constraints: AnnotationFieldConstraints, + include_explanation: bool = False, + criteria: str | None | Unset = UNSET, +) -> AnnotationField: + """Create a field in an annotation queue.""" + queues = AnnotationQueues() + return queues.create_field( + queue_id=queue_id, + name=name, + constraints=constraints, + include_explanation=include_explanation, + criteria=criteria, + ) + + +def share_annotation_queue( + queue_id: str, + *, + user_id: str | None = None, + user_email: str | None = None, + role: CollaboratorRole = CollaboratorRole.ANNOTATOR, + track_progress: bool = True, +) -> AnnotationQueueUser: + """Share an annotation queue with a user.""" + queues = AnnotationQueues() + return queues.share( + queue_id=queue_id, user_id=user_id, user_email=user_email, role=role, track_progress=track_progress + ) + + +def add_records_to_annotation_queue( + queue_id: str, + *, + project_id: str, + log_stream_id: str | None = None, + experiment_id: str | None = None, + record_ids: list[str] | None = None, + record_selector: AnnotationQueueRecordSelector | None = None, +) -> int: + """Add records to an annotation queue.""" + queues = AnnotationQueues() + return queues.add_records( + queue_id=queue_id, + project_id=project_id, + log_stream_id=log_stream_id, + experiment_id=experiment_id, + record_ids=record_ids, + record_selector=record_selector, + ) + + +def remove_records_from_annotation_queue( + queue_id: str, *, record_ids: list[str] | None = None, record_selector: AnnotationQueueRecordSelector | None = None +) -> int: + """Remove records from an annotation queue.""" + queues = AnnotationQueues() + return queues.remove_records(queue_id=queue_id, record_ids=record_ids, record_selector=record_selector) + + +def get_annotation_queue_records( + queue_id: str, + *, + starting_token: Unset | int = 0, + limit: Unset | int = 100, + previous_last_row_id: None | Unset | str = UNSET, + filter_tree: AnnotationQueueRecordsFilter | None | Unset = UNSET, + sort: LogRecordsSortClause | None | Unset = UNSET, +) -> LogRecordsPartialQueryResponse: + """Get records from an annotation queue.""" + queues = AnnotationQueues() + return queues.get_records( + queue_id=queue_id, + starting_token=starting_token, + limit=limit, + previous_last_row_id=previous_last_row_id, + filter_tree=filter_tree, + sort=sort, + ) + + +@overload +def get_annotation_queue(*, id: str) -> AnnotationQueue | None: ... + + +@overload +def get_annotation_queue(*, name: str) -> AnnotationQueue | None: ... + + +def get_annotation_queue(*, id: str | None = None, name: str | None = None) -> AnnotationQueue | None: + """Retrieve an annotation queue by id or name.""" + queues = AnnotationQueues() + return queues.get(id=id, name=name) # type: ignore[call-overload] + + +def list_annotation_queues(limit: Unset | int = 100) -> list[AnnotationQueue]: + """List annotation queues.""" + queues = AnnotationQueues() + return queues.list(limit=limit) + + +def list_annotation_queue_users(queue_id: str) -> list[AnnotationQueueUser]: + """List users who have access to an annotation queue.""" + queues = AnnotationQueues() + return queues.list_users(queue_id=queue_id) + + +def list_annotation_queue_fields(queue_id: str) -> list[AnnotationField]: + """List fields for an annotation queue.""" + queues = AnnotationQueues() + return queues.list_fields(queue_id=queue_id) + + +def update_annotation_queue( + id: str, *, name: str | None = None, description: str | None | Unset = UNSET +) -> AnnotationQueue: + """Update an annotation queue.""" + queues = AnnotationQueues() + return queues.update(id=id, name=name, description=description) + + +def update_annotation_queue_user( + queue_id: str, user_id: str, *, role: CollaboratorRole, track_progress: bool | None | Unset = UNSET +) -> AnnotationQueueUser: + """Update a user's role for an annotation queue.""" + queues = AnnotationQueues() + return queues.update_user(queue_id=queue_id, user_id=user_id, role=role, track_progress=track_progress) + + +def update_annotation_queue_field(queue_id: str, field_id: str, *, name: str, criteria: str | None) -> AnnotationField: + """Update a field in an annotation queue.""" + queues = AnnotationQueues() + return queues.update_field(queue_id=queue_id, field_id=field_id, name=name, criteria=criteria) + + +@overload +def delete_annotation_queue(*, id: str) -> None: ... + + +@overload +def delete_annotation_queue(*, name: str) -> None: ... + + +def delete_annotation_queue(*, id: str | None = None, name: str | None = None) -> None: + """Delete an annotation queue by id or name.""" + queues = AnnotationQueues() + return queues.delete(id=id, name=name) # type: ignore[call-overload] + + +def remove_annotation_queue_user(queue_id: str, user_id: str) -> None: + """Remove a user's access to an annotation queue.""" + queues = AnnotationQueues() + return queues.remove_user(queue_id=queue_id, user_id=user_id) + + +def delete_annotation_queue_field(queue_id: str, field_id: str) -> None: + """Delete a field from an annotation queue.""" + queues = AnnotationQueues() + return queues.delete_field(queue_id=queue_id, field_id=field_id) + + +def _to_annotation_queue( + response: AnnotationQueueResponse | HTTPValidationError | None, operation: str +) -> AnnotationQueue: + response = _require_response(response, f"Failed to {operation} annotation queue") + return AnnotationQueue(queue=response) + + +def _to_annotation_queue_list( + response: ListAnnotationQueueResponse | HTTPValidationError | None, +) -> ListAnnotationQueueResponse: + if isinstance(response, HTTPValidationError): + raise AnnotationQueuesAPIException(f"Failed to list annotation queues: {_format_validation_error(response)}") + if response is None: + return ListAnnotationQueueResponse(annotation_queues=[]) + return response + + +def _to_annotation_queue_user_list( + response: ListAnnotationQueueCollaboratorsResponse | HTTPValidationError | None, +) -> ListAnnotationQueueCollaboratorsResponse: + if isinstance(response, HTTPValidationError): + raise AnnotationQueuesAPIException( + f"Failed to list annotation queue users: {_format_validation_error(response)}" + ) + if response is None: + return ListAnnotationQueueCollaboratorsResponse(collaborators=[]) + return response + + +def _next_starting_token( + *, paginated: Unset | bool, next_starting_token: None | Unset | int, current_starting_token: int +) -> int | None: + if isinstance(next_starting_token, int) and next_starting_token > current_starting_token: + return next_starting_token + return None + + +def _validate_required_string(field_name: str, value: str) -> str: + value = value.strip() + if not value: + raise ValueError(f"'{field_name}' must be provided.") + return value + + +def _to_annotation_queue_run_id(*, log_stream_id: str | None, experiment_id: str | None) -> str: + if (log_stream_id is None) == (experiment_id is None): + raise ValueError("Exactly one of 'log_stream_id' or 'experiment_id' must be provided") + + if log_stream_id is not None: + return _validate_required_string("log_stream_id", log_stream_id) + + assert experiment_id is not None + return _validate_required_string("experiment_id", experiment_id) + + +def _to_annotation_queue_record_selector( + *, record_ids: list[str] | None, record_selector: AnnotationQueueRecordSelector | None +) -> AnnotationQueueRecordSelector: + if (record_ids is None) == (record_selector is None): + raise ValueError("Exactly one of 'record_ids' or 'record_selector' must be provided") + + if record_selector is not None: + return record_selector + + assert record_ids is not None + clean_record_ids = [record_id.strip() for record_id in record_ids] + if not clean_record_ids or any(not record_id for record_id in clean_record_ids): + raise ValueError("'record_ids' must contain at least one non-empty record ID.") + + return AnnotationQueueRecordsByRecordIDs(record_ids=clean_record_ids) + + +def _to_add_records_response(response: AddRecordsToQueueResponse | HTTPValidationError | None) -> int: + response = _require_response(response, "Failed to add records to annotation queue") + return response.num_records_added + + +def _to_remove_records_response(response: RemoveRecordsFromQueueResponse | HTTPValidationError | None) -> int: + response = _require_response(response, "Failed to remove records from annotation queue") + return response.num_records_removed + + +def _to_annotation_queue_records_response( + response: LogRecordsPartialQueryResponse | HTTPValidationError | None, +) -> LogRecordsPartialQueryResponse: + return _require_response(response, "Failed to get annotation queue records") + + +def _to_annotation_queue_user_create_response( + response: list[UserAnnotationQueueCollaborator] | HTTPValidationError | None, +) -> AnnotationQueueUser: + response = _require_response(response, "Failed to share annotation queue") + if not response: + raise AnnotationQueuesAPIException("Failed to share annotation queue: no response") + return AnnotationQueueUser(collaborator=response[0]) + + +def _to_annotation_queue_user( + response: UserAnnotationQueueCollaborator | HTTPValidationError | None, operation: str +) -> AnnotationQueueUser: + response = _require_response(response, f"Failed to {operation} annotation queue user") + return AnnotationQueueUser(collaborator=response) + + +def _to_annotation_field_create_response( + response: list[AnnotationTemplateDB] | HTTPValidationError | None, *, name: str +) -> AnnotationField: + response = _require_response(response, "Failed to create annotation queue field") + if not response: + raise AnnotationQueuesAPIException("Failed to create annotation queue field: no response") + for field in response: + if field.name == name: + return AnnotationField(field=field) + raise AnnotationQueuesAPIException(f"Failed to create annotation queue field: created field {name!r} not found") + + +def _to_annotation_field_list( + response: list[AnnotationTemplateDB] | HTTPValidationError | None, operation: str +) -> list[AnnotationField]: + if isinstance(response, HTTPValidationError): + raise AnnotationQueuesAPIException( + f"Failed to {operation} annotation queue fields: {_format_validation_error(response)}" + ) + if response is None: + return [] + return [AnnotationField(field=field) for field in response] + + +def _to_annotation_field( + response: AnnotationTemplateDB | HTTPValidationError | None, operation: str +) -> AnnotationField: + response = _require_response(response, f"Failed to {operation} annotation queue field") + return AnnotationField(field=response) + + +def _to_annotation_field_constraints(constraints: _AnnotationFieldResponseConstraints) -> AnnotationFieldConstraints: + if isinstance(constraints, TreeChoiceDBConstraints): + return TreeChoiceConstraints( + annotation_type=constraints.annotation_type, + choices_tree=constraints.choices_tree, + choices_tree_yaml=constraints.choices_tree_yaml, + ) + return cast(AnnotationFieldConstraints, constraints) + + +def _format_validation_error(error: HTTPValidationError) -> str: + if isinstance(error.detail, Unset): + return "validation error" + + messages = [detail.msg for detail in error.detail if detail.msg] + if not messages: + return "validation error" + return "; ".join(cast(list[str], messages)) + + +def _require_response(response: _ResponseT | HTTPValidationError | None, failure_message: str) -> _ResponseT: + if isinstance(response, HTTPValidationError): + raise AnnotationQueuesAPIException(f"{failure_message}: {_format_validation_error(response)}") + if response is None: + raise AnnotationQueuesAPIException(f"{failure_message}: no response") + return response diff --git a/src/splunk_ao/integration.py b/src/splunk_ao/integration.py index 7ec809a1..807d2781 100644 --- a/src/splunk_ao/integration.py +++ b/src/splunk_ao/integration.py @@ -319,30 +319,30 @@ def _to_provider(cls, integration_db: IntegrationDB) -> Provider: Provider: A provider-specific instance (OpenAIProvider, AzureProvider, etc.). For unsupported integration types, returns a GenericProvider. """ - name = str(integration_db.name) + provider_name = integration_db.provider - # Create appropriate provider instance based on name using __new__ to bypass __init__ + # Create appropriate provider instance based on provider using __new__ to bypass __init__ provider: Provider - if name == IntegrationProvider.OPENAI: + if provider_name == IntegrationProvider.OPENAI: provider = OpenAIProvider.__new__(OpenAIProvider) - elif name == IntegrationProvider.AZURE: + elif provider_name == IntegrationProvider.AZURE: provider = AzureProvider.__new__(AzureProvider) - elif name == IntegrationProvider.AWS_BEDROCK: + elif provider_name == IntegrationProvider.AWS_BEDROCK: provider = BedrockProvider.__new__(BedrockProvider) - elif name == IntegrationProvider.ANTHROPIC: + elif provider_name == IntegrationProvider.ANTHROPIC: provider = AnthropicProvider.__new__(AnthropicProvider) else: # For unsupported providers, use GenericProvider provider = GenericProvider.__new__(GenericProvider) - # Store the integration name enum for _get_integration_name() - provider._integration_name = integration_db.name + # Store the integration provider enum for _get_integration_provider() + provider._integration_provider = provider_name # Initialize the StateManagementMixin parent class StateManagementMixin.__init__(provider) # Populate provider attributes from IntegrationDB provider.id = str(integration_db.id) - provider.name = name + provider.name = str(integration_db.name) provider.created_at = integration_db.created_at provider.updated_at = integration_db.updated_at provider.created_by = integration_db.created_by @@ -384,7 +384,7 @@ def _get_integration_by_name(cls, integration_name: str) -> Provider | Unconfigu # Cast is safe because we checked for strings above providers = cast(list[Provider], providers_list) - matching = [p for p in providers if p.name == integration_name] + matching = [p for p in providers if p._get_integration_provider().value == integration_name] if not matching: logger.debug(f"Integration.{integration_name}: No '{integration_name}' integration configured.") diff --git a/src/splunk_ao/project.py b/src/splunk_ao/project.py index 05ca34dd..2acb53f7 100644 --- a/src/splunk_ao/project.py +++ b/src/splunk_ao/project.py @@ -792,15 +792,14 @@ def save(self) -> Project: """ Save changes to this project. - Persists any local changes (name, type) to the remote API. If the project + Persists any local changes to the remote API. If the project is LOCAL_ONLY, delegates to create(). If SYNCED, returns immediately as a no-op. Raises ValueError for DELETED or FAILED_SYNC states. .. note:: - ``ProjectUpdate`` also supports ``description``, ``labels``, and ``created_by``, - but these are not exposed as tracked attributes on the domain object because the - read endpoints (get/list) do not return them consistently. ``created_by`` is - server-managed. + ``ProjectUpdate`` also supports ``description`` and ``labels``, but these + are not exposed as tracked attributes on the domain object because the read + endpoints (get/list) do not return them consistently. If the project is in FAILED_SYNC state (from a prior failed operation), this method raises ValueError. Call :meth:`refresh` first to re-sync, then retry. @@ -843,11 +842,10 @@ def save(self) -> Project: logger.info(f"Project.save: name='{self.name}' id='{self.id}' - started") config = SplunkAOConfig.get() - # ProjectUpdate also accepts `description`, `labels`, and `created_by`, but: + # ProjectUpdate also accepts `description` and `labels`, but: # - `description`/`labels`: not exposed on the domain object because neither the # get (ProjectDBThin) nor list endpoints return them, so round-tripping would # leave the object stale. Expand when read endpoints return these fields. - # - `created_by`: server-managed, not a user-modifiable field. body = ProjectUpdate(name=self.name) try: diff --git a/src/splunk_ao/provider.py b/src/splunk_ao/provider.py index c37784b8..2d787864 100644 --- a/src/splunk_ao/provider.py +++ b/src/splunk_ao/provider.py @@ -21,6 +21,7 @@ BaseAwsIntegrationCreate, HTTPValidationError, IntegrationProvider, + LLMIntegration, OpenAIIntegrationCreate, ) from splunk_ao.resources.types import Unset @@ -83,7 +84,7 @@ def __repr__(self) -> str: return f"{self.__class__.__name__}(name='{self.name}', id='{self.id}', is_selected={self.is_selected})" @abstractmethod - def _get_integration_name(self) -> IntegrationProvider: + def _get_integration_provider(self) -> IntegrationProvider: """Get the IntegrationProvider enum for this provider.""" raise NotImplementedError @@ -105,10 +106,10 @@ def refresh(self) -> None: try: config = SplunkAOConfig.get() - integration_name = self._get_integration_name() + integration_provider = self._get_integration_provider() # Get the specific integration data - response = get_integration_integrations_name_get.sync(name=integration_name, client=config.api_client) + response = get_integration_integrations_name_get.sync(name=integration_provider, client=config.api_client) if response is None or isinstance(response, HTTPValidationError): api_error = APIError(f"Provider with ID {self.id} not found") @@ -165,9 +166,11 @@ def delete(self) -> None: try: config = SplunkAOConfig.get() - integration_name = self._get_integration_name() + integration_provider = self._get_integration_provider() - result = delete_integration_integrations_name_delete.sync(name=integration_name, client=config.api_client) + result = delete_integration_integrations_name_delete.sync( + name=integration_provider, client=config.api_client + ) if isinstance(result, HTTPValidationError): raise APIError(f"Failed to delete provider: {result.detail}") @@ -204,11 +207,11 @@ def models(self) -> list[Model]: try: config = SplunkAOConfig.get() - integration_name = self._get_integration_name() + integration_provider = self._get_integration_provider() # Get models from API response = get_available_models_llm_integrations_llm_integration_models_get.sync( - llm_integration=integration_name, client=config.api_client + llm_integration=LLMIntegration(integration_provider.value), client=config.api_client ) if response is None or isinstance(response, HTTPValidationError): @@ -312,7 +315,7 @@ def __init__(self, *, token: str, organization_id: str | None = None) -> None: self._temp_token = token self._temp_organization_id = organization_id - def _get_integration_name(self) -> IntegrationProvider: + def _get_integration_provider(self) -> IntegrationProvider: return IntegrationProvider.OPENAI def create(self) -> OpenAIProvider: @@ -439,7 +442,7 @@ def __init__(self, *, token: str, endpoint: str) -> None: self._temp_token = token self._temp_endpoint = endpoint - def _get_integration_name(self) -> IntegrationProvider: + def _get_integration_provider(self) -> IntegrationProvider: return IntegrationProvider.AZURE def create(self) -> AzureProvider: @@ -578,7 +581,7 @@ def __init__( self._temp_region = region self._temp_token_dict = {"aws_access_key_id": aws_access_key_id, "aws_secret_access_key": aws_secret_access_key} - def _get_integration_name(self) -> IntegrationProvider: + def _get_integration_provider(self) -> IntegrationProvider: return IntegrationProvider.AWS_BEDROCK def create(self) -> BedrockProvider: @@ -720,7 +723,7 @@ def __init__(self, *, token: str) -> None: # Store temporarily for create() call only self._temp_token = token - def _get_integration_name(self) -> IntegrationProvider: + def _get_integration_provider(self) -> IntegrationProvider: return IntegrationProvider.ANTHROPIC def create(self) -> AnthropicProvider: @@ -831,10 +834,10 @@ class GenericProvider(Provider): It does not support creation or updates through the SDK. """ - _integration_name: IntegrationProvider + _integration_provider: IntegrationProvider - def _get_integration_name(self) -> IntegrationProvider: - return self._integration_name + def _get_integration_provider(self) -> IntegrationProvider: + return self._integration_provider class UnconfiguredProvider: @@ -861,11 +864,11 @@ class UnconfiguredProvider: not configured """ - _integration_name: str + _integration_provider: str def __init__(self, integration_name: str) -> None: # Use object.__setattr__ to bypass our custom __setattr__ - object.__setattr__(self, "_integration_name", integration_name) + object.__setattr__(self, "_integration_provider", integration_name) def __bool__(self) -> bool: """Allow truthiness checks: 'if Integration.azure:' returns False.""" @@ -873,17 +876,17 @@ def __bool__(self) -> bool: def __getattr__(self, name: str) -> None: """Raise helpful error when any attribute is accessed.""" - raise IntegrationNotConfiguredError(self._integration_name) + raise IntegrationNotConfiguredError(self._integration_provider) def __setattr__(self, name: str, value: Any) -> None: """Raise helpful error when any attribute is set.""" - raise IntegrationNotConfiguredError(self._integration_name) + raise IntegrationNotConfiguredError(self._integration_provider) def __repr__(self) -> str: - return f"UnconfiguredProvider('{self._integration_name}')" + return f"UnconfiguredProvider('{self._integration_provider}')" def __str__(self) -> str: - return f"UnconfiguredProvider('{self._integration_name}')" + return f"UnconfiguredProvider('{self._integration_provider}')" # Import Model here to avoid circular imports From 1caac6008acb8c5a793fef17a161e0ea174a8533 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 20 Jul 2026 19:02:30 +0000 Subject: [PATCH 2/2] Update API Client --- openapi.yaml | 611 ++++-------------- .../api/jobs/get_job_jobs_job_id_get.py | 159 ----- ...rojects_project_id_runs_run_id_jobs_get.py | 202 ------ src/splunk_ao/resources/models/__init__.py | 12 - src/splunk_ao/resources/models/bleu_scorer.py | 146 ----- .../resources/models/core_scorer_name.py | 14 +- .../resources/models/create_job_request.py | 113 +--- .../resources/models/create_job_response.py | 113 +--- src/splunk_ao/resources/models/job_db.py | 330 ---------- .../resources/models/job_db_request_data.py | 44 -- .../models/prompt_perplexity_scorer.py | 146 ----- .../resources/models/rouge_scorer.py | 146 ----- src/splunk_ao/resources/models/run_db.py | 20 + src/splunk_ao/resources/models/run_db_thin.py | 20 + src/splunk_ao/resources/models/scorer_name.py | 106 ++- .../resources/models/scorers_configuration.py | 36 -- .../resources/models/uncertainty_scorer.py | 146 ----- 17 files changed, 284 insertions(+), 2080 deletions(-) delete mode 100644 src/splunk_ao/resources/api/jobs/get_job_jobs_job_id_get.py delete mode 100644 src/splunk_ao/resources/api/jobs/get_jobs_for_project_run_projects_project_id_runs_run_id_jobs_get.py delete mode 100644 src/splunk_ao/resources/models/bleu_scorer.py delete mode 100644 src/splunk_ao/resources/models/job_db.py delete mode 100644 src/splunk_ao/resources/models/job_db_request_data.py delete mode 100644 src/splunk_ao/resources/models/prompt_perplexity_scorer.py delete mode 100644 src/splunk_ao/resources/models/rouge_scorer.py delete mode 100644 src/splunk_ao/resources/models/uncertainty_scorer.py diff --git a/openapi.yaml b/openapi.yaml index 97c3ebef..f3093bc5 100644 --- a/openapi.yaml +++ b/openapi.yaml @@ -2898,94 +2898,6 @@ paths: - APIKeyHeader: [] - OAuth2PasswordBearer: [] - HTTPBasic: [] - /jobs/{job_id}: - get: - tags: - - jobs - summary: Get Job - description: Get a job by id. - operationId: get_job_jobs__job_id__get - security: - - ClassicAPIKeyHeader: [] - - APIKeyHeader: [] - - OAuth2PasswordBearer: [] - - HTTPBasic: [] - parameters: - - name: job_id - in: path - required: true - schema: - type: string - format: uuid4 - title: Job Id - responses: - '200': - description: Successful Response - content: - application/json: - schema: - $ref: '#/components/schemas/JobDB' - '422': - description: Validation Error - content: - application/json: - schema: - $ref: '#/components/schemas/HTTPValidationError' - /projects/{project_id}/runs/{run_id}/jobs: - get: - tags: - - jobs - summary: Get Jobs For Project Run - description: 'Get all jobs for a project and run. - - - Returns them in order of creation from newest to oldest.' - operationId: get_jobs_for_project_run_projects__project_id__runs__run_id__jobs_get - security: - - ClassicAPIKeyHeader: [] - - APIKeyHeader: [] - - OAuth2PasswordBearer: [] - - HTTPBasic: [] - parameters: - - name: project_id - in: path - required: true - schema: - type: string - format: uuid4 - title: Project Id - - name: run_id - in: path - required: true - schema: - type: string - format: uuid4 - title: Run Id - - name: status - in: query - required: false - schema: - anyOf: - - type: string - - type: 'null' - title: Status - responses: - '200': - description: Successful Response - content: - application/json: - schema: - type: array - items: - $ref: '#/components/schemas/JobDB' - title: Response Get Jobs For Project Run Projects Project Id Runs Run - Id Jobs Get - '422': - description: Validation Error - content: - application/json: - schema: - $ref: '#/components/schemas/HTTPValidationError' /projects/{project_id}/runs/{run_id}/scorer-settings: patch: tags: @@ -14039,32 +13951,6 @@ components: required: - metric title: BillingUsageResponse - BleuScorer: - properties: - name: - type: string - const: bleu - title: Name - default: bleu - filters: - anyOf: - - items: - oneOf: - - $ref: '#/components/schemas/NodeNameFilter' - - $ref: '#/components/schemas/MetadataFilter' - - $ref: '#/components/schemas/ModalityFilter' - discriminator: - propertyName: name - mapping: - metadata: '#/components/schemas/MetadataFilter' - modality: '#/components/schemas/ModalityFilter' - node_name: '#/components/schemas/NodeNameFilter' - type: array - - type: 'null' - title: Filters - description: List of filters to apply to the scorer. - type: object - title: BleuScorer Body_create_code_scorer_version_scorers__scorer_id__version_code_post: properties: file: @@ -15728,7 +15614,6 @@ components: oneOf: - $ref: '#/components/schemas/AgenticWorkflowSuccessScorer' - $ref: '#/components/schemas/AgenticSessionSuccessScorer' - - $ref: '#/components/schemas/BleuScorer' - $ref: '#/components/schemas/ChunkAttributionUtilizationScorer' - $ref: '#/components/schemas/CompletenessScorer' - $ref: '#/components/schemas/ContextAdherenceScorer' @@ -15745,17 +15630,13 @@ components: - $ref: '#/components/schemas/OutputToneScorer' - $ref: '#/components/schemas/OutputToxicityScorer' - $ref: '#/components/schemas/PromptInjectionScorer' - - $ref: '#/components/schemas/PromptPerplexityScorer' - - $ref: '#/components/schemas/RougeScorer' - $ref: '#/components/schemas/ToolErrorRateScorer' - $ref: '#/components/schemas/ToolSelectionQualityScorer' - - $ref: '#/components/schemas/UncertaintyScorer' discriminator: propertyName: name mapping: agentic_session_success: '#/components/schemas/AgenticSessionSuccessScorer' agentic_workflow_success: '#/components/schemas/AgenticWorkflowSuccessScorer' - bleu: '#/components/schemas/BleuScorer' chunk_attribution_utilization: '#/components/schemas/ChunkAttributionUtilizationScorer' completeness: '#/components/schemas/CompletenessScorer' context_adherence: '#/components/schemas/ContextAdherenceScorer' @@ -15772,11 +15653,8 @@ components: output_tone: '#/components/schemas/OutputToneScorer' output_toxicity: '#/components/schemas/OutputToxicityScorer' prompt_injection: '#/components/schemas/PromptInjectionScorer' - prompt_perplexity: '#/components/schemas/PromptPerplexityScorer' - rouge: '#/components/schemas/RougeScorer' tool_error_rate: '#/components/schemas/ToolErrorRateScorer' tool_selection_quality: '#/components/schemas/ToolSelectionQualityScorer' - uncertainty: '#/components/schemas/UncertaintyScorer' type: array - type: 'null' title: Scorers @@ -16056,7 +15934,6 @@ components: oneOf: - $ref: '#/components/schemas/AgenticWorkflowSuccessScorer' - $ref: '#/components/schemas/AgenticSessionSuccessScorer' - - $ref: '#/components/schemas/BleuScorer' - $ref: '#/components/schemas/ChunkAttributionUtilizationScorer' - $ref: '#/components/schemas/CompletenessScorer' - $ref: '#/components/schemas/ContextAdherenceScorer' @@ -16073,17 +15950,13 @@ components: - $ref: '#/components/schemas/OutputToneScorer' - $ref: '#/components/schemas/OutputToxicityScorer' - $ref: '#/components/schemas/PromptInjectionScorer' - - $ref: '#/components/schemas/PromptPerplexityScorer' - - $ref: '#/components/schemas/RougeScorer' - $ref: '#/components/schemas/ToolErrorRateScorer' - $ref: '#/components/schemas/ToolSelectionQualityScorer' - - $ref: '#/components/schemas/UncertaintyScorer' discriminator: propertyName: name mapping: agentic_session_success: '#/components/schemas/AgenticSessionSuccessScorer' agentic_workflow_success: '#/components/schemas/AgenticWorkflowSuccessScorer' - bleu: '#/components/schemas/BleuScorer' chunk_attribution_utilization: '#/components/schemas/ChunkAttributionUtilizationScorer' completeness: '#/components/schemas/CompletenessScorer' context_adherence: '#/components/schemas/ContextAdherenceScorer' @@ -16100,11 +15973,8 @@ components: output_tone: '#/components/schemas/OutputToneScorer' output_toxicity: '#/components/schemas/OutputToxicityScorer' prompt_injection: '#/components/schemas/PromptInjectionScorer' - prompt_perplexity: '#/components/schemas/PromptPerplexityScorer' - rouge: '#/components/schemas/RougeScorer' tool_error_rate: '#/components/schemas/ToolErrorRateScorer' tool_selection_quality: '#/components/schemas/ToolSelectionQualityScorer' - uncertainty: '#/components/schemas/UncertaintyScorer' type: array - type: 'null' title: Scorers @@ -23731,16 +23601,6 @@ components: label: Average Cost multi_valued: false sortable: true - - applicable_types: [] - category: metric - data_type: floating_point - filterable: true - id: metrics/average_bleu - is_empty: false - is_optional: false - label: Average Bleu - multi_valued: false - sortable: true - applicable_types: [] category: metric data_type: integer @@ -30512,104 +30372,6 @@ components: - stage_metadata - action_result title: InvokeResponse - JobDB: - properties: - id: - type: string - format: uuid4 - title: Id - created_at: - type: string - format: date-time - title: Created At - updated_at: - type: string - format: date-time - title: Updated At - failed_at: - anyOf: - - type: string - format: date-time - - type: 'null' - title: Failed At - completed_at: - anyOf: - - type: string - format: date-time - - type: 'null' - title: Completed At - processing_started: - anyOf: - - type: string - format: date-time - - type: 'null' - title: Processing Started - job_name: - type: string - title: Job Name - migration_name: - anyOf: - - type: string - - type: 'null' - title: Migration Name - project_id: - type: string - format: uuid4 - title: Project Id - run_id: - type: string - format: uuid4 - title: Run Id - monitor_batch_id: - anyOf: - - type: string - format: uuid4 - - type: 'null' - title: Monitor Batch Id - status: - type: string - title: Status - retries: - type: integer - title: Retries - request_data: - additionalProperties: true - type: object - title: Request Data - error_message: - anyOf: - - type: string - - type: 'null' - title: Error Message - progress_message: - anyOf: - - type: string - - type: 'null' - title: Progress Message - steps_completed: - type: integer - title: Steps Completed - default: 0 - steps_total: - type: integer - title: Steps Total - default: 0 - progress_percent: - type: number - title: Progress Percent - default: 0.0 - type: object - required: - - id - - created_at - - updated_at - - job_name - - project_id - - run_id - - status - - retries - - request_data - title: JobDB JobProgress: properties: progress_message: @@ -31571,14 +31333,14 @@ components: examples: - columns: - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: text description: Input to the trace or span. @@ -31592,14 +31354,14 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: text description: Output of the trace or span. @@ -31613,14 +31375,14 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: text description: Name of the trace, span or session. @@ -31634,14 +31396,14 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: timestamp description: Timestamp of the trace or span's creation. @@ -31655,13 +31417,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: string_list description: Tags associated with this trace or span. @@ -31675,13 +31437,13 @@ components: multi_valued: true sortable: false - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: integer description: Status code of the trace or span. Used for logging failure @@ -31696,14 +31458,14 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: text description: A user-provided session, trace or span ID. @@ -31717,13 +31479,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: text description: Input to the dataset associated with this trace @@ -31737,13 +31499,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: text description: Output from the dataset associated with this trace @@ -31757,14 +31519,14 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: uuid description: Galileo ID of the session, trace or span @@ -31778,13 +31540,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: uuid description: Galileo ID of the session containing the trace (or the @@ -31799,13 +31561,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: uuid description: Galileo ID of the project associated with this trace or @@ -31820,13 +31582,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: uuid description: Galileo ID of the run (log stream or experiment) associated @@ -31841,13 +31603,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: timestamp description: Timestamp of the session or trace or span's last update @@ -31861,13 +31623,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: boolean description: Whether or not this trace or span has child spans @@ -31881,14 +31643,14 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: text description: Runner progress text written directly to CH span @@ -31902,14 +31664,14 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - session + - agent + - llm - workflow + - control - trace - - agent + - session - retriever - - llm + - tool category: standard data_type: text description: Runner error text written directly to CH span @@ -31923,13 +31685,13 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control + - agent + - llm - workflow + - control - trace - - agent - retriever - - llm + - tool category: standard data_type: boolean description: Whether the parent trace is complete or not @@ -31943,21 +31705,21 @@ components: multi_valued: false sortable: true - allowed_values: - - tool + - llm - control - - session - workflow - - trace - agent + - trace + - session - retriever - - llm - applicable_types: - tool - - control - - workflow + applicable_types: - agent - - retriever - llm + - workflow + - control + - retriever + - tool category: standard data_type: text description: Type of the trace, span or session. @@ -31971,12 +31733,12 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - workflow - agent - - retriever - llm + - workflow + - control + - retriever + - tool category: standard data_type: uuid description: Galileo ID of the trace containing the span (or the same @@ -31991,12 +31753,12 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - workflow - agent - - retriever - llm + - workflow + - control + - retriever + - tool category: standard data_type: uuid description: Galileo ID of the parent of this span @@ -32010,12 +31772,12 @@ components: multi_valued: false sortable: true - applicable_types: - - tool - - control - - workflow - agent - - retriever - llm + - workflow + - control + - retriever + - tool category: standard data_type: integer description: Topological step number of the span. @@ -32029,14 +31791,14 @@ components: multi_valued: false sortable: true - allowed_values: - - react - - classifier - - judge - - default - supervisor - - reflection - planner + - react + - reflection + - classifier - router + - default + - judge applicable_types: - agent category: standard @@ -32151,8 +31913,8 @@ components: multi_valued: false sortable: true - allowed_values: - - post - pre + - post applicable_types: - control category: standard @@ -32169,8 +31931,8 @@ components: multi_valued: false sortable: true - allowed_values: - - llm_call - tool_call + - llm_call applicable_types: - control category: standard @@ -32243,21 +32005,6 @@ components: - Medium - High inverted: true - - applicable_types: [] - category: metric - data_type: floating_point - description: BLEU is a case-sensitive measurement of the difference - between an model generation and target generation at the sentence-level. - filter_type: number - filterable: true - group_label: Output Quality - id: metrics/bleu - is_empty: false - is_optional: false - label: BLEU - DEPRECATED - multi_valued: false - roll_up_method: average - sortable: true LogRecordsBooleanFilter: properties: column_id: @@ -33214,7 +32961,7 @@ components: annotation_agreement: {} annotation_queue_ids: [] annotations: {} - created_at: '2026-07-14T04:36:10.771215Z' + created_at: '2026-07-20T08:46:11.692908Z' dataset_metadata: {} error_message: '' feedback_rating_info: {} @@ -33233,7 +32980,7 @@ components: annotation_agreement: {} annotation_queue_ids: [] annotations: {} - created_at: '2026-07-14T04:36:10.771367Z' + created_at: '2026-07-20T08:46:11.693052Z' dataset_metadata: {} error_message: '' feedback_rating_info: {} @@ -33513,7 +33260,7 @@ components: annotation_agreement: {} annotation_queue_ids: [] annotations: {} - created_at: '2026-07-14T04:36:10.765574Z' + created_at: '2026-07-20T08:46:11.687053Z' dataset_metadata: {} error_message: '' feedback_rating_info: {} @@ -33538,7 +33285,7 @@ components: annotation_agreement: {} annotation_queue_ids: [] annotations: {} - created_at: '2026-07-14T04:36:10.765743Z' + created_at: '2026-07-20T08:46:11.687244Z' dataset_metadata: {} error_message: '' feedback_rating_info: {} @@ -33871,14 +33618,14 @@ components: - log_stream_id: 00000000-0000-0000-0000-000000000000 parent_id: 11000011-0000-0000-0000-110000110000 spans: - - created_at: '2026-07-14T04:36:10.732598Z' + - created_at: '2026-07-20T08:46:11.658627Z' dataset_metadata: {} input: who is a smart LLM? metrics: {} name: '' output: I am! spans: - - created_at: '2026-07-14T04:36:10.718011Z' + - created_at: '2026-07-20T08:46:11.644600Z' dataset_metadata: {} id: 22222222-2222-4222-a222-222222222222 input: @@ -34525,14 +34272,14 @@ components: - log_stream_id: 00000000-0000-0000-0000-000000000000 session_id: 00000000-0000-0000-0000-000000000000 traces: - - created_at: '2026-07-14T04:36:10.711971Z' + - created_at: '2026-07-20T08:46:11.639004Z' dataset_metadata: {} input: who is a smart LLM? metrics: {} name: '' output: I am! spans: - - created_at: '2026-07-14T04:36:10.711921Z' + - created_at: '2026-07-20T08:46:11.638961Z' dataset_metadata: {} input: - content: 'Question: who is a smart LLM?' @@ -34550,14 +34297,14 @@ components: user_metadata: {} - experiment_id: 00000000-0000-0000-0000-000000000000 traces: - - created_at: '2026-07-14T04:36:10.712528Z' + - created_at: '2026-07-20T08:46:11.639461Z' dataset_metadata: {} input: who is a smart LLM? metrics: {} name: '' output: I am! spans: - - created_at: '2026-07-14T04:36:10.712477Z' + - created_at: '2026-07-20T08:46:11.639420Z' dataset_metadata: {} id: 11111111-1111-4111-a111-111111111111 input: @@ -40163,32 +39910,6 @@ components: description: 'Template for the prompt injection metric, containing all the info necessary to send the prompt injection prompt.' - PromptPerplexityScorer: - properties: - name: - type: string - const: prompt_perplexity - title: Name - default: prompt_perplexity - filters: - anyOf: - - items: - oneOf: - - $ref: '#/components/schemas/NodeNameFilter' - - $ref: '#/components/schemas/MetadataFilter' - - $ref: '#/components/schemas/ModalityFilter' - discriminator: - propertyName: name - mapping: - metadata: '#/components/schemas/MetadataFilter' - modality: '#/components/schemas/ModalityFilter' - node_name: '#/components/schemas/NodeNameFilter' - type: array - - type: 'null' - title: Filters - description: List of filters to apply to the scorer. - type: object - title: PromptPerplexityScorer PromptRunSettings: properties: logprobs: @@ -41180,32 +40901,6 @@ components: Maps fine-grained StepType values to the three top-level categories used throughout the platform: session, trace, and span.' - RougeScorer: - properties: - name: - type: string - const: rouge - title: Name - default: rouge - filters: - anyOf: - - items: - oneOf: - - $ref: '#/components/schemas/NodeNameFilter' - - $ref: '#/components/schemas/MetadataFilter' - - $ref: '#/components/schemas/ModalityFilter' - discriminator: - propertyName: name - mapping: - metadata: '#/components/schemas/MetadataFilter' - modality: '#/components/schemas/ModalityFilter' - node_name: '#/components/schemas/NodeNameFilter' - type: array - - type: 'null' - title: Filters - description: List of filters to apply to the scorer. - type: object - title: RougeScorer Rule: properties: metric: @@ -41396,6 +41091,12 @@ components: format: uuid4 - type: 'null' title: Dataset Version Id + prompt_template_version_id: + anyOf: + - type: string + format: uuid4 + - type: 'null' + title: Prompt Template Version Id id: type: string format: uuid4 @@ -41484,6 +41185,12 @@ components: format: uuid4 - type: 'null' title: Dataset Version Id + prompt_template_version_id: + anyOf: + - type: string + format: uuid4 + - type: 'null' + title: Prompt Template Version Id id: type: string format: uuid4 @@ -42809,14 +42516,6 @@ components: type: boolean title: Input Pii default: false - bleu: - type: boolean - title: Bleu - default: true - rouge: - type: boolean - title: Rouge - default: true protect_status: type: boolean title: Protect Status @@ -42897,10 +42596,6 @@ components: type: boolean title: Action Advancement Luna default: false - uncertainty: - type: boolean - title: Uncertainty - default: false factuality: type: boolean title: Factuality @@ -42909,10 +42604,6 @@ components: type: boolean title: Groundedness default: false - prompt_perplexity: - type: boolean - title: Prompt Perplexity - default: false chunk_attribution_utilization_gpt: type: boolean title: Chunk Attribution Utilization Gpt @@ -44750,32 +44441,6 @@ components: - label - id title: TreeChoiceNode - UncertaintyScorer: - properties: - name: - type: string - const: uncertainty - title: Name - default: uncertainty - filters: - anyOf: - - items: - oneOf: - - $ref: '#/components/schemas/NodeNameFilter' - - $ref: '#/components/schemas/MetadataFilter' - - $ref: '#/components/schemas/ModalityFilter' - discriminator: - propertyName: name - mapping: - metadata: '#/components/schemas/MetadataFilter' - modality: '#/components/schemas/ModalityFilter' - node_name: '#/components/schemas/NodeNameFilter' - type: array - - type: 'null' - title: Filters - description: List of filters to apply to the scorer. - type: object - title: UncertaintyScorer UpdateAnnotationQueueRequest: properties: name: @@ -46409,12 +46074,13 @@ components: type: string enum: - action_advancement_luna + - action_completion_audio - action_completion_luna + - action_completion_vision - agent_efficiency - agent_flow - agentic_session_success - agentic_workflow_success - - bleu - chunk_attribution_utilization - chunk_attribution_utilization_luna - chunk_relevance @@ -46430,7 +46096,11 @@ components: - context_relevance_luna - conversation_quality - correctness + - correctness_audio + - correctness_vision - ground_truth_adherence + - ground_truth_adherence_audio + - ground_truth_adherence_vision - input_pii - input_pii_gpt - input_sexist @@ -46456,9 +46126,9 @@ components: - precision_at_k - prompt_injection - prompt_injection_luna - - prompt_perplexity - reasoning_coherence - - rouge + - reasoning_coherence_audio + - reasoning_coherence_vision - sql_adherence - sql_correctness - sql_efficiency @@ -46467,8 +46137,9 @@ components: - tool_error_rate_luna - tool_selection_quality - tool_selection_quality_luna - - uncertainty - user_intent_change + - user_intent_change_audio + - user_intent_change_vision - visual_fidelity - visual_quality title: CoreScorerName @@ -46633,7 +46304,6 @@ components: - _factuality - _groundedness - _latency - - _prompt_perplexity - _protect_status - _pii - _input_pii @@ -46652,10 +46322,7 @@ components: - _user_submitted - _user_generated - _user_finetuned - - _uncertainty - - _bleu - _cost - - _rouge - _prompt_injection_gpt - _prompt_injection - _rag_nli diff --git a/src/splunk_ao/resources/api/jobs/get_job_jobs_job_id_get.py b/src/splunk_ao/resources/api/jobs/get_job_jobs_job_id_get.py deleted file mode 100644 index 3ac3e98a..00000000 --- a/src/splunk_ao/resources/api/jobs/get_job_jobs_job_id_get.py +++ /dev/null @@ -1,159 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from galileo_core.constants.request_method import RequestMethod -from galileo_core.helpers.api_client import ApiClient -from splunk_ao.exceptions import ( - AuthenticationError, - BadRequestError, - ConflictError, - ForbiddenError, - NotFoundError, - RateLimitError, - ServerError, -) -from splunk_ao.utils.headers_data import get_sdk_header - -from ... import errors -from ...models.http_validation_error import HTTPValidationError -from ...models.job_db import JobDB -from ...types import Response - - -def _get_kwargs(job_id: str) -> dict[str, Any]: - headers: dict[str, Any] = {} - - _kwargs: dict[str, Any] = { - "method": RequestMethod.GET, - "return_raw_response": True, - "path": "/jobs/{job_id}".format(job_id=job_id), - } - - headers["X-Galileo-SDK"] = get_sdk_header() - - _kwargs["content_headers"] = headers - return _kwargs - - -def _parse_response(*, client: ApiClient, response: httpx.Response) -> Union[HTTPValidationError, JobDB]: - if response.status_code == 200: - response_200 = JobDB.from_dict(response.json()) - - return response_200 - - if response.status_code == 422: - response_422 = HTTPValidationError.from_dict(response.json()) - - return response_422 - - # Handle common HTTP errors with actionable messages - if response.status_code == 400: - raise BadRequestError(response.status_code, response.content) - if response.status_code == 401: - raise AuthenticationError(response.status_code, response.content) - if response.status_code == 403: - raise ForbiddenError(response.status_code, response.content) - if response.status_code == 404: - raise NotFoundError(response.status_code, response.content) - if response.status_code == 409: - raise ConflictError(response.status_code, response.content) - if response.status_code == 429: - raise RateLimitError(response.status_code, response.content) - if response.status_code >= 500: - raise ServerError(response.status_code, response.content) - raise errors.UnexpectedStatus(response.status_code, response.content) - - -def _build_response(*, client: ApiClient, response: httpx.Response) -> Response[Union[HTTPValidationError, JobDB]]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed(job_id: str, *, client: ApiClient) -> Response[Union[HTTPValidationError, JobDB]]: - """Get Job - - Get a job by id. - - Args: - job_id (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[Union[HTTPValidationError, JobDB]] - """ - - kwargs = _get_kwargs(job_id=job_id) - - response = client.request(**kwargs) - - return _build_response(client=client, response=response) - - -def sync(job_id: str, *, client: ApiClient) -> Optional[Union[HTTPValidationError, JobDB]]: - """Get Job - - Get a job by id. - - Args: - job_id (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Union[HTTPValidationError, JobDB] - """ - - return sync_detailed(job_id=job_id, client=client).parsed - - -async def asyncio_detailed(job_id: str, *, client: ApiClient) -> Response[Union[HTTPValidationError, JobDB]]: - """Get Job - - Get a job by id. - - Args: - job_id (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[Union[HTTPValidationError, JobDB]] - """ - - kwargs = _get_kwargs(job_id=job_id) - - response = await client.arequest(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio(job_id: str, *, client: ApiClient) -> Optional[Union[HTTPValidationError, JobDB]]: - """Get Job - - Get a job by id. - - Args: - job_id (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Union[HTTPValidationError, JobDB] - """ - - return (await asyncio_detailed(job_id=job_id, client=client)).parsed diff --git a/src/splunk_ao/resources/api/jobs/get_jobs_for_project_run_projects_project_id_runs_run_id_jobs_get.py b/src/splunk_ao/resources/api/jobs/get_jobs_for_project_run_projects_project_id_runs_run_id_jobs_get.py deleted file mode 100644 index 5f7274ad..00000000 --- a/src/splunk_ao/resources/api/jobs/get_jobs_for_project_run_projects_project_id_runs_run_id_jobs_get.py +++ /dev/null @@ -1,202 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from galileo_core.constants.request_method import RequestMethod -from galileo_core.helpers.api_client import ApiClient -from splunk_ao.exceptions import ( - AuthenticationError, - BadRequestError, - ConflictError, - ForbiddenError, - NotFoundError, - RateLimitError, - ServerError, -) -from splunk_ao.utils.headers_data import get_sdk_header - -from ... import errors -from ...models.http_validation_error import HTTPValidationError -from ...models.job_db import JobDB -from ...types import UNSET, Response, Unset - - -def _get_kwargs(project_id: str, run_id: str, *, status: Union[None, Unset, str] = UNSET) -> dict[str, Any]: - headers: dict[str, Any] = {} - - params: dict[str, Any] = {} - - json_status: Union[None, Unset, str] - if isinstance(status, Unset): - json_status = UNSET - else: - json_status = status - params["status"] = json_status - - params = {k: v for k, v in params.items() if v is not UNSET and v is not None} - - _kwargs: dict[str, Any] = { - "method": RequestMethod.GET, - "return_raw_response": True, - "path": "/projects/{project_id}/runs/{run_id}/jobs".format(project_id=project_id, run_id=run_id), - "params": params, - } - - headers["X-Galileo-SDK"] = get_sdk_header() - - _kwargs["content_headers"] = headers - return _kwargs - - -def _parse_response(*, client: ApiClient, response: httpx.Response) -> Union[HTTPValidationError, list["JobDB"]]: - if response.status_code == 200: - response_200 = [] - _response_200 = response.json() - for response_200_item_data in _response_200: - response_200_item = JobDB.from_dict(response_200_item_data) - - response_200.append(response_200_item) - - return response_200 - - if response.status_code == 422: - response_422 = HTTPValidationError.from_dict(response.json()) - - return response_422 - - # Handle common HTTP errors with actionable messages - if response.status_code == 400: - raise BadRequestError(response.status_code, response.content) - if response.status_code == 401: - raise AuthenticationError(response.status_code, response.content) - if response.status_code == 403: - raise ForbiddenError(response.status_code, response.content) - if response.status_code == 404: - raise NotFoundError(response.status_code, response.content) - if response.status_code == 409: - raise ConflictError(response.status_code, response.content) - if response.status_code == 429: - raise RateLimitError(response.status_code, response.content) - if response.status_code >= 500: - raise ServerError(response.status_code, response.content) - raise errors.UnexpectedStatus(response.status_code, response.content) - - -def _build_response( - *, client: ApiClient, response: httpx.Response -) -> Response[Union[HTTPValidationError, list["JobDB"]]]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - project_id: str, run_id: str, *, client: ApiClient, status: Union[None, Unset, str] = UNSET -) -> Response[Union[HTTPValidationError, list["JobDB"]]]: - """Get Jobs For Project Run - - Get all jobs for a project and run. - - Returns them in order of creation from newest to oldest. - - Args: - project_id (str): - run_id (str): - status (Union[None, Unset, str]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[Union[HTTPValidationError, list['JobDB']]] - """ - - kwargs = _get_kwargs(project_id=project_id, run_id=run_id, status=status) - - response = client.request(**kwargs) - - return _build_response(client=client, response=response) - - -def sync( - project_id: str, run_id: str, *, client: ApiClient, status: Union[None, Unset, str] = UNSET -) -> Optional[Union[HTTPValidationError, list["JobDB"]]]: - """Get Jobs For Project Run - - Get all jobs for a project and run. - - Returns them in order of creation from newest to oldest. - - Args: - project_id (str): - run_id (str): - status (Union[None, Unset, str]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Union[HTTPValidationError, list['JobDB']] - """ - - return sync_detailed(project_id=project_id, run_id=run_id, client=client, status=status).parsed - - -async def asyncio_detailed( - project_id: str, run_id: str, *, client: ApiClient, status: Union[None, Unset, str] = UNSET -) -> Response[Union[HTTPValidationError, list["JobDB"]]]: - """Get Jobs For Project Run - - Get all jobs for a project and run. - - Returns them in order of creation from newest to oldest. - - Args: - project_id (str): - run_id (str): - status (Union[None, Unset, str]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[Union[HTTPValidationError, list['JobDB']]] - """ - - kwargs = _get_kwargs(project_id=project_id, run_id=run_id, status=status) - - response = await client.arequest(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - project_id: str, run_id: str, *, client: ApiClient, status: Union[None, Unset, str] = UNSET -) -> Optional[Union[HTTPValidationError, list["JobDB"]]]: - """Get Jobs For Project Run - - Get all jobs for a project and run. - - Returns them in order of creation from newest to oldest. - - Args: - project_id (str): - run_id (str): - status (Union[None, Unset, str]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Union[HTTPValidationError, list['JobDB']] - """ - - return (await asyncio_detailed(project_id=project_id, run_id=run_id, client=client, status=status)).parsed diff --git a/src/splunk_ao/resources/models/__init__.py b/src/splunk_ao/resources/models/__init__.py index 56d14fcd..75174065 100644 --- a/src/splunk_ao/resources/models/__init__.py +++ b/src/splunk_ao/resources/models/__init__.py @@ -149,7 +149,6 @@ from .billing_usage_data_point import BillingUsageDataPoint from .billing_usage_metric import BillingUsageMetric from .billing_usage_response import BillingUsageResponse -from .bleu_scorer import BleuScorer from .body_create_code_scorer_version_scorers_scorer_id_version_code_post import ( BodyCreateCodeScorerVersionScorersScorerIdVersionCodePost, ) @@ -779,8 +778,6 @@ from .invoke_response_headers_type_0 import InvokeResponseHeadersType0 from .invoke_response_metadata_type_0 import InvokeResponseMetadataType0 from .invoke_response_metric_results import InvokeResponseMetricResults -from .job_db import JobDB -from .job_db_request_data import JobDBRequestData from .job_progress import JobProgress from .like_dislike_aggregate import LikeDislikeAggregate from .like_dislike_constraints import LikeDislikeConstraints @@ -1108,7 +1105,6 @@ from .prompt_injection_scorer_type import PromptInjectionScorerType from .prompt_injection_template import PromptInjectionTemplate from .prompt_injection_template_response_schema_type_0 import PromptInjectionTemplateResponseSchemaType0 -from .prompt_perplexity_scorer import PromptPerplexityScorer from .prompt_run_settings import PromptRunSettings from .prompt_run_settings_response_format_type_0 import PromptRunSettingsResponseFormatType0 from .prompt_run_settings_tools_type_0_item import PromptRunSettingsToolsType0Item @@ -1158,7 +1154,6 @@ from .roll_up_strategy import RollUpStrategy from .rollback_request import RollbackRequest from .root_type import RootType -from .rouge_scorer import RougeScorer from .rule import Rule from .rule_operator import RuleOperator from .rule_result import RuleResult @@ -1298,7 +1293,6 @@ from .tree_choice_db_constraints import TreeChoiceDBConstraints from .tree_choice_node import TreeChoiceNode from .tree_choice_rating import TreeChoiceRating -from .uncertainty_scorer import UncertaintyScorer from .update_annotation_queue_request import UpdateAnnotationQueueRequest from .update_dataset_content_request import UpdateDatasetContentRequest from .update_dataset_request import UpdateDatasetRequest @@ -1488,7 +1482,6 @@ "BillingUsageDataPoint", "BillingUsageMetric", "BillingUsageResponse", - "BleuScorer", "BodyCreateCodeScorerVersionScorersScorerIdVersionCodePost", "BodyCreateDatasetDatasetsPost", "BodyLoginEmailLoginPost", @@ -1952,8 +1945,6 @@ "InvokeResponseHeadersType0", "InvokeResponseMetadataType0", "InvokeResponseMetricResults", - "JobDB", - "JobDBRequestData", "JobProgress", "LikeDislikeAggregate", "LikeDislikeConstraints", @@ -2245,7 +2236,6 @@ "PromptInjectionScorerType", "PromptInjectionTemplate", "PromptInjectionTemplateResponseSchemaType0", - "PromptPerplexityScorer", "PromptRunSettings", "PromptRunSettingsResponseFormatType0", "PromptRunSettingsToolsType0Item", @@ -2291,7 +2281,6 @@ "RollUpMethodDisplayOptions", "RollUpStrategy", "RootType", - "RougeScorer", "Rule", "RuleOperator", "RuleResult", @@ -2431,7 +2420,6 @@ "TreeChoiceDBConstraints", "TreeChoiceNode", "TreeChoiceRating", - "UncertaintyScorer", "UpdateAnnotationQueueRequest", "UpdateDatasetContentRequest", "UpdateDatasetRequest", diff --git a/src/splunk_ao/resources/models/bleu_scorer.py b/src/splunk_ao/resources/models/bleu_scorer.py deleted file mode 100644 index d6575b12..00000000 --- a/src/splunk_ao/resources/models/bleu_scorer.py +++ /dev/null @@ -1,146 +0,0 @@ -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, 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.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - -T = TypeVar("T", bound="BleuScorer") - - -@_attrs_define -class BleuScorer: - """ - Attributes: - name (Union[Literal['bleu'], Unset]): Default: 'bleu'. - filters (Union[None, Unset, list[Union['MetadataFilter', 'ModalityFilter', 'NodeNameFilter']]]): List of filters - to apply to the scorer. - """ - - name: Union[Literal["bleu"], Unset] = "bleu" - filters: Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - from ..models.metadata_filter import MetadataFilter - from ..models.node_name_filter import NodeNameFilter - - name = self.name - - filters: Union[None, Unset, list[dict[str, Any]]] - if isinstance(self.filters, Unset): - filters = UNSET - elif isinstance(self.filters, list): - filters = [] - for filters_type_0_item_data in self.filters: - filters_type_0_item: dict[str, Any] - if isinstance(filters_type_0_item_data, NodeNameFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - elif isinstance(filters_type_0_item_data, MetadataFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - else: - filters_type_0_item = filters_type_0_item_data.to_dict() - - filters.append(filters_type_0_item) - - else: - filters = self.filters - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if name is not UNSET: - field_dict["name"] = name - if filters is not UNSET: - field_dict["filters"] = filters - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - d = dict(src_dict) - name = cast(Union[Literal["bleu"], Unset], d.pop("name", UNSET)) - if name != "bleu" and not isinstance(name, Unset): - raise ValueError(f"name must match const 'bleu', got '{name}'") - - def _parse_filters( - data: object, - ) -> Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, list): - raise TypeError() - filters_type_0 = [] - _filters_type_0 = data - for filters_type_0_item_data in _filters_type_0: - - def _parse_filters_type_0_item( - data: object, - ) -> Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]: - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_0 = NodeNameFilter.from_dict(data) - - return filters_type_0_item_type_0 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_1 = MetadataFilter.from_dict(data) - - return filters_type_0_item_type_1 - except: # noqa: E722 - pass - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_2 = ModalityFilter.from_dict(data) - - return filters_type_0_item_type_2 - - filters_type_0_item = _parse_filters_type_0_item(filters_type_0_item_data) - - filters_type_0.append(filters_type_0_item) - - return filters_type_0 - except: # noqa: E722 - pass - return cast(Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]], data) - - filters = _parse_filters(d.pop("filters", UNSET)) - - bleu_scorer = cls(name=name, filters=filters) - - bleu_scorer.additional_properties = d - return bleu_scorer - - @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 diff --git a/src/splunk_ao/resources/models/core_scorer_name.py b/src/splunk_ao/resources/models/core_scorer_name.py index ed6a36f6..77a72c45 100644 --- a/src/splunk_ao/resources/models/core_scorer_name.py +++ b/src/splunk_ao/resources/models/core_scorer_name.py @@ -3,12 +3,13 @@ class CoreScorerName(str, Enum): ACTION_ADVANCEMENT_LUNA = "action_advancement_luna" + ACTION_COMPLETION_AUDIO = "action_completion_audio" ACTION_COMPLETION_LUNA = "action_completion_luna" + ACTION_COMPLETION_VISION = "action_completion_vision" AGENTIC_SESSION_SUCCESS = "agentic_session_success" AGENTIC_WORKFLOW_SUCCESS = "agentic_workflow_success" AGENT_EFFICIENCY = "agent_efficiency" AGENT_FLOW = "agent_flow" - BLEU = "bleu" CHUNK_ATTRIBUTION_UTILIZATION = "chunk_attribution_utilization" CHUNK_ATTRIBUTION_UTILIZATION_LUNA = "chunk_attribution_utilization_luna" CHUNK_RELEVANCE = "chunk_relevance" @@ -24,7 +25,11 @@ class CoreScorerName(str, Enum): CONTEXT_RELEVANCE_LUNA = "context_relevance_luna" CONVERSATION_QUALITY = "conversation_quality" CORRECTNESS = "correctness" + CORRECTNESS_AUDIO = "correctness_audio" + CORRECTNESS_VISION = "correctness_vision" GROUND_TRUTH_ADHERENCE = "ground_truth_adherence" + GROUND_TRUTH_ADHERENCE_AUDIO = "ground_truth_adherence_audio" + GROUND_TRUTH_ADHERENCE_VISION = "ground_truth_adherence_vision" INPUT_PII = "input_pii" INPUT_PII_GPT = "input_pii_gpt" INPUT_SEXIST = "input_sexist" @@ -50,9 +55,9 @@ class CoreScorerName(str, Enum): PRECISION_AT_K = "precision_at_k" PROMPT_INJECTION = "prompt_injection" PROMPT_INJECTION_LUNA = "prompt_injection_luna" - PROMPT_PERPLEXITY = "prompt_perplexity" REASONING_COHERENCE = "reasoning_coherence" - ROUGE = "rouge" + REASONING_COHERENCE_AUDIO = "reasoning_coherence_audio" + REASONING_COHERENCE_VISION = "reasoning_coherence_vision" SQL_ADHERENCE = "sql_adherence" SQL_CORRECTNESS = "sql_correctness" SQL_EFFICIENCY = "sql_efficiency" @@ -61,8 +66,9 @@ class CoreScorerName(str, Enum): TOOL_ERROR_RATE_LUNA = "tool_error_rate_luna" TOOL_SELECTION_QUALITY = "tool_selection_quality" TOOL_SELECTION_QUALITY_LUNA = "tool_selection_quality_luna" - UNCERTAINTY = "uncertainty" USER_INTENT_CHANGE = "user_intent_change" + USER_INTENT_CHANGE_AUDIO = "user_intent_change_audio" + USER_INTENT_CHANGE_VISION = "user_intent_change_vision" VISUAL_FIDELITY = "visual_fidelity" VISUAL_QUALITY = "visual_quality" diff --git a/src/splunk_ao/resources/models/create_job_request.py b/src/splunk_ao/resources/models/create_job_request.py index c8f03ade..65e91ad8 100644 --- a/src/splunk_ao/resources/models/create_job_request.py +++ b/src/splunk_ao/resources/models/create_job_request.py @@ -12,7 +12,6 @@ from ..models.agentic_session_success_scorer import AgenticSessionSuccessScorer from ..models.agentic_workflow_success_scorer import AgenticWorkflowSuccessScorer from ..models.base_scorer import BaseScorer - from ..models.bleu_scorer import BleuScorer from ..models.chunk_attribution_utilization_scorer import ChunkAttributionUtilizationScorer from ..models.completeness_scorer import CompletenessScorer from ..models.context_adherence_scorer import ContextAdherenceScorer @@ -48,17 +47,14 @@ from ..models.output_tone_scorer import OutputToneScorer from ..models.output_toxicity_scorer import OutputToxicityScorer from ..models.prompt_injection_scorer import PromptInjectionScorer - from ..models.prompt_perplexity_scorer import PromptPerplexityScorer from ..models.prompt_run_settings import PromptRunSettings from ..models.registered_scorer import RegisteredScorer - from ..models.rouge_scorer import RougeScorer from ..models.scorer_config import ScorerConfig from ..models.scorers_configuration import ScorersConfiguration from ..models.segment_filter import SegmentFilter from ..models.task_resource_limits import TaskResourceLimits from ..models.tool_error_rate_scorer import ToolErrorRateScorer from ..models.tool_selection_quality_scorer import ToolSelectionQualityScorer - from ..models.uncertainty_scorer import UncertaintyScorer T = TypeVar("T", bound="CreateJobRequest") @@ -93,13 +89,12 @@ class CreateJobRequest: protect_scorer_payload (Union[None, Unset, str]): prompt_settings (Union['PromptRunSettings', None, Unset]): scorers (Union[None, Unset, list['ScorerConfig'], list[Union['AgenticSessionSuccessScorer', - 'AgenticWorkflowSuccessScorer', 'BleuScorer', 'ChunkAttributionUtilizationScorer', 'CompletenessScorer', + 'AgenticWorkflowSuccessScorer', 'ChunkAttributionUtilizationScorer', 'CompletenessScorer', 'ContextAdherenceScorer', 'ContextRelevanceScorer', 'CorrectnessScorer', 'GroundTruthAdherenceScorer', 'InputPIIScorer', 'InputSexistScorer', 'InputToneScorer', 'InputToxicityScorer', 'InstructionAdherenceScorer', 'OutputPIIScorer', 'OutputSexistScorer', 'OutputToneScorer', 'OutputToxicityScorer', 'PromptInjectionScorer', - 'PromptPerplexityScorer', 'RougeScorer', 'ToolErrorRateScorer', 'ToolSelectionQualityScorer', - 'UncertaintyScorer']]]): For G2.0 we send all scorers as ScorerConfig, for G1.0 we send preset scorers as - GalileoScorer + 'ToolErrorRateScorer', 'ToolSelectionQualityScorer']]]): For G2.0 we send all scorers as ScorerConfig, for G1.0 + we send preset scorers as GalileoScorer prompt_registered_scorers_configuration (Union[None, Unset, list['RegisteredScorer']]): prompt_generated_scorers_configuration (Union[None, Unset, list[str]]): prompt_finetuned_scorers_configuration (Union[None, Unset, list['FineTunedScorer']]): @@ -158,7 +153,6 @@ class CreateJobRequest: Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -175,11 +169,8 @@ class CreateJobRequest: "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ] ], ] = UNSET @@ -229,7 +220,6 @@ def to_dict(self) -> dict[str, Any]: from ..models.agentic_session_success_scorer import AgenticSessionSuccessScorer from ..models.agentic_workflow_success_scorer import AgenticWorkflowSuccessScorer from ..models.base_scorer import BaseScorer - from ..models.bleu_scorer import BleuScorer from ..models.chunk_attribution_utilization_scorer import ChunkAttributionUtilizationScorer from ..models.completeness_scorer import CompletenessScorer from ..models.context_adherence_scorer import ContextAdherenceScorer @@ -263,14 +253,11 @@ def to_dict(self) -> dict[str, Any]: from ..models.output_tone_scorer import OutputToneScorer from ..models.output_toxicity_scorer import OutputToxicityScorer from ..models.prompt_injection_scorer import PromptInjectionScorer - from ..models.prompt_perplexity_scorer import PromptPerplexityScorer from ..models.prompt_run_settings import PromptRunSettings - from ..models.rouge_scorer import RougeScorer from ..models.scorer_config import ScorerConfig from ..models.scorers_configuration import ScorersConfiguration from ..models.task_resource_limits import TaskResourceLimits from ..models.tool_error_rate_scorer import ToolErrorRateScorer - from ..models.tool_selection_quality_scorer import ToolSelectionQualityScorer project_id = self.project_id @@ -427,8 +414,6 @@ def to_dict(self) -> dict[str, Any]: scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, AgenticSessionSuccessScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, BleuScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, ChunkAttributionUtilizationScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, CompletenessScorer): @@ -461,14 +446,8 @@ def to_dict(self) -> dict[str, Any]: scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, PromptInjectionScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, PromptPerplexityScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, RougeScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, ToolErrorRateScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, ToolSelectionQualityScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() else: scorers_type_1_item = scorers_type_1_item_data.to_dict() @@ -786,7 +765,6 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: from ..models.agentic_session_success_scorer import AgenticSessionSuccessScorer from ..models.agentic_workflow_success_scorer import AgenticWorkflowSuccessScorer from ..models.base_scorer import BaseScorer - from ..models.bleu_scorer import BleuScorer from ..models.chunk_attribution_utilization_scorer import ChunkAttributionUtilizationScorer from ..models.completeness_scorer import CompletenessScorer from ..models.context_adherence_scorer import ContextAdherenceScorer @@ -822,17 +800,14 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: from ..models.output_tone_scorer import OutputToneScorer from ..models.output_toxicity_scorer import OutputToxicityScorer from ..models.prompt_injection_scorer import PromptInjectionScorer - from ..models.prompt_perplexity_scorer import PromptPerplexityScorer from ..models.prompt_run_settings import PromptRunSettings from ..models.registered_scorer import RegisteredScorer - from ..models.rouge_scorer import RougeScorer from ..models.scorer_config import ScorerConfig from ..models.scorers_configuration import ScorersConfiguration from ..models.segment_filter import SegmentFilter from ..models.task_resource_limits import TaskResourceLimits from ..models.tool_error_rate_scorer import ToolErrorRateScorer from ..models.tool_selection_quality_scorer import ToolSelectionQualityScorer - from ..models.uncertainty_scorer import UncertaintyScorer d = dict(src_dict) project_id = d.pop("project_id") @@ -1075,7 +1050,6 @@ def _parse_scorers( Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -1092,11 +1066,8 @@ def _parse_scorers( "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ] ], ]: @@ -1129,7 +1100,6 @@ def _parse_scorers_type_1_item( ) -> Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -1146,11 +1116,8 @@ def _parse_scorers_type_1_item( "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ]: try: if not isinstance(data, dict): @@ -1171,7 +1138,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_2 = BleuScorer.from_dict(data) + scorers_type_1_item_type_2 = ChunkAttributionUtilizationScorer.from_dict(data) return scorers_type_1_item_type_2 except: # noqa: E722 @@ -1179,7 +1146,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_3 = ChunkAttributionUtilizationScorer.from_dict(data) + scorers_type_1_item_type_3 = CompletenessScorer.from_dict(data) return scorers_type_1_item_type_3 except: # noqa: E722 @@ -1187,7 +1154,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_4 = CompletenessScorer.from_dict(data) + scorers_type_1_item_type_4 = ContextAdherenceScorer.from_dict(data) return scorers_type_1_item_type_4 except: # noqa: E722 @@ -1195,7 +1162,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_5 = ContextAdherenceScorer.from_dict(data) + scorers_type_1_item_type_5 = ContextRelevanceScorer.from_dict(data) return scorers_type_1_item_type_5 except: # noqa: E722 @@ -1203,7 +1170,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_6 = ContextRelevanceScorer.from_dict(data) + scorers_type_1_item_type_6 = CorrectnessScorer.from_dict(data) return scorers_type_1_item_type_6 except: # noqa: E722 @@ -1211,7 +1178,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_7 = CorrectnessScorer.from_dict(data) + scorers_type_1_item_type_7 = GroundTruthAdherenceScorer.from_dict(data) return scorers_type_1_item_type_7 except: # noqa: E722 @@ -1219,7 +1186,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_8 = GroundTruthAdherenceScorer.from_dict(data) + scorers_type_1_item_type_8 = InputPIIScorer.from_dict(data) return scorers_type_1_item_type_8 except: # noqa: E722 @@ -1227,7 +1194,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_9 = InputPIIScorer.from_dict(data) + scorers_type_1_item_type_9 = InputSexistScorer.from_dict(data) return scorers_type_1_item_type_9 except: # noqa: E722 @@ -1235,7 +1202,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_10 = InputSexistScorer.from_dict(data) + scorers_type_1_item_type_10 = InputToneScorer.from_dict(data) return scorers_type_1_item_type_10 except: # noqa: E722 @@ -1243,7 +1210,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_11 = InputToneScorer.from_dict(data) + scorers_type_1_item_type_11 = InputToxicityScorer.from_dict(data) return scorers_type_1_item_type_11 except: # noqa: E722 @@ -1251,7 +1218,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_12 = InputToxicityScorer.from_dict(data) + scorers_type_1_item_type_12 = InstructionAdherenceScorer.from_dict(data) return scorers_type_1_item_type_12 except: # noqa: E722 @@ -1259,7 +1226,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_13 = InstructionAdherenceScorer.from_dict(data) + scorers_type_1_item_type_13 = OutputPIIScorer.from_dict(data) return scorers_type_1_item_type_13 except: # noqa: E722 @@ -1267,7 +1234,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_14 = OutputPIIScorer.from_dict(data) + scorers_type_1_item_type_14 = OutputSexistScorer.from_dict(data) return scorers_type_1_item_type_14 except: # noqa: E722 @@ -1275,7 +1242,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_15 = OutputSexistScorer.from_dict(data) + scorers_type_1_item_type_15 = OutputToneScorer.from_dict(data) return scorers_type_1_item_type_15 except: # noqa: E722 @@ -1283,7 +1250,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_16 = OutputToneScorer.from_dict(data) + scorers_type_1_item_type_16 = OutputToxicityScorer.from_dict(data) return scorers_type_1_item_type_16 except: # noqa: E722 @@ -1291,7 +1258,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_17 = OutputToxicityScorer.from_dict(data) + scorers_type_1_item_type_17 = PromptInjectionScorer.from_dict(data) return scorers_type_1_item_type_17 except: # noqa: E722 @@ -1299,48 +1266,16 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_18 = PromptInjectionScorer.from_dict(data) + scorers_type_1_item_type_18 = ToolErrorRateScorer.from_dict(data) return scorers_type_1_item_type_18 except: # noqa: E722 pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_19 = PromptPerplexityScorer.from_dict(data) - - return scorers_type_1_item_type_19 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_20 = RougeScorer.from_dict(data) - - return scorers_type_1_item_type_20 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_21 = ToolErrorRateScorer.from_dict(data) - - return scorers_type_1_item_type_21 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_22 = ToolSelectionQualityScorer.from_dict(data) - - return scorers_type_1_item_type_22 - except: # noqa: E722 - pass if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_23 = UncertaintyScorer.from_dict(data) + scorers_type_1_item_type_19 = ToolSelectionQualityScorer.from_dict(data) - return scorers_type_1_item_type_23 + return scorers_type_1_item_type_19 scorers_type_1_item = _parse_scorers_type_1_item(scorers_type_1_item_data) @@ -1358,7 +1293,6 @@ def _parse_scorers_type_1_item( Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -1375,11 +1309,8 @@ def _parse_scorers_type_1_item( "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ] ], ], diff --git a/src/splunk_ao/resources/models/create_job_response.py b/src/splunk_ao/resources/models/create_job_response.py index f103f2a9..0e4a4957 100644 --- a/src/splunk_ao/resources/models/create_job_response.py +++ b/src/splunk_ao/resources/models/create_job_response.py @@ -12,7 +12,6 @@ from ..models.agentic_session_success_scorer import AgenticSessionSuccessScorer from ..models.agentic_workflow_success_scorer import AgenticWorkflowSuccessScorer from ..models.base_scorer import BaseScorer - from ..models.bleu_scorer import BleuScorer from ..models.chunk_attribution_utilization_scorer import ChunkAttributionUtilizationScorer from ..models.completeness_scorer import CompletenessScorer from ..models.context_adherence_scorer import ContextAdherenceScorer @@ -48,17 +47,14 @@ from ..models.output_tone_scorer import OutputToneScorer from ..models.output_toxicity_scorer import OutputToxicityScorer from ..models.prompt_injection_scorer import PromptInjectionScorer - from ..models.prompt_perplexity_scorer import PromptPerplexityScorer from ..models.prompt_run_settings import PromptRunSettings from ..models.registered_scorer import RegisteredScorer - from ..models.rouge_scorer import RougeScorer from ..models.scorer_config import ScorerConfig from ..models.scorers_configuration import ScorersConfiguration from ..models.segment_filter import SegmentFilter from ..models.task_resource_limits import TaskResourceLimits from ..models.tool_error_rate_scorer import ToolErrorRateScorer from ..models.tool_selection_quality_scorer import ToolSelectionQualityScorer - from ..models.uncertainty_scorer import UncertaintyScorer T = TypeVar("T", bound="CreateJobResponse") @@ -95,13 +91,12 @@ class CreateJobResponse: protect_scorer_payload (Union[None, Unset, str]): prompt_settings (Union['PromptRunSettings', None, Unset]): scorers (Union[None, Unset, list['ScorerConfig'], list[Union['AgenticSessionSuccessScorer', - 'AgenticWorkflowSuccessScorer', 'BleuScorer', 'ChunkAttributionUtilizationScorer', 'CompletenessScorer', + 'AgenticWorkflowSuccessScorer', 'ChunkAttributionUtilizationScorer', 'CompletenessScorer', 'ContextAdherenceScorer', 'ContextRelevanceScorer', 'CorrectnessScorer', 'GroundTruthAdherenceScorer', 'InputPIIScorer', 'InputSexistScorer', 'InputToneScorer', 'InputToxicityScorer', 'InstructionAdherenceScorer', 'OutputPIIScorer', 'OutputSexistScorer', 'OutputToneScorer', 'OutputToxicityScorer', 'PromptInjectionScorer', - 'PromptPerplexityScorer', 'RougeScorer', 'ToolErrorRateScorer', 'ToolSelectionQualityScorer', - 'UncertaintyScorer']]]): For G2.0 we send all scorers as ScorerConfig, for G1.0 we send preset scorers as - GalileoScorer + 'ToolErrorRateScorer', 'ToolSelectionQualityScorer']]]): For G2.0 we send all scorers as ScorerConfig, for G1.0 + we send preset scorers as GalileoScorer prompt_registered_scorers_configuration (Union[None, Unset, list['RegisteredScorer']]): prompt_generated_scorers_configuration (Union[None, Unset, list[str]]): prompt_finetuned_scorers_configuration (Union[None, Unset, list['FineTunedScorer']]): @@ -162,7 +157,6 @@ class CreateJobResponse: Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -179,11 +173,8 @@ class CreateJobResponse: "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ] ], ] = UNSET @@ -233,7 +224,6 @@ def to_dict(self) -> dict[str, Any]: from ..models.agentic_session_success_scorer import AgenticSessionSuccessScorer from ..models.agentic_workflow_success_scorer import AgenticWorkflowSuccessScorer from ..models.base_scorer import BaseScorer - from ..models.bleu_scorer import BleuScorer from ..models.chunk_attribution_utilization_scorer import ChunkAttributionUtilizationScorer from ..models.completeness_scorer import CompletenessScorer from ..models.context_adherence_scorer import ContextAdherenceScorer @@ -267,14 +257,11 @@ def to_dict(self) -> dict[str, Any]: from ..models.output_tone_scorer import OutputToneScorer from ..models.output_toxicity_scorer import OutputToxicityScorer from ..models.prompt_injection_scorer import PromptInjectionScorer - from ..models.prompt_perplexity_scorer import PromptPerplexityScorer from ..models.prompt_run_settings import PromptRunSettings - from ..models.rouge_scorer import RougeScorer from ..models.scorer_config import ScorerConfig from ..models.scorers_configuration import ScorersConfiguration from ..models.task_resource_limits import TaskResourceLimits from ..models.tool_error_rate_scorer import ToolErrorRateScorer - from ..models.tool_selection_quality_scorer import ToolSelectionQualityScorer project_id = self.project_id @@ -435,8 +422,6 @@ def to_dict(self) -> dict[str, Any]: scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, AgenticSessionSuccessScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, BleuScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, ChunkAttributionUtilizationScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, CompletenessScorer): @@ -469,14 +454,8 @@ def to_dict(self) -> dict[str, Any]: scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, PromptInjectionScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, PromptPerplexityScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, RougeScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() elif isinstance(scorers_type_1_item_data, ToolErrorRateScorer): scorers_type_1_item = scorers_type_1_item_data.to_dict() - elif isinstance(scorers_type_1_item_data, ToolSelectionQualityScorer): - scorers_type_1_item = scorers_type_1_item_data.to_dict() else: scorers_type_1_item = scorers_type_1_item_data.to_dict() @@ -794,7 +773,6 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: from ..models.agentic_session_success_scorer import AgenticSessionSuccessScorer from ..models.agentic_workflow_success_scorer import AgenticWorkflowSuccessScorer from ..models.base_scorer import BaseScorer - from ..models.bleu_scorer import BleuScorer from ..models.chunk_attribution_utilization_scorer import ChunkAttributionUtilizationScorer from ..models.completeness_scorer import CompletenessScorer from ..models.context_adherence_scorer import ContextAdherenceScorer @@ -830,17 +808,14 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: from ..models.output_tone_scorer import OutputToneScorer from ..models.output_toxicity_scorer import OutputToxicityScorer from ..models.prompt_injection_scorer import PromptInjectionScorer - from ..models.prompt_perplexity_scorer import PromptPerplexityScorer from ..models.prompt_run_settings import PromptRunSettings from ..models.registered_scorer import RegisteredScorer - from ..models.rouge_scorer import RougeScorer from ..models.scorer_config import ScorerConfig from ..models.scorers_configuration import ScorersConfiguration from ..models.segment_filter import SegmentFilter from ..models.task_resource_limits import TaskResourceLimits from ..models.tool_error_rate_scorer import ToolErrorRateScorer from ..models.tool_selection_quality_scorer import ToolSelectionQualityScorer - from ..models.uncertainty_scorer import UncertaintyScorer d = dict(src_dict) project_id = d.pop("project_id") @@ -1087,7 +1062,6 @@ def _parse_scorers( Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -1104,11 +1078,8 @@ def _parse_scorers( "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ] ], ]: @@ -1141,7 +1112,6 @@ def _parse_scorers_type_1_item( ) -> Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -1158,11 +1128,8 @@ def _parse_scorers_type_1_item( "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ]: try: if not isinstance(data, dict): @@ -1183,7 +1150,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_2 = BleuScorer.from_dict(data) + scorers_type_1_item_type_2 = ChunkAttributionUtilizationScorer.from_dict(data) return scorers_type_1_item_type_2 except: # noqa: E722 @@ -1191,7 +1158,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_3 = ChunkAttributionUtilizationScorer.from_dict(data) + scorers_type_1_item_type_3 = CompletenessScorer.from_dict(data) return scorers_type_1_item_type_3 except: # noqa: E722 @@ -1199,7 +1166,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_4 = CompletenessScorer.from_dict(data) + scorers_type_1_item_type_4 = ContextAdherenceScorer.from_dict(data) return scorers_type_1_item_type_4 except: # noqa: E722 @@ -1207,7 +1174,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_5 = ContextAdherenceScorer.from_dict(data) + scorers_type_1_item_type_5 = ContextRelevanceScorer.from_dict(data) return scorers_type_1_item_type_5 except: # noqa: E722 @@ -1215,7 +1182,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_6 = ContextRelevanceScorer.from_dict(data) + scorers_type_1_item_type_6 = CorrectnessScorer.from_dict(data) return scorers_type_1_item_type_6 except: # noqa: E722 @@ -1223,7 +1190,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_7 = CorrectnessScorer.from_dict(data) + scorers_type_1_item_type_7 = GroundTruthAdherenceScorer.from_dict(data) return scorers_type_1_item_type_7 except: # noqa: E722 @@ -1231,7 +1198,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_8 = GroundTruthAdherenceScorer.from_dict(data) + scorers_type_1_item_type_8 = InputPIIScorer.from_dict(data) return scorers_type_1_item_type_8 except: # noqa: E722 @@ -1239,7 +1206,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_9 = InputPIIScorer.from_dict(data) + scorers_type_1_item_type_9 = InputSexistScorer.from_dict(data) return scorers_type_1_item_type_9 except: # noqa: E722 @@ -1247,7 +1214,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_10 = InputSexistScorer.from_dict(data) + scorers_type_1_item_type_10 = InputToneScorer.from_dict(data) return scorers_type_1_item_type_10 except: # noqa: E722 @@ -1255,7 +1222,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_11 = InputToneScorer.from_dict(data) + scorers_type_1_item_type_11 = InputToxicityScorer.from_dict(data) return scorers_type_1_item_type_11 except: # noqa: E722 @@ -1263,7 +1230,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_12 = InputToxicityScorer.from_dict(data) + scorers_type_1_item_type_12 = InstructionAdherenceScorer.from_dict(data) return scorers_type_1_item_type_12 except: # noqa: E722 @@ -1271,7 +1238,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_13 = InstructionAdherenceScorer.from_dict(data) + scorers_type_1_item_type_13 = OutputPIIScorer.from_dict(data) return scorers_type_1_item_type_13 except: # noqa: E722 @@ -1279,7 +1246,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_14 = OutputPIIScorer.from_dict(data) + scorers_type_1_item_type_14 = OutputSexistScorer.from_dict(data) return scorers_type_1_item_type_14 except: # noqa: E722 @@ -1287,7 +1254,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_15 = OutputSexistScorer.from_dict(data) + scorers_type_1_item_type_15 = OutputToneScorer.from_dict(data) return scorers_type_1_item_type_15 except: # noqa: E722 @@ -1295,7 +1262,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_16 = OutputToneScorer.from_dict(data) + scorers_type_1_item_type_16 = OutputToxicityScorer.from_dict(data) return scorers_type_1_item_type_16 except: # noqa: E722 @@ -1303,7 +1270,7 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_17 = OutputToxicityScorer.from_dict(data) + scorers_type_1_item_type_17 = PromptInjectionScorer.from_dict(data) return scorers_type_1_item_type_17 except: # noqa: E722 @@ -1311,48 +1278,16 @@ def _parse_scorers_type_1_item( try: if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_18 = PromptInjectionScorer.from_dict(data) + scorers_type_1_item_type_18 = ToolErrorRateScorer.from_dict(data) return scorers_type_1_item_type_18 except: # noqa: E722 pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_19 = PromptPerplexityScorer.from_dict(data) - - return scorers_type_1_item_type_19 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_20 = RougeScorer.from_dict(data) - - return scorers_type_1_item_type_20 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_21 = ToolErrorRateScorer.from_dict(data) - - return scorers_type_1_item_type_21 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - scorers_type_1_item_type_22 = ToolSelectionQualityScorer.from_dict(data) - - return scorers_type_1_item_type_22 - except: # noqa: E722 - pass if not isinstance(data, dict): raise TypeError() - scorers_type_1_item_type_23 = UncertaintyScorer.from_dict(data) + scorers_type_1_item_type_19 = ToolSelectionQualityScorer.from_dict(data) - return scorers_type_1_item_type_23 + return scorers_type_1_item_type_19 scorers_type_1_item = _parse_scorers_type_1_item(scorers_type_1_item_data) @@ -1370,7 +1305,6 @@ def _parse_scorers_type_1_item( Union[ "AgenticSessionSuccessScorer", "AgenticWorkflowSuccessScorer", - "BleuScorer", "ChunkAttributionUtilizationScorer", "CompletenessScorer", "ContextAdherenceScorer", @@ -1387,11 +1321,8 @@ def _parse_scorers_type_1_item( "OutputToneScorer", "OutputToxicityScorer", "PromptInjectionScorer", - "PromptPerplexityScorer", - "RougeScorer", "ToolErrorRateScorer", "ToolSelectionQualityScorer", - "UncertaintyScorer", ] ], ], diff --git a/src/splunk_ao/resources/models/job_db.py b/src/splunk_ao/resources/models/job_db.py deleted file mode 100644 index be6a07ef..00000000 --- a/src/splunk_ao/resources/models/job_db.py +++ /dev/null @@ -1,330 +0,0 @@ -import datetime -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, TypeVar, Union, cast - -from attrs import define as _attrs_define -from attrs import field as _attrs_field -from dateutil.parser import isoparse - -from ..types import UNSET, Unset - -if TYPE_CHECKING: - from ..models.job_db_request_data import JobDBRequestData - - -T = TypeVar("T", bound="JobDB") - - -@_attrs_define -class JobDB: - """ - Attributes: - id (str): - created_at (datetime.datetime): - updated_at (datetime.datetime): - job_name (str): - project_id (str): - run_id (str): - status (str): - retries (int): - request_data (JobDBRequestData): - failed_at (Union[None, Unset, datetime.datetime]): - completed_at (Union[None, Unset, datetime.datetime]): - processing_started (Union[None, Unset, datetime.datetime]): - migration_name (Union[None, Unset, str]): - monitor_batch_id (Union[None, Unset, str]): - error_message (Union[None, Unset, str]): - progress_message (Union[None, Unset, str]): - steps_completed (Union[Unset, int]): Default: 0. - steps_total (Union[Unset, int]): Default: 0. - progress_percent (Union[Unset, float]): Default: 0.0. - """ - - id: str - created_at: datetime.datetime - updated_at: datetime.datetime - job_name: str - project_id: str - run_id: str - status: str - retries: int - request_data: "JobDBRequestData" - failed_at: Union[None, Unset, datetime.datetime] = UNSET - completed_at: Union[None, Unset, datetime.datetime] = UNSET - processing_started: Union[None, Unset, datetime.datetime] = UNSET - migration_name: Union[None, Unset, str] = UNSET - monitor_batch_id: Union[None, Unset, str] = UNSET - error_message: Union[None, Unset, str] = UNSET - progress_message: Union[None, Unset, str] = UNSET - steps_completed: Union[Unset, int] = 0 - steps_total: Union[Unset, int] = 0 - progress_percent: Union[Unset, float] = 0.0 - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - id = self.id - - created_at = self.created_at.isoformat() - - updated_at = self.updated_at.isoformat() - - job_name = self.job_name - - project_id = self.project_id - - run_id = self.run_id - - status = self.status - - retries = self.retries - - request_data = self.request_data.to_dict() - - failed_at: Union[None, Unset, str] - if isinstance(self.failed_at, Unset): - failed_at = UNSET - elif isinstance(self.failed_at, datetime.datetime): - failed_at = self.failed_at.isoformat() - else: - failed_at = self.failed_at - - completed_at: Union[None, Unset, str] - if isinstance(self.completed_at, Unset): - completed_at = UNSET - elif isinstance(self.completed_at, datetime.datetime): - completed_at = self.completed_at.isoformat() - else: - completed_at = self.completed_at - - processing_started: Union[None, Unset, str] - if isinstance(self.processing_started, Unset): - processing_started = UNSET - elif isinstance(self.processing_started, datetime.datetime): - processing_started = self.processing_started.isoformat() - else: - processing_started = self.processing_started - - migration_name: Union[None, Unset, str] - if isinstance(self.migration_name, Unset): - migration_name = UNSET - else: - migration_name = self.migration_name - - monitor_batch_id: Union[None, Unset, str] - if isinstance(self.monitor_batch_id, Unset): - monitor_batch_id = UNSET - else: - monitor_batch_id = self.monitor_batch_id - - error_message: Union[None, Unset, str] - if isinstance(self.error_message, Unset): - error_message = UNSET - else: - error_message = self.error_message - - progress_message: Union[None, Unset, str] - if isinstance(self.progress_message, Unset): - progress_message = UNSET - else: - progress_message = self.progress_message - - steps_completed = self.steps_completed - - steps_total = self.steps_total - - progress_percent = self.progress_percent - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "id": id, - "created_at": created_at, - "updated_at": updated_at, - "job_name": job_name, - "project_id": project_id, - "run_id": run_id, - "status": status, - "retries": retries, - "request_data": request_data, - } - ) - if failed_at is not UNSET: - field_dict["failed_at"] = failed_at - if completed_at is not UNSET: - field_dict["completed_at"] = completed_at - if processing_started is not UNSET: - field_dict["processing_started"] = processing_started - if migration_name is not UNSET: - field_dict["migration_name"] = migration_name - if monitor_batch_id is not UNSET: - field_dict["monitor_batch_id"] = monitor_batch_id - if error_message is not UNSET: - field_dict["error_message"] = error_message - if progress_message is not UNSET: - field_dict["progress_message"] = progress_message - if steps_completed is not UNSET: - field_dict["steps_completed"] = steps_completed - if steps_total is not UNSET: - field_dict["steps_total"] = steps_total - if progress_percent is not UNSET: - field_dict["progress_percent"] = progress_percent - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.job_db_request_data import JobDBRequestData - - d = dict(src_dict) - id = d.pop("id") - - created_at = isoparse(d.pop("created_at")) - - updated_at = isoparse(d.pop("updated_at")) - - job_name = d.pop("job_name") - - project_id = d.pop("project_id") - - run_id = d.pop("run_id") - - status = d.pop("status") - - retries = d.pop("retries") - - request_data = JobDBRequestData.from_dict(d.pop("request_data")) - - def _parse_failed_at(data: object) -> Union[None, Unset, datetime.datetime]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, str): - raise TypeError() - failed_at_type_0 = isoparse(data) - - return failed_at_type_0 - except: # noqa: E722 - pass - return cast(Union[None, Unset, datetime.datetime], data) - - failed_at = _parse_failed_at(d.pop("failed_at", UNSET)) - - def _parse_completed_at(data: object) -> Union[None, Unset, datetime.datetime]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, str): - raise TypeError() - completed_at_type_0 = isoparse(data) - - return completed_at_type_0 - except: # noqa: E722 - pass - return cast(Union[None, Unset, datetime.datetime], data) - - completed_at = _parse_completed_at(d.pop("completed_at", UNSET)) - - def _parse_processing_started(data: object) -> Union[None, Unset, datetime.datetime]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, str): - raise TypeError() - processing_started_type_0 = isoparse(data) - - return processing_started_type_0 - except: # noqa: E722 - pass - return cast(Union[None, Unset, datetime.datetime], data) - - processing_started = _parse_processing_started(d.pop("processing_started", UNSET)) - - def _parse_migration_name(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - migration_name = _parse_migration_name(d.pop("migration_name", UNSET)) - - def _parse_monitor_batch_id(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - monitor_batch_id = _parse_monitor_batch_id(d.pop("monitor_batch_id", UNSET)) - - def _parse_error_message(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - error_message = _parse_error_message(d.pop("error_message", UNSET)) - - def _parse_progress_message(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - progress_message = _parse_progress_message(d.pop("progress_message", UNSET)) - - steps_completed = d.pop("steps_completed", UNSET) - - steps_total = d.pop("steps_total", UNSET) - - progress_percent = d.pop("progress_percent", UNSET) - - job_db = cls( - id=id, - created_at=created_at, - updated_at=updated_at, - job_name=job_name, - project_id=project_id, - run_id=run_id, - status=status, - retries=retries, - request_data=request_data, - failed_at=failed_at, - completed_at=completed_at, - processing_started=processing_started, - migration_name=migration_name, - monitor_batch_id=monitor_batch_id, - error_message=error_message, - progress_message=progress_message, - steps_completed=steps_completed, - steps_total=steps_total, - progress_percent=progress_percent, - ) - - job_db.additional_properties = d - return job_db - - @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 diff --git a/src/splunk_ao/resources/models/job_db_request_data.py b/src/splunk_ao/resources/models/job_db_request_data.py deleted file mode 100644 index 3f3db2f4..00000000 --- a/src/splunk_ao/resources/models/job_db_request_data.py +++ /dev/null @@ -1,44 +0,0 @@ -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="JobDBRequestData") - - -@_attrs_define -class JobDBRequestData: - """ """ - - 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) - job_db_request_data = cls() - - job_db_request_data.additional_properties = d - return job_db_request_data - - @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 diff --git a/src/splunk_ao/resources/models/prompt_perplexity_scorer.py b/src/splunk_ao/resources/models/prompt_perplexity_scorer.py deleted file mode 100644 index c44a0686..00000000 --- a/src/splunk_ao/resources/models/prompt_perplexity_scorer.py +++ /dev/null @@ -1,146 +0,0 @@ -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, 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.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - -T = TypeVar("T", bound="PromptPerplexityScorer") - - -@_attrs_define -class PromptPerplexityScorer: - """ - Attributes: - name (Union[Literal['prompt_perplexity'], Unset]): Default: 'prompt_perplexity'. - filters (Union[None, Unset, list[Union['MetadataFilter', 'ModalityFilter', 'NodeNameFilter']]]): List of filters - to apply to the scorer. - """ - - name: Union[Literal["prompt_perplexity"], Unset] = "prompt_perplexity" - filters: Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - from ..models.metadata_filter import MetadataFilter - from ..models.node_name_filter import NodeNameFilter - - name = self.name - - filters: Union[None, Unset, list[dict[str, Any]]] - if isinstance(self.filters, Unset): - filters = UNSET - elif isinstance(self.filters, list): - filters = [] - for filters_type_0_item_data in self.filters: - filters_type_0_item: dict[str, Any] - if isinstance(filters_type_0_item_data, NodeNameFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - elif isinstance(filters_type_0_item_data, MetadataFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - else: - filters_type_0_item = filters_type_0_item_data.to_dict() - - filters.append(filters_type_0_item) - - else: - filters = self.filters - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if name is not UNSET: - field_dict["name"] = name - if filters is not UNSET: - field_dict["filters"] = filters - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - d = dict(src_dict) - name = cast(Union[Literal["prompt_perplexity"], Unset], d.pop("name", UNSET)) - if name != "prompt_perplexity" and not isinstance(name, Unset): - raise ValueError(f"name must match const 'prompt_perplexity', got '{name}'") - - def _parse_filters( - data: object, - ) -> Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, list): - raise TypeError() - filters_type_0 = [] - _filters_type_0 = data - for filters_type_0_item_data in _filters_type_0: - - def _parse_filters_type_0_item( - data: object, - ) -> Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]: - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_0 = NodeNameFilter.from_dict(data) - - return filters_type_0_item_type_0 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_1 = MetadataFilter.from_dict(data) - - return filters_type_0_item_type_1 - except: # noqa: E722 - pass - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_2 = ModalityFilter.from_dict(data) - - return filters_type_0_item_type_2 - - filters_type_0_item = _parse_filters_type_0_item(filters_type_0_item_data) - - filters_type_0.append(filters_type_0_item) - - return filters_type_0 - except: # noqa: E722 - pass - return cast(Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]], data) - - filters = _parse_filters(d.pop("filters", UNSET)) - - prompt_perplexity_scorer = cls(name=name, filters=filters) - - prompt_perplexity_scorer.additional_properties = d - return prompt_perplexity_scorer - - @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 diff --git a/src/splunk_ao/resources/models/rouge_scorer.py b/src/splunk_ao/resources/models/rouge_scorer.py deleted file mode 100644 index 94129392..00000000 --- a/src/splunk_ao/resources/models/rouge_scorer.py +++ /dev/null @@ -1,146 +0,0 @@ -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, 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.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - -T = TypeVar("T", bound="RougeScorer") - - -@_attrs_define -class RougeScorer: - """ - Attributes: - name (Union[Literal['rouge'], Unset]): Default: 'rouge'. - filters (Union[None, Unset, list[Union['MetadataFilter', 'ModalityFilter', 'NodeNameFilter']]]): List of filters - to apply to the scorer. - """ - - name: Union[Literal["rouge"], Unset] = "rouge" - filters: Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - from ..models.metadata_filter import MetadataFilter - from ..models.node_name_filter import NodeNameFilter - - name = self.name - - filters: Union[None, Unset, list[dict[str, Any]]] - if isinstance(self.filters, Unset): - filters = UNSET - elif isinstance(self.filters, list): - filters = [] - for filters_type_0_item_data in self.filters: - filters_type_0_item: dict[str, Any] - if isinstance(filters_type_0_item_data, NodeNameFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - elif isinstance(filters_type_0_item_data, MetadataFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - else: - filters_type_0_item = filters_type_0_item_data.to_dict() - - filters.append(filters_type_0_item) - - else: - filters = self.filters - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if name is not UNSET: - field_dict["name"] = name - if filters is not UNSET: - field_dict["filters"] = filters - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - d = dict(src_dict) - name = cast(Union[Literal["rouge"], Unset], d.pop("name", UNSET)) - if name != "rouge" and not isinstance(name, Unset): - raise ValueError(f"name must match const 'rouge', got '{name}'") - - def _parse_filters( - data: object, - ) -> Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, list): - raise TypeError() - filters_type_0 = [] - _filters_type_0 = data - for filters_type_0_item_data in _filters_type_0: - - def _parse_filters_type_0_item( - data: object, - ) -> Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]: - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_0 = NodeNameFilter.from_dict(data) - - return filters_type_0_item_type_0 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_1 = MetadataFilter.from_dict(data) - - return filters_type_0_item_type_1 - except: # noqa: E722 - pass - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_2 = ModalityFilter.from_dict(data) - - return filters_type_0_item_type_2 - - filters_type_0_item = _parse_filters_type_0_item(filters_type_0_item_data) - - filters_type_0.append(filters_type_0_item) - - return filters_type_0 - except: # noqa: E722 - pass - return cast(Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]], data) - - filters = _parse_filters(d.pop("filters", UNSET)) - - rouge_scorer = cls(name=name, filters=filters) - - rouge_scorer.additional_properties = d - return rouge_scorer - - @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 diff --git a/src/splunk_ao/resources/models/run_db.py b/src/splunk_ao/resources/models/run_db.py index 84ba8868..9db9e5ed 100644 --- a/src/splunk_ao/resources/models/run_db.py +++ b/src/splunk_ao/resources/models/run_db.py @@ -33,6 +33,7 @@ class RunDB: project_id (Union[None, Unset, str]): dataset_hash (Union[None, Unset, str]): dataset_version_id (Union[None, Unset, str]): + prompt_template_version_id (Union[None, Unset, str]): task_type (Union[None, TaskType, Unset]): run_tags (Union[Unset, list['RunTagDB']]): example_content_id (Union[None, Unset, str]): @@ -52,6 +53,7 @@ class RunDB: project_id: Union[None, Unset, str] = UNSET dataset_hash: Union[None, Unset, str] = UNSET dataset_version_id: Union[None, Unset, str] = UNSET + prompt_template_version_id: Union[None, Unset, str] = UNSET task_type: Union[None, TaskType, Unset] = UNSET run_tags: Union[Unset, list["RunTagDB"]] = UNSET example_content_id: Union[None, Unset, str] = UNSET @@ -100,6 +102,12 @@ def to_dict(self) -> dict[str, Any]: else: dataset_version_id = self.dataset_version_id + prompt_template_version_id: Union[None, Unset, str] + if isinstance(self.prompt_template_version_id, Unset): + prompt_template_version_id = UNSET + else: + prompt_template_version_id = self.prompt_template_version_id + task_type: Union[None, Unset, int] if isinstance(self.task_type, Unset): task_type = UNSET @@ -151,6 +159,8 @@ def to_dict(self) -> dict[str, Any]: field_dict["dataset_hash"] = dataset_hash if dataset_version_id is not UNSET: field_dict["dataset_version_id"] = dataset_version_id + if prompt_template_version_id is not UNSET: + field_dict["prompt_template_version_id"] = prompt_template_version_id if task_type is not UNSET: field_dict["task_type"] = task_type if run_tags is not UNSET: @@ -222,6 +232,15 @@ def _parse_dataset_version_id(data: object) -> Union[None, Unset, str]: dataset_version_id = _parse_dataset_version_id(d.pop("dataset_version_id", UNSET)) + def _parse_prompt_template_version_id(data: object) -> Union[None, Unset, str]: + if data is None: + return data + if isinstance(data, Unset): + return data + return cast(Union[None, Unset, str], data) + + prompt_template_version_id = _parse_prompt_template_version_id(d.pop("prompt_template_version_id", UNSET)) + def _parse_task_type(data: object) -> Union[None, TaskType, Unset]: if data is None: return data @@ -272,6 +291,7 @@ def _parse_example_content_id(data: object) -> Union[None, Unset, str]: project_id=project_id, dataset_hash=dataset_hash, dataset_version_id=dataset_version_id, + prompt_template_version_id=prompt_template_version_id, task_type=task_type, run_tags=run_tags, example_content_id=example_content_id, diff --git a/src/splunk_ao/resources/models/run_db_thin.py b/src/splunk_ao/resources/models/run_db_thin.py index 23bed747..916583dc 100644 --- a/src/splunk_ao/resources/models/run_db_thin.py +++ b/src/splunk_ao/resources/models/run_db_thin.py @@ -33,6 +33,7 @@ class RunDBThin: project_id (Union[None, Unset, str]): dataset_hash (Union[None, Unset, str]): dataset_version_id (Union[None, Unset, str]): + prompt_template_version_id (Union[None, Unset, str]): task_type (Union[None, TaskType, Unset]): run_tags (Union[Unset, list['RunTagDB']]): example_content_id (Union[None, Unset, str]): @@ -52,6 +53,7 @@ class RunDBThin: project_id: Union[None, Unset, str] = UNSET dataset_hash: Union[None, Unset, str] = UNSET dataset_version_id: Union[None, Unset, str] = UNSET + prompt_template_version_id: Union[None, Unset, str] = UNSET task_type: Union[None, TaskType, Unset] = UNSET run_tags: Union[Unset, list["RunTagDB"]] = UNSET example_content_id: Union[None, Unset, str] = UNSET @@ -100,6 +102,12 @@ def to_dict(self) -> dict[str, Any]: else: dataset_version_id = self.dataset_version_id + prompt_template_version_id: Union[None, Unset, str] + if isinstance(self.prompt_template_version_id, Unset): + prompt_template_version_id = UNSET + else: + prompt_template_version_id = self.prompt_template_version_id + task_type: Union[None, Unset, int] if isinstance(self.task_type, Unset): task_type = UNSET @@ -151,6 +159,8 @@ def to_dict(self) -> dict[str, Any]: field_dict["dataset_hash"] = dataset_hash if dataset_version_id is not UNSET: field_dict["dataset_version_id"] = dataset_version_id + if prompt_template_version_id is not UNSET: + field_dict["prompt_template_version_id"] = prompt_template_version_id if task_type is not UNSET: field_dict["task_type"] = task_type if run_tags is not UNSET: @@ -222,6 +232,15 @@ def _parse_dataset_version_id(data: object) -> Union[None, Unset, str]: dataset_version_id = _parse_dataset_version_id(d.pop("dataset_version_id", UNSET)) + def _parse_prompt_template_version_id(data: object) -> Union[None, Unset, str]: + if data is None: + return data + if isinstance(data, Unset): + return data + return cast(Union[None, Unset, str], data) + + prompt_template_version_id = _parse_prompt_template_version_id(d.pop("prompt_template_version_id", UNSET)) + def _parse_task_type(data: object) -> Union[None, TaskType, Unset]: if data is None: return data @@ -272,6 +291,7 @@ def _parse_example_content_id(data: object) -> Union[None, Unset, str]: project_id=project_id, dataset_hash=dataset_hash, dataset_version_id=dataset_version_id, + prompt_template_version_id=prompt_template_version_id, task_type=task_type, run_tags=run_tags, example_content_id=example_content_id, diff --git a/src/splunk_ao/resources/models/scorer_name.py b/src/splunk_ao/resources/models/scorer_name.py index f5eb6196..3fb142d2 100644 --- a/src/splunk_ao/resources/models/scorer_name.py +++ b/src/splunk_ao/resources/models/scorer_name.py @@ -4,66 +4,62 @@ class ScorerName(str, Enum): VALUE_0 = "_completeness_gpt" VALUE_1 = "_context_adherence_luna" - VALUE_10 = "_prompt_perplexity" - VALUE_11 = "_protect_status" - VALUE_12 = "_pii" - VALUE_13 = "_input_pii" - VALUE_14 = "_sexist" - VALUE_15 = "_input_sexist" - VALUE_16 = "_sexist_gpt" - VALUE_17 = "_input_sexist_gpt" - VALUE_18 = "_tone" - VALUE_19 = "_input_tone" + VALUE_10 = "_protect_status" + VALUE_11 = "_pii" + VALUE_12 = "_input_pii" + VALUE_13 = "_sexist" + VALUE_14 = "_input_sexist" + VALUE_15 = "_sexist_gpt" + VALUE_16 = "_input_sexist_gpt" + VALUE_17 = "_tone" + VALUE_18 = "_input_tone" + VALUE_19 = "_toxicity" VALUE_2 = "_context_relevance" - VALUE_20 = "_toxicity" - VALUE_21 = "_toxicity_gpt" - VALUE_22 = "_input_toxicity" - VALUE_23 = "_input_toxicity_gpt" - VALUE_24 = "_user_registered" - VALUE_25 = "_composite_user_registered" - VALUE_26 = "_user_submitted" - VALUE_27 = "_user_generated" - VALUE_28 = "_user_finetuned" - VALUE_29 = "_uncertainty" + VALUE_20 = "_toxicity_gpt" + VALUE_21 = "_input_toxicity" + VALUE_22 = "_input_toxicity_gpt" + VALUE_23 = "_user_registered" + VALUE_24 = "_composite_user_registered" + VALUE_25 = "_user_submitted" + VALUE_26 = "_user_generated" + VALUE_27 = "_user_finetuned" + VALUE_28 = "_cost" + VALUE_29 = "_prompt_injection_gpt" VALUE_3 = "_context_relevance_luna" - VALUE_30 = "_bleu" - VALUE_31 = "_cost" - VALUE_32 = "_rouge" - VALUE_33 = "_prompt_injection_gpt" - VALUE_34 = "_prompt_injection" - VALUE_35 = "_rag_nli" - VALUE_36 = "_adherence_nli" - VALUE_37 = "_completeness_nli" - VALUE_38 = "_chunk_attribution_utilization_nli" - VALUE_39 = "_instruction_adherence" + VALUE_30 = "_prompt_injection" + VALUE_31 = "_rag_nli" + VALUE_32 = "_adherence_nli" + VALUE_33 = "_completeness_nli" + VALUE_34 = "_chunk_attribution_utilization_nli" + VALUE_35 = "_instruction_adherence" + VALUE_36 = "_ground_truth_adherence" + VALUE_37 = "_tool_selection_quality" + VALUE_38 = "_tool_selection_quality_luna" + VALUE_39 = "_tool_error_rate" VALUE_4 = "_chunk_relevance_luna" - VALUE_40 = "_ground_truth_adherence" - VALUE_41 = "_tool_selection_quality" - VALUE_42 = "_tool_selection_quality_luna" - VALUE_43 = "_tool_error_rate" - VALUE_44 = "_tool_error_rate_luna" - VALUE_45 = "_action_completion_luna" - VALUE_46 = "_agentic_session_success" - VALUE_47 = "_action_advancement_luna" - VALUE_48 = "_agentic_workflow_success" - VALUE_49 = "_generic_wizard" + VALUE_40 = "_tool_error_rate_luna" + VALUE_41 = "_action_completion_luna" + VALUE_42 = "_agentic_session_success" + VALUE_43 = "_action_advancement_luna" + VALUE_44 = "_agentic_workflow_success" + VALUE_45 = "_generic_wizard" + VALUE_46 = "_customized_completeness_gpt" + VALUE_47 = "_customized_factuality" + VALUE_48 = "_customized_groundedness" + VALUE_49 = "_customized_chunk_attribution_utilization_gpt" VALUE_5 = "_completeness_luna" - VALUE_50 = "_customized_completeness_gpt" - VALUE_51 = "_customized_factuality" - VALUE_52 = "_customized_groundedness" - VALUE_53 = "_customized_chunk_attribution_utilization_gpt" - VALUE_54 = "_customized_instruction_adherence" - VALUE_55 = "_customized_ground_truth_adherence" - VALUE_56 = "_customized_prompt_injection_gpt" - VALUE_57 = "_customized_tool_selection_quality" - VALUE_58 = "_customized_tool_error_rate" - VALUE_59 = "_customized_agentic_session_success" + VALUE_50 = "_customized_instruction_adherence" + VALUE_51 = "_customized_ground_truth_adherence" + VALUE_52 = "_customized_prompt_injection_gpt" + VALUE_53 = "_customized_tool_selection_quality" + VALUE_54 = "_customized_tool_error_rate" + VALUE_55 = "_customized_agentic_session_success" + VALUE_56 = "_customized_agentic_workflow_success" + VALUE_57 = "_customized_sexist_gpt" + VALUE_58 = "_customized_input_sexist_gpt" + VALUE_59 = "_customized_toxicity_gpt" VALUE_6 = "_chunk_attribution_utilization_gpt" - VALUE_60 = "_customized_agentic_workflow_success" - VALUE_61 = "_customized_sexist_gpt" - VALUE_62 = "_customized_input_sexist_gpt" - VALUE_63 = "_customized_toxicity_gpt" - VALUE_64 = "_customized_input_toxicity_gpt" + VALUE_60 = "_customized_input_toxicity_gpt" VALUE_7 = "_factuality" VALUE_8 = "_groundedness" VALUE_9 = "_latency" diff --git a/src/splunk_ao/resources/models/scorers_configuration.py b/src/splunk_ao/resources/models/scorers_configuration.py index 07f5e092..655c00bb 100644 --- a/src/splunk_ao/resources/models/scorers_configuration.py +++ b/src/splunk_ao/resources/models/scorers_configuration.py @@ -21,8 +21,6 @@ class ScorersConfiguration: cost (Union[Unset, bool]): Default: True. pii (Union[Unset, bool]): Default: False. input_pii (Union[Unset, bool]): Default: False. - bleu (Union[Unset, bool]): Default: True. - rouge (Union[Unset, bool]): Default: True. protect_status (Union[Unset, bool]): Default: True. context_relevance (Union[Unset, bool]): Default: False. toxicity (Union[Unset, bool]): Default: False. @@ -43,10 +41,8 @@ class ScorersConfiguration: tool_selection_quality_luna (Union[Unset, bool]): Default: False. action_completion_luna (Union[Unset, bool]): Default: False. action_advancement_luna (Union[Unset, bool]): Default: False. - uncertainty (Union[Unset, bool]): Default: False. factuality (Union[Unset, bool]): Default: False. groundedness (Union[Unset, bool]): Default: False. - prompt_perplexity (Union[Unset, bool]): Default: False. chunk_attribution_utilization_gpt (Union[Unset, bool]): Default: False. completeness_gpt (Union[Unset, bool]): Default: False. instruction_adherence (Union[Unset, bool]): Default: False. @@ -66,8 +62,6 @@ class ScorersConfiguration: cost: Union[Unset, bool] = True pii: Union[Unset, bool] = False input_pii: Union[Unset, bool] = False - bleu: Union[Unset, bool] = True - rouge: Union[Unset, bool] = True protect_status: Union[Unset, bool] = True context_relevance: Union[Unset, bool] = False toxicity: Union[Unset, bool] = False @@ -88,10 +82,8 @@ class ScorersConfiguration: tool_selection_quality_luna: Union[Unset, bool] = False action_completion_luna: Union[Unset, bool] = False action_advancement_luna: Union[Unset, bool] = False - uncertainty: Union[Unset, bool] = False factuality: Union[Unset, bool] = False groundedness: Union[Unset, bool] = False - prompt_perplexity: Union[Unset, bool] = False chunk_attribution_utilization_gpt: Union[Unset, bool] = False completeness_gpt: Union[Unset, bool] = False instruction_adherence: Union[Unset, bool] = False @@ -116,10 +108,6 @@ def to_dict(self) -> dict[str, Any]: input_pii = self.input_pii - bleu = self.bleu - - rouge = self.rouge - protect_status = self.protect_status context_relevance = self.context_relevance @@ -160,14 +148,10 @@ def to_dict(self) -> dict[str, Any]: action_advancement_luna = self.action_advancement_luna - uncertainty = self.uncertainty - factuality = self.factuality groundedness = self.groundedness - prompt_perplexity = self.prompt_perplexity - chunk_attribution_utilization_gpt = self.chunk_attribution_utilization_gpt completeness_gpt = self.completeness_gpt @@ -205,10 +189,6 @@ def to_dict(self) -> dict[str, Any]: field_dict["pii"] = pii if input_pii is not UNSET: field_dict["input_pii"] = input_pii - if bleu is not UNSET: - field_dict["bleu"] = bleu - if rouge is not UNSET: - field_dict["rouge"] = rouge if protect_status is not UNSET: field_dict["protect_status"] = protect_status if context_relevance is not UNSET: @@ -249,14 +229,10 @@ def to_dict(self) -> dict[str, Any]: field_dict["action_completion_luna"] = action_completion_luna if action_advancement_luna is not UNSET: field_dict["action_advancement_luna"] = action_advancement_luna - if uncertainty is not UNSET: - field_dict["uncertainty"] = uncertainty if factuality is not UNSET: field_dict["factuality"] = factuality if groundedness is not UNSET: field_dict["groundedness"] = groundedness - if prompt_perplexity is not UNSET: - field_dict["prompt_perplexity"] = prompt_perplexity if chunk_attribution_utilization_gpt is not UNSET: field_dict["chunk_attribution_utilization_gpt"] = chunk_attribution_utilization_gpt if completeness_gpt is not UNSET: @@ -297,10 +273,6 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: input_pii = d.pop("input_pii", UNSET) - bleu = d.pop("bleu", UNSET) - - rouge = d.pop("rouge", UNSET) - protect_status = d.pop("protect_status", UNSET) context_relevance = d.pop("context_relevance", UNSET) @@ -341,14 +313,10 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: action_advancement_luna = d.pop("action_advancement_luna", UNSET) - uncertainty = d.pop("uncertainty", UNSET) - factuality = d.pop("factuality", UNSET) groundedness = d.pop("groundedness", UNSET) - prompt_perplexity = d.pop("prompt_perplexity", UNSET) - chunk_attribution_utilization_gpt = d.pop("chunk_attribution_utilization_gpt", UNSET) completeness_gpt = d.pop("completeness_gpt", UNSET) @@ -380,8 +348,6 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: cost=cost, pii=pii, input_pii=input_pii, - bleu=bleu, - rouge=rouge, protect_status=protect_status, context_relevance=context_relevance, toxicity=toxicity, @@ -402,10 +368,8 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: tool_selection_quality_luna=tool_selection_quality_luna, action_completion_luna=action_completion_luna, action_advancement_luna=action_advancement_luna, - uncertainty=uncertainty, factuality=factuality, groundedness=groundedness, - prompt_perplexity=prompt_perplexity, chunk_attribution_utilization_gpt=chunk_attribution_utilization_gpt, completeness_gpt=completeness_gpt, instruction_adherence=instruction_adherence, diff --git a/src/splunk_ao/resources/models/uncertainty_scorer.py b/src/splunk_ao/resources/models/uncertainty_scorer.py deleted file mode 100644 index bd66fdc8..00000000 --- a/src/splunk_ao/resources/models/uncertainty_scorer.py +++ /dev/null @@ -1,146 +0,0 @@ -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, 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.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - -T = TypeVar("T", bound="UncertaintyScorer") - - -@_attrs_define -class UncertaintyScorer: - """ - Attributes: - name (Union[Literal['uncertainty'], Unset]): Default: 'uncertainty'. - filters (Union[None, Unset, list[Union['MetadataFilter', 'ModalityFilter', 'NodeNameFilter']]]): List of filters - to apply to the scorer. - """ - - name: Union[Literal["uncertainty"], Unset] = "uncertainty" - filters: Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - from ..models.metadata_filter import MetadataFilter - from ..models.node_name_filter import NodeNameFilter - - name = self.name - - filters: Union[None, Unset, list[dict[str, Any]]] - if isinstance(self.filters, Unset): - filters = UNSET - elif isinstance(self.filters, list): - filters = [] - for filters_type_0_item_data in self.filters: - filters_type_0_item: dict[str, Any] - if isinstance(filters_type_0_item_data, NodeNameFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - elif isinstance(filters_type_0_item_data, MetadataFilter): - filters_type_0_item = filters_type_0_item_data.to_dict() - else: - filters_type_0_item = filters_type_0_item_data.to_dict() - - filters.append(filters_type_0_item) - - else: - filters = self.filters - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if name is not UNSET: - field_dict["name"] = name - if filters is not UNSET: - field_dict["filters"] = filters - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.metadata_filter import MetadataFilter - from ..models.modality_filter import ModalityFilter - from ..models.node_name_filter import NodeNameFilter - - d = dict(src_dict) - name = cast(Union[Literal["uncertainty"], Unset], d.pop("name", UNSET)) - if name != "uncertainty" and not isinstance(name, Unset): - raise ValueError(f"name must match const 'uncertainty', got '{name}'") - - def _parse_filters( - data: object, - ) -> Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, list): - raise TypeError() - filters_type_0 = [] - _filters_type_0 = data - for filters_type_0_item_data in _filters_type_0: - - def _parse_filters_type_0_item( - data: object, - ) -> Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]: - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_0 = NodeNameFilter.from_dict(data) - - return filters_type_0_item_type_0 - except: # noqa: E722 - pass - try: - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_1 = MetadataFilter.from_dict(data) - - return filters_type_0_item_type_1 - except: # noqa: E722 - pass - if not isinstance(data, dict): - raise TypeError() - filters_type_0_item_type_2 = ModalityFilter.from_dict(data) - - return filters_type_0_item_type_2 - - filters_type_0_item = _parse_filters_type_0_item(filters_type_0_item_data) - - filters_type_0.append(filters_type_0_item) - - return filters_type_0 - except: # noqa: E722 - pass - return cast(Union[None, Unset, list[Union["MetadataFilter", "ModalityFilter", "NodeNameFilter"]]], data) - - filters = _parse_filters(d.pop("filters", UNSET)) - - uncertainty_scorer = cls(name=name, filters=filters) - - uncertainty_scorer.additional_properties = d - return uncertainty_scorer - - @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