rapidata 2.21.5__py3-none-any.whl → 2.22.0__py3-none-any.whl

rapidata/api_client/models/get_workflow_by_id_result_workflow.py

@@ -18,12 +18,13 @@ 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.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", "SimpleWorkflowModel1"]
 
 class GetWorkflowByIdResultWorkflow(BaseModel):
     """
@@ -31,10 +32,12 @@ 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: SimpleWorkflowModel1
-    oneof_schema_2_validator: Optional[SimpleWorkflowModel1] = None
-    actual_instance: Optional[Union[CompareWorkflowModel1, SimpleWorkflowModel1]] = None
-    one_of_schemas: Set[str] = { "CompareWorkflowModel1", "SimpleWorkflowModel1" }
+    oneof_schema_3_validator: Optional[SimpleWorkflowModel1] = None
+    actual_instance: Optional[Union[CompareWorkflowModel1, EvaluationWorkflowModel1, SimpleWorkflowModel1]] = None
+    one_of_schemas: Set[str] = { "CompareWorkflowModel1", "EvaluationWorkflowModel1", "SimpleWorkflowModel1" }
 
     model_config = ConfigDict(
         validate_assignment=True,
@@ -65,6 +68,11 @@ 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: SimpleWorkflowModel1
         if not isinstance(v, SimpleWorkflowModel1):
             error_messages.append(f"Error! Input type `{type(v)}` is not `SimpleWorkflowModel1`")
@@ -72,10 +80,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, 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, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
         else:
             return v
 
@@ -96,6 +104,12 @@ 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 SimpleWorkflowModel1
         try:
             instance.actual_instance = SimpleWorkflowModel1.from_json(json_str)
@@ -105,10 +119,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, 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, SimpleWorkflowModel1. Details: " + ", ".join(error_messages))
         else:
             return instance
 
@@ -122,7 +136,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, SimpleWorkflowModel1]]:
         """Returns the dict representation of the actual instance"""
         if self.actual_instance is None:
             return None

rapidata/api_client/models/get_workflow_results_result.py

@@ -0,0 +1,118 @@
+# 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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.datapoint_asset import DatapointAsset
+from rapidata.api_client.models.get_validation_rapids_result_payload import GetValidationRapidsResultPayload
+from rapidata.api_client.models.rapid_response import RapidResponse
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetWorkflowResultsResult(BaseModel):
+    """
+    GetWorkflowResultsResult
+    """ # noqa: E501
+    rapid_id: StrictStr = Field(alias="rapidId")
+    payload: GetValidationRapidsResultPayload
+    asset: DatapointAsset
+    responses: List[RapidResponse]
+    state: StrictStr
+    __properties: ClassVar[List[str]] = ["rapidId", "payload", "asset", "responses", "state"]
+
+    @field_validator('state')
+    def state_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Labeling', 'Paused', 'Incomplete', 'Done', 'None']):
+            raise ValueError("must be one of enum values ('Labeling', 'Paused', 'Incomplete', 'Done', 'None')")
+        return value
+
+    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
+        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": GetValidationRapidsResultPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
+            "asset": DatapointAsset.from_dict(obj["asset"]) if obj.get("asset") is not None else None,
+            "responses": [RapidResponse.from_dict(_item) for _item in obj["responses"]] if obj.get("responses") is not None else None,
+            "state": obj.get("state")
+        })
+        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/google_one_tap_login_model.py

@@ -0,0 +1,87 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GoogleOneTapLoginModel(BaseModel):
+    """
+    The model for the Google One Tap login.
+    """ # noqa: E501
+    id_token: StrictStr = Field(description="The id token received from the Google One Tap login.", 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
+
+

rapidata/api_client/models/labeling_selection.py

@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,7 +28,9 @@ class LabelingSelection(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for LabelingSelection", alias="_t")
     amount: StrictInt
-    __properties: ClassVar[List[str]] = ["_t", "amount"]
+    retrieval_mode: Optional[StrictStr] = Field(default=None, alias="retrievalMode")
+    max_iterations: Optional[StrictInt] = Field(default=None, alias="maxIterations")
+    __properties: ClassVar[List[str]] = ["_t", "amount", "retrievalMode", "maxIterations"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -37,6 +39,16 @@ class LabelingSelection(BaseModel):
             raise ValueError("must be one of enum values ('LabelingSelection')")
         return value
 
+    @field_validator('retrieval_mode')
+    def retrieval_mode_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['Random', 'Shuffled', 'Sequential']):
+            raise ValueError("must be one of enum values ('Random', 'Shuffled', 'Sequential')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,
@@ -76,6 +88,11 @@ class LabelingSelection(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # set to None if max_iterations (nullable) is None
+        # and model_fields_set contains the field
+        if self.max_iterations is None and "max_iterations" in self.model_fields_set:
+            _dict['maxIterations'] = None
+
         return _dict
 
     @classmethod
@@ -89,7 +106,9 @@ class LabelingSelection(BaseModel):
 
         _obj = cls.model_validate({
             "_t": obj.get("_t") if obj.get("_t") is not None else 'LabelingSelection',
-            "amount": obj.get("amount")
+            "amount": obj.get("amount"),
+            "retrievalMode": obj.get("retrievalMode"),
+            "maxIterations": obj.get("maxIterations")
         })
         return _obj
 

rapidata/api_client/models/logic_operator.py

@@ -28,6 +28,7 @@ class LogicOperator(str, Enum):
     """
     AND = 'And'
     OR = 'Or'
+    NOT = 'Not'
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:

rapidata/api_client/models/rapid_response.py

@@ -32,8 +32,9 @@ class RapidResponse(BaseModel):
     country: StrictStr
     result: RapidResponseResult
     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", "demographicInformation"]
+    __properties: ClassVar[List[str]] = ["id", "userId", "country", "result", "userScore", "userScores", "demographicInformation"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -94,6 +95,7 @@ class RapidResponse(BaseModel):
             "country": obj.get("country"),
             "result": RapidResponseResult.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/retrieval_mode.py

@@ -0,0 +1,38 @@
+# 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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class RetrievalMode(str, Enum):
+    """
+    RetrievalMode
+    """
+
+    """
+    allowed enum values
+    """
+    RANDOM = 'Random'
+    SHUFFLED = 'Shuffled'
+    SEQUENTIAL = 'Sequential'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of RetrievalMode from a JSON string"""
+        return cls(json.loads(json_str))
+
+

rapidata/api_client/models/root_filter.py

@@ -37,8 +37,8 @@ class RootFilter(BaseModel):
         if value is None:
             return value
 
-        if value not in set(['And', 'Or']):
-            raise ValueError("must be one of enum values ('And', 'Or')")
+        if value not in set(['And', 'Or', 'Not']):
+            raise ValueError("must be one of enum values ('And', 'Or', 'Not')")
         return value
 
     model_config = ConfigDict(

rapidata/api_client/models/skip_truth.py

@@ -0,0 +1,94 @@
+# 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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SkipTruth(BaseModel):
+    """
+    SkipTruth
+    """ # noqa: E501
+    t: StrictStr = Field(description="Discriminator value for SkipTruth", alias="_t")
+    __properties: ClassVar[List[str]] = ["_t"]
+
+    @field_validator('t')
+    def t_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['SkipTruth']):
+            raise ValueError("must be one of enum values ('SkipTruth')")
+        return value
+
+    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 SkipTruth 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 SkipTruth from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "_t": obj.get("_t") if obj.get("_t") is not None else 'SkipTruth'
+        })
+        return _obj
+
+

rapidata/api_client/models/sticky_state.py

@@ -0,0 +1,38 @@
+# 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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class StickyState(str, Enum):
+    """
+    StickyState
+    """
+
+    """
+    allowed enum values
+    """
+    NONE = 'None'
+    TEMPORARY = 'Temporary'
+    PERMANENT = 'Permanent'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of StickyState from a JSON string"""
+        return cls(json.loads(json_str))
+
+