rapidata 1.8.3__py3-none-any.whl → 2.44.4__py3-none-any.whl

rapidata/api_client/models/get_workflow_by_id_result_workflow.py

@@ -18,12 +18,14 @@ import pprint
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
 from typing import Any, List, Optional
 from rapidata.api_client.models.compare_workflow_model1 import CompareWorkflowModel1
+from rapidata.api_client.models.evaluation_workflow_model1 import EvaluationWorkflowModel1
+from rapidata.api_client.models.grouped_ranking_workflow_model1 import GroupedRankingWorkflowModel1
 from rapidata.api_client.models.simple_workflow_model1 import SimpleWorkflowModel1
 from pydantic import StrictStr, Field
 from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
-GETWORKFLOWBYIDRESULTWORKFLOW_ONE_OF_SCHEMAS = ["CompareWorkflowModel1", "SimpleWorkflowModel1"]
+GETWORKFLOWBYIDRESULTWORKFLOW_ONE_OF_SCHEMAS = ["CompareWorkflowModel1", "EvaluationWorkflowModel1", "GroupedRankingWorkflowModel1", "SimpleWorkflowModel1"]
 
 class GetWorkflowByIdResultWorkflow(BaseModel):
     """
@@ -31,10 +33,14 @@ class GetWorkflowByIdResultWorkflow(BaseModel):
     """
     # data type: CompareWorkflowModel1
     oneof_schema_1_validator: Optional[CompareWorkflowModel1] = None
+    # data type: EvaluationWorkflowModel1
+    oneof_schema_2_validator: Optional[EvaluationWorkflowModel1] = None
+    # data type: GroupedRankingWorkflowModel1
+    oneof_schema_3_validator: Optional[GroupedRankingWorkflowModel1] = None
     # data type: SimpleWorkflowModel1
-    oneof_schema_2_validator: Optional[SimpleWorkflowModel1] = None
-    actual_instance: Optional[Union[CompareWorkflowModel1, SimpleWorkflowModel1]] = None
-    one_of_schemas: Set[str] = { "CompareWorkflowModel1", "SimpleWorkflowModel1" }
+    oneof_schema_4_validator: Optional[SimpleWorkflowModel1] = None
+    actual_instance: Optional[Union[CompareWorkflowModel1, EvaluationWorkflowModel1, GroupedRankingWorkflowModel1, SimpleWorkflowModel1]] = None
+    one_of_schemas: Set[str] = { "CompareWorkflowModel1", "EvaluationWorkflowModel1", "GroupedRankingWorkflowModel1", "SimpleWorkflowModel1" }
 
     model_config = ConfigDict(
         validate_assignment=True,
@@ -65,6 +71,16 @@ class GetWorkflowByIdResultWorkflow(BaseModel):
             error_messages.append(f"Error! Input type `{type(v)}` is not `CompareWorkflowModel1`")
         else:
             match += 1
+        # validate data type: EvaluationWorkflowModel1
+        if not isinstance(v, EvaluationWorkflowModel1):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `EvaluationWorkflowModel1`")
+        else:
+            match += 1
+        # validate data type: GroupedRankingWorkflowModel1
+        if not isinstance(v, GroupedRankingWorkflowModel1):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `GroupedRankingWorkflowModel1`")
+        else:
+            match += 1
         # validate data type: SimpleWorkflowModel1
         if not isinstance(v, SimpleWorkflowModel1):
             error_messages.append(f"Error! Input type `{type(v)}` is not `SimpleWorkflowModel1`")
@@ -72,10 +88,10 @@ class GetWorkflowByIdResultWorkflow(BaseModel):
             match += 1
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when setting `actual_instance` in GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when setting `actual_instance` in GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, EvaluationWorkflowModel1, GroupedRankingWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when setting `actual_instance` in GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when setting `actual_instance` in GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, EvaluationWorkflowModel1, GroupedRankingWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
         else:
             return v
 
@@ -96,6 +112,18 @@ class GetWorkflowByIdResultWorkflow(BaseModel):
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
+        # deserialize data into EvaluationWorkflowModel1
+        try:
+            instance.actual_instance = EvaluationWorkflowModel1.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into GroupedRankingWorkflowModel1
+        try:
+            instance.actual_instance = GroupedRankingWorkflowModel1.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
         # deserialize data into SimpleWorkflowModel1
         try:
             instance.actual_instance = SimpleWorkflowModel1.from_json(json_str)
@@ -105,10 +133,10 @@ class GetWorkflowByIdResultWorkflow(BaseModel):
 
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when deserializing the JSON string into GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when deserializing the JSON string into GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, EvaluationWorkflowModel1, GroupedRankingWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when deserializing the JSON string into GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when deserializing the JSON string into GetWorkflowByIdResultWorkflow with oneOf schemas: CompareWorkflowModel1, EvaluationWorkflowModel1, GroupedRankingWorkflowModel1, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
         else:
             return instance
 
@@ -122,7 +150,7 @@ class GetWorkflowByIdResultWorkflow(BaseModel):
         else:
             return json.dumps(self.actual_instance)
 
-    def to_dict(self) -> Optional[Union[Dict[str, Any], CompareWorkflowModel1, SimpleWorkflowModel1]]:
+    def to_dict(self) -> Optional[Union[Dict[str, Any], CompareWorkflowModel1, EvaluationWorkflowModel1, GroupedRankingWorkflowModel1, SimpleWorkflowModel1]]:
         """Returns the dict representation of the actual instance"""
         if self.actual_instance is None:
             return None

rapidata/api_client/models/get_workflow_progress_result.py

@@ -1,9 +1,9 @@
 # coding: utf-8
 
 """
-    Rapidata.Dataset
+    Rapidata Asset API
 
-    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+    The API for the Rapidata Asset service
 
     The version of the OpenAPI document: v1
     Generated by OpenAPI Generator (https://openapi-generator.tech)
@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt
 from typing import Any, ClassVar, Dict, List, Union
+from rapidata.api_client.models.workflow_state import WorkflowState
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,16 +30,9 @@ class GetWorkflowProgressResult(BaseModel):
     completion_percentage: Union[StrictFloat, StrictInt] = Field(alias="completionPercentage")
     total: StrictInt
     completed: StrictInt
-    state: StrictStr
+    state: WorkflowState
     __properties: ClassVar[List[str]] = ["completionPercentage", "total", "completed", "state"]
 
-    @field_validator('state')
-    def state_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Created', 'Started', 'Labeling', 'Paused', 'Done', 'Failed']):
-            raise ValueError("must be one of enum values ('Created', 'Started', 'Labeling', 'Paused', 'Done', 'Failed')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/get_workflow_results_result.py

@@ -0,0 +1,129 @@
+# coding: utf-8
+
+"""
+    Rapidata Asset API
+
+    The API for the Rapidata Asset service
+
+    The version of the OpenAPI document: v1
+    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 rapidata.api_client.models.get_workflow_results_result_response import GetWorkflowResultsResultResponse
+from rapidata.api_client.models.i_asset_model import IAssetModel
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.api_client.models.rapid_state import RapidState
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetWorkflowResultsResult(BaseModel):
+    """
+    GetWorkflowResultsResult
+    """ # noqa: E501
+    rapid_id: StrictStr = Field(alias="rapidId")
+    payload: IRapidPayload
+    asset: IAssetModel
+    responses: List[GetWorkflowResultsResultResponse]
+    state: RapidState
+    context: Optional[StrictStr] = None
+    context_asset: Optional[IAssetModel] = Field(default=None, alias="contextAsset")
+    __properties: ClassVar[List[str]] = ["rapidId", "payload", "asset", "responses", "state", "context", "contextAsset"]
+
+    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 GetWorkflowResultsResult 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 payload
+        if self.payload:
+            _dict['payload'] = self.payload.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of asset
+        if self.asset:
+            _dict['asset'] = self.asset.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in responses (list)
+        _items = []
+        if self.responses:
+            for _item_responses in self.responses:
+                if _item_responses:
+                    _items.append(_item_responses.to_dict())
+            _dict['responses'] = _items
+        # override the default output from pydantic by calling `to_dict()` of context_asset
+        if self.context_asset:
+            _dict['contextAsset'] = self.context_asset.to_dict()
+        # set to None if context (nullable) is None
+        # and model_fields_set contains the field
+        if self.context is None and "context" in self.model_fields_set:
+            _dict['context'] = None
+
+        # set to None if context_asset (nullable) is None
+        # and model_fields_set contains the field
+        if self.context_asset is None and "context_asset" in self.model_fields_set:
+            _dict['contextAsset'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetWorkflowResultsResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "rapidId": obj.get("rapidId"),
+            "payload": IRapidPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
+            "asset": IAssetModel.from_dict(obj["asset"]) if obj.get("asset") is not None else None,
+            "responses": [GetWorkflowResultsResultResponse.from_dict(_item) for _item in obj["responses"]] if obj.get("responses") is not None else None,
+            "state": obj.get("state"),
+            "context": obj.get("context"),
+            "contextAsset": IAssetModel.from_dict(obj["contextAsset"]) if obj.get("contextAsset") is not None else None
+        })
+        return _obj
+
+

rapidata/api_client/models/get_workflow_results_result_paged_result.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    Rapidata.Dataset
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: v1
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.get_workflow_results_result import GetWorkflowResultsResult
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetWorkflowResultsResultPagedResult(BaseModel):
+    """
+    GetWorkflowResultsResultPagedResult
+    """ # noqa: E501
+    total: StrictInt
+    page: StrictInt
+    page_size: StrictInt = Field(alias="pageSize")
+    items: List[GetWorkflowResultsResult]
+    total_pages: Optional[StrictInt] = Field(default=None, alias="totalPages")
+    __properties: ClassVar[List[str]] = ["total", "page", "pageSize", "items", "totalPages"]
+
+    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 GetWorkflowResultsResultPagedResult 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.
+        """
+        excluded_fields: Set[str] = set([
+            "total_pages",
+        ])
+
+        _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 items (list)
+        _items = []
+        if self.items:
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
+            _dict['items'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetWorkflowResultsResultPagedResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "total": obj.get("total"),
+            "page": obj.get("page"),
+            "pageSize": obj.get("pageSize"),
+            "items": [GetWorkflowResultsResult.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
+            "totalPages": obj.get("totalPages")
+        })
+        return _obj
+
+

rapidata/api_client/models/get_workflow_results_result_response.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+    Rapidata Asset API
+
+    The API for the Rapidata Asset service
+
+    The version of the OpenAPI document: v1
+    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, Union
+from rapidata.api_client.models.i_rapid_result import IRapidResult
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetWorkflowResultsResultResponse(BaseModel):
+    """
+    GetWorkflowResultsResultResponse
+    """ # noqa: E501
+    id: StrictStr
+    user_id: StrictStr = Field(alias="userId")
+    country: StrictStr
+    result: IRapidResult
+    user_score: Union[StrictFloat, StrictInt] = Field(alias="userScore")
+    user_scores: Dict[str, Union[StrictFloat, StrictInt]] = Field(alias="userScores")
+    demographic_information: Dict[str, StrictStr] = Field(alias="demographicInformation")
+    __properties: ClassVar[List[str]] = ["id", "userId", "country", "result", "userScore", "userScores", "demographicInformation"]
+
+    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 GetWorkflowResultsResultResponse 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 result
+        if self.result:
+            _dict['result'] = self.result.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetWorkflowResultsResultResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "userId": obj.get("userId"),
+            "country": obj.get("country"),
+            "result": IRapidResult.from_dict(obj["result"]) if obj.get("result") is not None else None,
+            "userScore": obj.get("userScore"),
+            "userScores": obj.get("userScores"),
+            "demographicInformation": obj.get("demographicInformation")
+        })
+        return _obj
+
+

rapidata/api_client/models/google_one_tap_login_model.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    Rapidata Asset API
+
+    The API for the Rapidata Asset service
+
+    The version of the OpenAPI document: v1
+    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
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GoogleOneTapLoginModel(BaseModel):
+    """
+    GoogleOneTapLoginModel
+    """ # noqa: E501
+    id_token: StrictStr = Field(alias="idToken")
+    __properties: ClassVar[List[str]] = ["idToken"]
+
+    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 GoogleOneTapLoginModel 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 GoogleOneTapLoginModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "idToken": obj.get("idToken")
+        })
+        return _obj
+
+