eval-studio-client 1.2.5__py3-none-any.whl → 1.3.0a1__py3-none-any.whl

eval_studio_client/api/models/v1_comparison_result.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+    ai/h2o/eval_studio/v1/insight.proto
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: version not set
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from eval_studio_client.api.models.v1_diff_item import V1DiffItem
+from eval_studio_client.api.models.v1_leaderboard_info import V1LeaderboardInfo
+from eval_studio_client.api.models.v1_metric_meta import V1MetricMeta
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1ComparisonResult(BaseModel):
+    """
+    V1ComparisonResult
+    """ # noqa: E501
+    diffs: Optional[List[V1DiffItem]] = Field(default=None, description="List of differences between leaderboards.")
+    leaderboards: Optional[List[V1LeaderboardInfo]] = Field(default=None, description="Leaderboard information.")
+    metrics_meta: Optional[Dict[str, V1MetricMeta]] = Field(default=None, description="Metadata about metrics.", alias="metricsMeta")
+    __properties: ClassVar[List[str]] = ["diffs", "leaderboards", "metricsMeta"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1ComparisonResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in diffs (list)
+        _items = []
+        if self.diffs:
+            for _item_diffs in self.diffs:
+                if _item_diffs:
+                    _items.append(_item_diffs.to_dict())
+            _dict['diffs'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in leaderboards (list)
+        _items = []
+        if self.leaderboards:
+            for _item_leaderboards in self.leaderboards:
+                if _item_leaderboards:
+                    _items.append(_item_leaderboards.to_dict())
+            _dict['leaderboards'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each value in metrics_meta (dict)
+        _field_dict = {}
+        if self.metrics_meta:
+            for _key_metrics_meta in self.metrics_meta:
+                if self.metrics_meta[_key_metrics_meta]:
+                    _field_dict[_key_metrics_meta] = self.metrics_meta[_key_metrics_meta].to_dict()
+            _dict['metricsMeta'] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1ComparisonResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj, strict=False)
+
+        _obj = cls.model_validate({
+            "diffs": [V1DiffItem.from_dict(_item) for _item in obj["diffs"]] if obj.get("diffs") is not None else None,
+            "leaderboards": [V1LeaderboardInfo.from_dict(_item) for _item in obj["leaderboards"]] if obj.get("leaderboards") is not None else None,
+            "metricsMeta": dict(
+                (_k, V1MetricMeta.from_dict(_v))
+                for _k, _v in obj["metricsMeta"].items()
+            )
+            if obj.get("metricsMeta") is not None
+            else None
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_comparison_summary.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    ai/h2o/eval_studio/v1/insight.proto
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: version not set
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1ComparisonSummary(BaseModel):
+    """
+    V1ComparisonSummary
+    """ # noqa: E501
+    recommendation_winner: Optional[StrictStr] = Field(default=None, description="Winner of the comparison (baseline, current, or tie).", alias="recommendationWinner")
+    recommendation: Optional[StrictStr] = Field(default=None, description="Recommendation text.")
+    recommendation_confidence: Optional[StrictStr] = Field(default=None, description="Confidence level of the recommendation.", alias="recommendationConfidence")
+    __properties: ClassVar[List[str]] = ["recommendationWinner", "recommendation", "recommendationConfidence"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1ComparisonSummary from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1ComparisonSummary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj, strict=False)
+
+        _obj = cls.model_validate({
+            "recommendationWinner": obj.get("recommendationWinner"),
+            "recommendation": obj.get("recommendation"),
+            "recommendationConfidence": obj.get("recommendationConfidence")
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_create_evaluation_request.py

@@ -20,6 +20,7 @@ import json
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from eval_studio_client.api.models.v1_evaluation_test import V1EvaluationTest
+from eval_studio_client.api.models.v1_evaluation_type import V1EvaluationType
 from eval_studio_client.api.models.v1_model import V1Model
 from typing import Optional, Set
 from typing_extensions import Self
@@ -38,7 +39,8 @@ class V1CreateEvaluationRequest(BaseModel):
     model_parameters: Optional[StrictStr] = Field(default=None, description="Optional. Parameters overrides in JSON format.", alias="modelParameters")
     h2ogpte_collection: Optional[StrictStr] = Field(default=None, description="The existing collection name in H2OGPTe.", alias="h2ogpteCollection")
     default_h2ogpte_model: Optional[V1Model] = Field(default=None, alias="defaultH2ogpteModel")
-    __properties: ClassVar[List[str]] = ["evaluatorIdentifiers", "model", "evaluationTests", "operation", "llmModels", "useCache", "evaluatorsParameters", "modelParameters", "h2ogpteCollection", "defaultH2ogpteModel"]
+    evaluation_type: Optional[V1EvaluationType] = Field(default=None, alias="evaluationType")
+    __properties: ClassVar[List[str]] = ["evaluatorIdentifiers", "model", "evaluationTests", "operation", "llmModels", "useCache", "evaluatorsParameters", "modelParameters", "h2ogpteCollection", "defaultH2ogpteModel", "evaluationType"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -113,7 +115,8 @@ class V1CreateEvaluationRequest(BaseModel):
             "evaluatorsParameters": obj.get("evaluatorsParameters"),
             "modelParameters": obj.get("modelParameters"),
             "h2ogpteCollection": obj.get("h2ogpteCollection"),
-            "defaultH2ogpteModel": V1Model.from_dict(obj["defaultH2ogpteModel"]) if obj.get("defaultH2ogpteModel") is not None else None
+            "defaultH2ogpteModel": V1Model.from_dict(obj["defaultH2ogpteModel"]) if obj.get("defaultH2ogpteModel") is not None else None,
+            "evaluationType": obj.get("evaluationType")
         }, strict=False)
         return _obj
 

eval_studio_client/api/models/v1_create_test_from_test_cases_request.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    ai/h2o/eval_studio/v1/insight.proto
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: version not set
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1CreateTestFromTestCasesRequest(BaseModel):
+    """
+    V1CreateTestFromTestCasesRequest
+    """ # noqa: E501
+    tests_json: Optional[StrictStr] = Field(default=None, description="Test Cases in JSON format.", alias="testsJson")
+    url: Optional[StrictStr] = Field(default=None, description="URL pointing to the Test Cases in JSON format to import.")
+    test_display_name: Optional[StrictStr] = Field(default=None, description="Required. Display name of the newly created Test.", alias="testDisplayName")
+    test_description: Optional[StrictStr] = Field(default=None, description="Optional. Description of the newly created Tests.", alias="testDescription")
+    __properties: ClassVar[List[str]] = ["testsJson", "url", "testDisplayName", "testDescription"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1CreateTestFromTestCasesRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1CreateTestFromTestCasesRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj, strict=False)
+
+        _obj = cls.model_validate({
+            "testsJson": obj.get("testsJson"),
+            "url": obj.get("url"),
+            "testDisplayName": obj.get("testDisplayName"),
+            "testDescription": obj.get("testDescription")
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_create_test_from_test_cases_response.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    ai/h2o/eval_studio/v1/insight.proto
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: version not set
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from eval_studio_client.api.models.v1_test import V1Test
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1CreateTestFromTestCasesResponse(BaseModel):
+    """
+    V1CreateTestFromTestCasesResponse
+    """ # noqa: E501
+    test: Optional[V1Test] = None
+    __properties: ClassVar[List[str]] = ["test"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1CreateTestFromTestCasesResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of test
+        if self.test:
+            _dict['test'] = self.test.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1CreateTestFromTestCasesResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj, strict=False)
+
+        _obj = cls.model_validate({
+            "test": V1Test.from_dict(obj["test"]) if obj.get("test") is not None else None
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_dashboard_report.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    ai/h2o/eval_studio/v1/insight.proto
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: version not set
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from eval_studio_client.api.models.v1_dashboard_report_result import V1DashboardReportResult
+from eval_studio_client.api.models.v1_leaderboard_report_evaluator import V1LeaderboardReportEvaluator
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1DashboardReport(BaseModel):
+    """
+    DashboardReport represents the dashboard report which is formed by the results, models and evaluator.
+    """ # noqa: E501
+    results: Optional[List[V1DashboardReportResult]] = Field(default=None, description="Output only. List of per test case results.")
+    evaluator: Optional[List[V1LeaderboardReportEvaluator]] = Field(default=None, description="Output only. Details of the evaluators which evaluated the model outputs to create the results.")
+    __properties: ClassVar[List[str]] = ["results", "evaluator"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1DashboardReport from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "results",
+            "evaluator",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in results (list)
+        _items = []
+        if self.results:
+            for _item_results in self.results:
+                if _item_results:
+                    _items.append(_item_results.to_dict())
+            _dict['results'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in evaluator (list)
+        _items = []
+        if self.evaluator:
+            for _item_evaluator in self.evaluator:
+                if _item_evaluator:
+                    _items.append(_item_evaluator.to_dict())
+            _dict['evaluator'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1DashboardReport from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj, strict=False)
+
+        _obj = cls.model_validate({
+            "results": [V1DashboardReportResult.from_dict(_item) for _item in obj["results"]] if obj.get("results") is not None else None,
+            "evaluator": [V1LeaderboardReportEvaluator.from_dict(_item) for _item in obj["evaluator"]] if obj.get("evaluator") is not None else None
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_dashboard_report_result.py

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+    ai/h2o/eval_studio/v1/insight.proto
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: version not set
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from eval_studio_client.api.models.v1_human_decision import V1HumanDecision
+from eval_studio_client.api.models.v1_metric_scores import V1MetricScores
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1DashboardReportResult(BaseModel):
+    """
+    V1DashboardReportResult
+    """ # noqa: E501
+    key: Optional[StrictStr] = Field(default=None, description="Output only. Composite unique key of the result formed by the model key and test case key.")
+    input: Optional[StrictStr] = Field(default=None, description="Output only. Input prompt or text to be processed.")
+    expected_output: Optional[StrictStr] = Field(default=None, description="Output only. Expected output or target result.", alias="expectedOutput")
+    actual_output: Optional[StrictStr] = Field(default=None, description="Output only. Actual output produced by the model.", alias="actualOutput")
+    model_key: Optional[StrictStr] = Field(default=None, description="Output only. Unique identifier for the model used.", alias="modelKey")
+    test_case_key: Optional[StrictStr] = Field(default=None, description="Output only. Unique identifier for the test case.", alias="testCaseKey")
+    metrics: Optional[Dict[str, V1MetricScores]] = Field(default=None, description="Optional. All metrics values for the result. Maps evaluator ID to MetricScore.")
+    result_error_map: Optional[Dict[str, StrictStr]] = Field(default=None, description="Output only. Error message if processing resulted in failure. Maps evaluator ID to error message.", alias="resultErrorMap")
+    human_decision: Optional[V1HumanDecision] = Field(default=None, alias="humanDecision")
+    comment: Optional[StrictStr] = Field(default=None, description="Output only. Optional comment about the result.")
+    annotations: Optional[Dict[str, Dict[str, Any]]] = Field(default=None, description="Output only. Additional annotations for the result.")
+    __properties: ClassVar[List[str]] = ["key", "input", "expectedOutput", "actualOutput", "modelKey", "testCaseKey", "metrics", "resultErrorMap", "humanDecision", "comment", "annotations"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of V1DashboardReportResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "key",
+            "input",
+            "expected_output",
+            "actual_output",
+            "model_key",
+            "test_case_key",
+            "result_error_map",
+            "comment",
+            "annotations",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each value in metrics (dict)
+        _field_dict = {}
+        if self.metrics:
+            for _key_metrics in self.metrics:
+                if self.metrics[_key_metrics]:
+                    _field_dict[_key_metrics] = self.metrics[_key_metrics].to_dict()
+            _dict['metrics'] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1DashboardReportResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj, strict=False)
+
+        _obj = cls.model_validate({
+            "key": obj.get("key"),
+            "input": obj.get("input"),
+            "expectedOutput": obj.get("expectedOutput"),
+            "actualOutput": obj.get("actualOutput"),
+            "modelKey": obj.get("modelKey"),
+            "testCaseKey": obj.get("testCaseKey"),
+            "metrics": dict(
+                (_k, V1MetricScores.from_dict(_v))
+                for _k, _v in obj["metrics"].items()
+            )
+            if obj.get("metrics") is not None
+            else None,
+            "resultErrorMap": obj.get("resultErrorMap"),
+            "humanDecision": obj.get("humanDecision"),
+            "comment": obj.get("comment"),
+            "annotations": obj.get("annotations")
+        }, strict=False)
+        return _obj
+
+