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

eval_studio_client/api/models/v1_retrieved_context_diff.py

@@ -0,0 +1,101 @@
+# 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, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1RetrievedContextDiff(BaseModel):
+    """
+    V1RetrievedContextDiff
+    """ # noqa: E501
+    chunks: Optional[List[StrictStr]] = Field(default=None, description="Context chunks.")
+    chunks_count: Optional[StrictInt] = Field(default=None, description="Chunk count.", alias="chunksCount")
+    common_chunks: Optional[List[StrictStr]] = Field(default=None, description="Common chunks between baseline and current.", alias="commonChunks")
+    common_count: Optional[StrictInt] = Field(default=None, description="Common chunk count.", alias="commonCount")
+    unique_chunks: Optional[List[StrictStr]] = Field(default=None, description="Unique chunks.", alias="uniqueChunks")
+    unique_count: Optional[StrictInt] = Field(default=None, description="Unique chunk count.", alias="uniqueCount")
+    identical: Optional[StrictBool] = Field(default=None, description="Whether contexts are identical.")
+    chunk_similarity: Optional[Dict[str, Union[StrictFloat, StrictInt]]] = Field(default=None, description="Chunk similarity scores.", alias="chunkSimilarity")
+    __properties: ClassVar[List[str]] = ["chunks", "chunksCount", "commonChunks", "commonCount", "uniqueChunks", "uniqueCount", "identical", "chunkSimilarity"]
+
+    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 V1RetrievedContextDiff 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 V1RetrievedContextDiff 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({
+            "chunks": obj.get("chunks"),
+            "chunksCount": obj.get("chunksCount"),
+            "commonChunks": obj.get("commonChunks"),
+            "commonCount": obj.get("commonCount"),
+            "uniqueChunks": obj.get("uniqueChunks"),
+            "uniqueCount": obj.get("uniqueCount"),
+            "identical": obj.get("identical"),
+            "chunkSimilarity": obj.get("chunkSimilarity")
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_stats.py

@@ -29,7 +29,9 @@ class V1Stats(BaseModel):
     topic_modeling_pending_jobs: Optional[StrictStr] = Field(default=None, description="Number of pending jobs in the topic modeling queue. It's marked as optional to always be part of the response, even when the value is zero.", alias="topicModelingPendingJobs")
     test_validation_pending_jobs: Optional[StrictStr] = Field(default=None, description="Number of pending jobs in the test validation queue. It's marked as optional to always be part of the response, even when the value is zero.", alias="testValidationPendingJobs")
     failure_clustering_pending_jobs: Optional[StrictStr] = Field(default=None, description="Number of pending jobs in the failure clustering queue. It's marked as optional to always be part of the response, even when the value is zero.", alias="failureClusteringPendingJobs")
-    __properties: ClassVar[List[str]] = ["topicModelingPendingJobs", "testValidationPendingJobs", "failureClusteringPendingJobs"]
+    test_case_import_pending_jobs: Optional[StrictStr] = Field(default=None, description="Number of pending jobs in the test case import queue. It's marked as optional to always be part of the response, even when the value is zero.", alias="testCaseImportPendingJobs")
+    evaluation_worker_queue_length: Optional[StrictStr] = Field(default=None, description="Number of pending jobs in the evaluation worker queue. It's marked as optional to always be part of the response, even when the value is zero.", alias="evaluationWorkerQueueLength")
+    __properties: ClassVar[List[str]] = ["topicModelingPendingJobs", "testValidationPendingJobs", "failureClusteringPendingJobs", "testCaseImportPendingJobs", "evaluationWorkerQueueLength"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -85,6 +87,16 @@ class V1Stats(BaseModel):
         if self.failure_clustering_pending_jobs is None and "failure_clustering_pending_jobs" in self.model_fields_set:
             _dict['failureClusteringPendingJobs'] = None
 
+        # set to None if test_case_import_pending_jobs (nullable) is None
+        # and model_fields_set contains the field
+        if self.test_case_import_pending_jobs is None and "test_case_import_pending_jobs" in self.model_fields_set:
+            _dict['testCaseImportPendingJobs'] = None
+
+        # set to None if evaluation_worker_queue_length (nullable) is None
+        # and model_fields_set contains the field
+        if self.evaluation_worker_queue_length is None and "evaluation_worker_queue_length" in self.model_fields_set:
+            _dict['evaluationWorkerQueueLength'] = None
+
         return _dict
 
     @classmethod
@@ -99,7 +111,9 @@ class V1Stats(BaseModel):
         _obj = cls.model_validate({
             "topicModelingPendingJobs": obj.get("topicModelingPendingJobs"),
             "testValidationPendingJobs": obj.get("testValidationPendingJobs"),
-            "failureClusteringPendingJobs": obj.get("failureClusteringPendingJobs")
+            "failureClusteringPendingJobs": obj.get("failureClusteringPendingJobs"),
+            "testCaseImportPendingJobs": obj.get("testCaseImportPendingJobs"),
+            "evaluationWorkerQueueLength": obj.get("evaluationWorkerQueueLength")
         }, strict=False)
         return _obj
 

eval_studio_client/api/models/v1_technical_metrics.py

@@ -0,0 +1,96 @@
+# 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_technical_metrics_detail import V1TechnicalMetricsDetail
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1TechnicalMetrics(BaseModel):
+    """
+    V1TechnicalMetrics
+    """ # noqa: E501
+    baseline: Optional[V1TechnicalMetricsDetail] = None
+    current: Optional[V1TechnicalMetricsDetail] = None
+    __properties: ClassVar[List[str]] = ["baseline", "current"]
+
+    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 V1TechnicalMetrics 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 baseline
+        if self.baseline:
+            _dict['baseline'] = self.baseline.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of current
+        if self.current:
+            _dict['current'] = self.current.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1TechnicalMetrics 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({
+            "baseline": V1TechnicalMetricsDetail.from_dict(obj["baseline"]) if obj.get("baseline") is not None else None,
+            "current": V1TechnicalMetricsDetail.from_dict(obj["current"]) if obj.get("current") is not None else None
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_technical_metrics_detail.py

@@ -0,0 +1,95 @@
+# 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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1TechnicalMetricsDetail(BaseModel):
+    """
+    V1TechnicalMetricsDetail
+    """ # noqa: E501
+    cost_sum: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Sum of costs.", alias="costSum")
+    duration_sum: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Sum of durations.", alias="durationSum")
+    duration_min: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Minimum duration.", alias="durationMin")
+    duration_max: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Maximum duration.", alias="durationMax")
+    duration_avg: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Average duration.", alias="durationAvg")
+    __properties: ClassVar[List[str]] = ["costSum", "durationSum", "durationMin", "durationMax", "durationAvg"]
+
+    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 V1TechnicalMetricsDetail 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 V1TechnicalMetricsDetail 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({
+            "costSum": obj.get("costSum"),
+            "durationSum": obj.get("durationSum"),
+            "durationMin": obj.get("durationMin"),
+            "durationMax": obj.get("durationMax"),
+            "durationAvg": obj.get("durationAvg")
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_test_case_leaderboard_item.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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1TestCaseLeaderboardItem(BaseModel):
+    """
+    V1TestCaseLeaderboardItem
+    """ # noqa: E501
+    wins: Optional[StrictInt] = Field(default=None, description="Number of wins.")
+    question: Optional[StrictStr] = Field(default=None, description="Question text.")
+    changed_metrics_count: Optional[StrictInt] = Field(default=None, description="Count of changed metrics.", alias="changedMetricsCount")
+    __properties: ClassVar[List[str]] = ["wins", "question", "changedMetricsCount"]
+
+    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 V1TestCaseLeaderboardItem 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 V1TestCaseLeaderboardItem 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({
+            "wins": obj.get("wins"),
+            "question": obj.get("question"),
+            "changedMetricsCount": obj.get("changedMetricsCount")
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_test_case_relationship_info.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 V1TestCaseRelationshipInfo(BaseModel):
+    """
+    V1TestCaseRelationshipInfo
+    """ # noqa: E501
+    type: Optional[StrictStr] = Field(default=None, description="Type of the relationship.")
+    target: Optional[StrictStr] = Field(default=None, description="Target of the relationship.")
+    target_type: Optional[StrictStr] = Field(default=None, description="Type of the target.", alias="targetType")
+    __properties: ClassVar[List[str]] = ["type", "target", "targetType"]
+
+    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 V1TestCaseRelationshipInfo 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 V1TestCaseRelationshipInfo 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({
+            "type": obj.get("type"),
+            "target": obj.get("target"),
+            "targetType": obj.get("targetType")
+        }, strict=False)
+        return _obj
+
+

eval_studio_client/api/models/v1_test_case_result.py

@@ -0,0 +1,157 @@
+# 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from eval_studio_client.api.models.v1_actual_output_meta import V1ActualOutputMeta
+from eval_studio_client.api.models.v1_comparison_metric_score import V1ComparisonMetricScore
+from eval_studio_client.api.models.v1_metric import V1Metric
+from eval_studio_client.api.models.v1_test_case_relationship_info import V1TestCaseRelationshipInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class V1TestCaseResult(BaseModel):
+    """
+    V1TestCaseResult
+    """ # noqa: E501
+    key: Optional[StrictStr] = Field(default=None, description="Unique key for the test case.")
+    input: Optional[StrictStr] = Field(default=None, description="Input text.")
+    corpus: Optional[List[StrictStr]] = Field(default=None, description="Corpus URLs.")
+    context: Optional[List[StrictStr]] = Field(default=None, description="Context texts.")
+    categories: Optional[List[StrictStr]] = Field(default=None, description="Categories.")
+    relationships: Optional[List[V1TestCaseRelationshipInfo]] = Field(default=None, description="Relationships.")
+    expected_output: Optional[StrictStr] = Field(default=None, description="Expected output.", alias="expectedOutput")
+    output_constraints: Optional[List[StrictStr]] = Field(default=None, description="Output constraints.", alias="outputConstraints")
+    output_condition: Optional[StrictStr] = Field(default=None, description="Output condition.", alias="outputCondition")
+    actual_output: Optional[StrictStr] = Field(default=None, description="Actual output generated.", alias="actualOutput")
+    actual_duration: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Duration in seconds.", alias="actualDuration")
+    cost: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Cost of evaluation.")
+    model_key: Optional[StrictStr] = Field(default=None, description="Model key.", alias="modelKey")
+    test_key: Optional[StrictStr] = Field(default=None, description="Test key.", alias="testKey")
+    test_case_key: Optional[StrictStr] = Field(default=None, description="Test case key.", alias="testCaseKey")
+    metrics: Optional[List[V1Metric]] = Field(default=None, description="List of metrics.")
+    metrics_meta: Optional[Dict[str, StrictStr]] = Field(default=None, description="Metadata for metrics.", alias="metricsMeta")
+    actual_output_meta: Optional[List[V1ActualOutputMeta]] = Field(default=None, description="Actual output metadata.", alias="actualOutputMeta")
+    metric_scores: Optional[List[V1ComparisonMetricScore]] = Field(default=None, description="Metric scores.", alias="metricScores")
+    result_error_message: Optional[StrictStr] = Field(default=None, description="Error message if processing resulted in failure.", alias="resultErrorMessage")
+    __properties: ClassVar[List[str]] = ["key", "input", "corpus", "context", "categories", "relationships", "expectedOutput", "outputConstraints", "outputCondition", "actualOutput", "actualDuration", "cost", "modelKey", "testKey", "testCaseKey", "metrics", "metricsMeta", "actualOutputMeta", "metricScores", "resultErrorMessage"]
+
+    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 V1TestCaseResult 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 relationships (list)
+        _items = []
+        if self.relationships:
+            for _item_relationships in self.relationships:
+                if _item_relationships:
+                    _items.append(_item_relationships.to_dict())
+            _dict['relationships'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in metrics (list)
+        _items = []
+        if self.metrics:
+            for _item_metrics in self.metrics:
+                if _item_metrics:
+                    _items.append(_item_metrics.to_dict())
+            _dict['metrics'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in actual_output_meta (list)
+        _items = []
+        if self.actual_output_meta:
+            for _item_actual_output_meta in self.actual_output_meta:
+                if _item_actual_output_meta:
+                    _items.append(_item_actual_output_meta.to_dict())
+            _dict['actualOutputMeta'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in metric_scores (list)
+        _items = []
+        if self.metric_scores:
+            for _item_metric_scores in self.metric_scores:
+                if _item_metric_scores:
+                    _items.append(_item_metric_scores.to_dict())
+            _dict['metricScores'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of V1TestCaseResult 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"),
+            "corpus": obj.get("corpus"),
+            "context": obj.get("context"),
+            "categories": obj.get("categories"),
+            "relationships": [V1TestCaseRelationshipInfo.from_dict(_item) for _item in obj["relationships"]] if obj.get("relationships") is not None else None,
+            "expectedOutput": obj.get("expectedOutput"),
+            "outputConstraints": obj.get("outputConstraints"),
+            "outputCondition": obj.get("outputCondition"),
+            "actualOutput": obj.get("actualOutput"),
+            "actualDuration": obj.get("actualDuration"),
+            "cost": obj.get("cost"),
+            "modelKey": obj.get("modelKey"),
+            "testKey": obj.get("testKey"),
+            "testCaseKey": obj.get("testCaseKey"),
+            "metrics": [V1Metric.from_dict(_item) for _item in obj["metrics"]] if obj.get("metrics") is not None else None,
+            "metricsMeta": obj.get("metricsMeta"),
+            "actualOutputMeta": [V1ActualOutputMeta.from_dict(_item) for _item in obj["actualOutputMeta"]] if obj.get("actualOutputMeta") is not None else None,
+            "metricScores": [V1ComparisonMetricScore.from_dict(_item) for _item in obj["metricScores"]] if obj.get("metricScores") is not None else None,
+            "resultErrorMessage": obj.get("resultErrorMessage")
+        }, strict=False)
+        return _obj
+
+