rapidata 2.41.1__py3-none-any.whl → 2.41.3__py3-none-any.whl

rapidata/api_client/models/compare_workflow_config.py

@@ -19,11 +19,11 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from rapidata.api_client.models.compare_workflow_config_metadata_value import CompareWorkflowConfigMetadataValue
 from rapidata.api_client.models.compare_workflow_config_pair_maker_config import CompareWorkflowConfigPairMakerConfig
 from rapidata.api_client.models.compare_workflow_model1_referee import CompareWorkflowModel1Referee
 from rapidata.api_client.models.elo_config import EloConfig
 from rapidata.api_client.models.feature_flag import FeatureFlag
+from rapidata.api_client.models.file_asset_metadata_value import FileAssetMetadataValue
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -35,7 +35,7 @@ class CompareWorkflowConfig(BaseModel):
     criteria: StrictStr
     referee: CompareWorkflowModel1Referee
     target_country_codes: List[StrictStr] = Field(alias="targetCountryCodes")
-    metadata: Dict[str, CompareWorkflowConfigMetadataValue]
+    metadata: Dict[str, FileAssetMetadataValue]
     elo_config: Optional[EloConfig] = Field(default=None, alias="eloConfig")
     pair_maker_config: Optional[CompareWorkflowConfigPairMakerConfig] = Field(default=None, alias="pairMakerConfig")
     feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="featureFlags")
@@ -127,7 +127,7 @@ class CompareWorkflowConfig(BaseModel):
             "referee": CompareWorkflowModel1Referee.from_dict(obj["referee"]) if obj.get("referee") is not None else None,
             "targetCountryCodes": obj.get("targetCountryCodes"),
             "metadata": dict(
-                (_k, CompareWorkflowConfigMetadataValue.from_dict(_v))
+                (_k, FileAssetMetadataValue.from_dict(_v))
                 for _k, _v in obj["metadata"].items()
             )
             if obj.get("metadata") is not None

rapidata/api_client/models/compare_workflow_config_model.py

@@ -19,11 +19,11 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from rapidata.api_client.models.compare_workflow_config_metadata_value import CompareWorkflowConfigMetadataValue
 from rapidata.api_client.models.compare_workflow_config_model_pair_maker_config import CompareWorkflowConfigModelPairMakerConfig
 from rapidata.api_client.models.compare_workflow_model1_referee import CompareWorkflowModel1Referee
 from rapidata.api_client.models.elo_config import EloConfig
 from rapidata.api_client.models.feature_flag import FeatureFlag
+from rapidata.api_client.models.file_asset_metadata_value import FileAssetMetadataValue
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -37,7 +37,7 @@ class CompareWorkflowConfigModel(BaseModel):
     referee: CompareWorkflowModel1Referee
     target_country_codes: List[StrictStr] = Field(description="A list of country codes that this workflow is targeting.", alias="targetCountryCodes")
     elo_config: Optional[EloConfig] = Field(default=None, alias="eloConfig")
-    metadata: Dict[str, CompareWorkflowConfigMetadataValue] = Field(description="The metadata is attached to every single rapid and can be used for something like the prompt.")
+    metadata: Dict[str, FileAssetMetadataValue] = Field(description="The metadata is attached to every single rapid and can be used for something like the prompt.")
     feature_flags: List[FeatureFlag] = Field(description="The list of feature flags that will be applied to the rapids created by this workflow.", alias="featureFlags")
     __properties: ClassVar[List[str]] = ["_t", "criteria", "pairMakerConfig", "referee", "targetCountryCodes", "eloConfig", "metadata", "featureFlags"]
 
@@ -129,7 +129,7 @@ class CompareWorkflowConfigModel(BaseModel):
             "targetCountryCodes": obj.get("targetCountryCodes"),
             "eloConfig": EloConfig.from_dict(obj["eloConfig"]) if obj.get("eloConfig") is not None else None,
             "metadata": dict(
-                (_k, CompareWorkflowConfigMetadataValue.from_dict(_v))
+                (_k, FileAssetMetadataValue.from_dict(_v))
                 for _k, _v in obj["metadata"].items()
             )
             if obj.get("metadata") is not None

rapidata/api_client/models/compare_workflow_model.py

@@ -28,14 +28,14 @@ from typing_extensions import Self
 
 class CompareWorkflowModel(BaseModel):
     """
-    If the SimpleWorkflow is chosen, each datapoint uploaded will correspond to a single task to be solved. This is the most commonly chosen workflow.
+    CompareWorkflowModel
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for CompareWorkflow", alias="_t")
-    criteria: StrictStr = Field(description="The criteria that the datapoints should be compared based on. No default value.")
+    criteria: StrictStr
     pair_maker_config: Optional[CompareWorkflowModelPairMakerConfig] = Field(default=None, alias="pairMakerConfig")
     elo_config: Optional[EloConfigModel] = Field(default=None, alias="eloConfig")
-    metadata: Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]] = Field(default=None, description="The metadata is attached to every single rapid and can be used for something like the prompt.")
-    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, description="The list of feature flags that will be applied to the rapids created by this workflow.", alias="featureFlags")
+    metadata: Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]] = None
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="featureFlags")
     __properties: ClassVar[List[str]] = ["_t", "criteria", "pairMakerConfig", "eloConfig", "metadata", "featureFlags"]
 
     @field_validator('t')

rapidata/api_client/models/compare_workflow_model_pair_maker_config.py

@@ -26,7 +26,7 @@ COMPAREWORKFLOWMODELPAIRMAKERCONFIG_ONE_OF_SCHEMAS = ["OnlinePairMakerConfigMode
 
 class CompareWorkflowModelPairMakerConfig(BaseModel):
     """
-    The PairMaker config determines the pair making algorithm for compare workflows
+    CompareWorkflowModelPairMakerConfig
     """
     # data type: OnlinePairMakerConfigModel
     oneof_schema_1_validator: Optional[OnlinePairMakerConfigModel] = None

rapidata/api_client/models/create_order_model_referee.py

@@ -29,10 +29,10 @@ class CreateOrderModelReferee(BaseModel):
     """
     The referee is used to determine how many votes will be collected.
     """
-    # data type: NaiveRefereeModel
-    oneof_schema_1_validator: Optional[NaiveRefereeModel] = None
     # data type: EarlyStoppingRefereeModel
-    oneof_schema_2_validator: Optional[EarlyStoppingRefereeModel] = None
+    oneof_schema_1_validator: Optional[EarlyStoppingRefereeModel] = None
+    # data type: NaiveRefereeModel
+    oneof_schema_2_validator: Optional[NaiveRefereeModel] = None
     actual_instance: Optional[Union[EarlyStoppingRefereeModel, NaiveRefereeModel]] = None
     one_of_schemas: Set[str] = { "EarlyStoppingRefereeModel", "NaiveRefereeModel" }
 
@@ -60,16 +60,16 @@ class CreateOrderModelReferee(BaseModel):
         instance = CreateOrderModelReferee.model_construct()
         error_messages = []
         match = 0
-        # validate data type: NaiveRefereeModel
-        if not isinstance(v, NaiveRefereeModel):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `NaiveRefereeModel`")
-        else:
-            match += 1
         # validate data type: EarlyStoppingRefereeModel
         if not isinstance(v, EarlyStoppingRefereeModel):
             error_messages.append(f"Error! Input type `{type(v)}` is not `EarlyStoppingRefereeModel`")
         else:
             match += 1
+        # validate data type: NaiveRefereeModel
+        if not isinstance(v, NaiveRefereeModel):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `NaiveRefereeModel`")
+        else:
+            match += 1
         if match > 1:
             # more than 1 match
             raise ValueError("Multiple matches found when setting `actual_instance` in CreateOrderModelReferee with oneOf schemas: EarlyStoppingRefereeModel, NaiveRefereeModel. Details: " + ", ".join(error_messages))
@@ -90,15 +90,15 @@ class CreateOrderModelReferee(BaseModel):
         error_messages = []
         match = 0
 
-        # deserialize data into NaiveRefereeModel
+        # deserialize data into EarlyStoppingRefereeModel
         try:
-            instance.actual_instance = NaiveRefereeModel.from_json(json_str)
+            instance.actual_instance = EarlyStoppingRefereeModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into EarlyStoppingRefereeModel
+        # deserialize data into NaiveRefereeModel
         try:
-            instance.actual_instance = EarlyStoppingRefereeModel.from_json(json_str)
+            instance.actual_instance = NaiveRefereeModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))

rapidata/api_client/models/create_order_model_workflow.py

@@ -30,12 +30,12 @@ class CreateOrderModelWorkflow(BaseModel):
     """
     The workflow helps to determine the tasks that need to be completed by the users.
     """
+    # data type: CompareWorkflowModel
+    oneof_schema_1_validator: Optional[CompareWorkflowModel] = None
     # data type: EvaluationWorkflowModel
-    oneof_schema_1_validator: Optional[EvaluationWorkflowModel] = None
+    oneof_schema_2_validator: Optional[EvaluationWorkflowModel] = None
     # data type: SimpleWorkflowModel
-    oneof_schema_2_validator: Optional[SimpleWorkflowModel] = None
-    # data type: CompareWorkflowModel
-    oneof_schema_3_validator: Optional[CompareWorkflowModel] = None
+    oneof_schema_3_validator: Optional[SimpleWorkflowModel] = None
     actual_instance: Optional[Union[CompareWorkflowModel, EvaluationWorkflowModel, SimpleWorkflowModel]] = None
     one_of_schemas: Set[str] = { "CompareWorkflowModel", "EvaluationWorkflowModel", "SimpleWorkflowModel" }
 
@@ -63,6 +63,11 @@ class CreateOrderModelWorkflow(BaseModel):
         instance = CreateOrderModelWorkflow.model_construct()
         error_messages = []
         match = 0
+        # validate data type: CompareWorkflowModel
+        if not isinstance(v, CompareWorkflowModel):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CompareWorkflowModel`")
+        else:
+            match += 1
         # validate data type: EvaluationWorkflowModel
         if not isinstance(v, EvaluationWorkflowModel):
             error_messages.append(f"Error! Input type `{type(v)}` is not `EvaluationWorkflowModel`")
@@ -73,11 +78,6 @@ class CreateOrderModelWorkflow(BaseModel):
             error_messages.append(f"Error! Input type `{type(v)}` is not `SimpleWorkflowModel`")
         else:
             match += 1
-        # validate data type: CompareWorkflowModel
-        if not isinstance(v, CompareWorkflowModel):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `CompareWorkflowModel`")
-        else:
-            match += 1
         if match > 1:
             # more than 1 match
             raise ValueError("Multiple matches found when setting `actual_instance` in CreateOrderModelWorkflow with oneOf schemas: CompareWorkflowModel, EvaluationWorkflowModel, SimpleWorkflowModel. Details: " + ", ".join(error_messages))
@@ -98,21 +98,21 @@ class CreateOrderModelWorkflow(BaseModel):
         error_messages = []
         match = 0
 
-        # deserialize data into EvaluationWorkflowModel
+        # deserialize data into CompareWorkflowModel
         try:
-            instance.actual_instance = EvaluationWorkflowModel.from_json(json_str)
+            instance.actual_instance = CompareWorkflowModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into SimpleWorkflowModel
+        # deserialize data into EvaluationWorkflowModel
         try:
-            instance.actual_instance = SimpleWorkflowModel.from_json(json_str)
+            instance.actual_instance = EvaluationWorkflowModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into CompareWorkflowModel
+        # deserialize data into SimpleWorkflowModel
         try:
-            instance.actual_instance = CompareWorkflowModel.from_json(json_str)
+            instance.actual_instance = SimpleWorkflowModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))

rapidata/api_client/models/early_stopping_referee_model.py

@@ -24,11 +24,11 @@ from typing_extensions import Self
 
 class EarlyStoppingRefereeModel(BaseModel):
     """
-    The Early Stopping Referee can currently only be used for classification tasks and will stop once a certain threshold is reached or the maximum number of votes is collected.
+    EarlyStoppingRefereeModel
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for EarlyStoppingReferee", alias="_t")
-    max_votes: StrictInt = Field(description="The upper limit of votes that will be collected for each task.", alias="maxVotes")
-    threshold: Union[StrictFloat, StrictInt] = Field(description="The threshold that needs to be reached to stop collecting votes.")
+    max_votes: StrictInt = Field(alias="maxVotes")
+    threshold: Union[StrictFloat, StrictInt]
     __properties: ClassVar[List[str]] = ["_t", "maxVotes", "threshold"]
 
     @field_validator('t')

rapidata/api_client/models/elo_config_model.py

@@ -24,11 +24,11 @@ from typing_extensions import Self
 
 class EloConfigModel(BaseModel):
     """
-    These parameters affect how the ELO algorithms behaves
+    EloConfigModel
     """ # noqa: E501
-    starting_elo: Optional[StrictInt] = Field(default=None, description="The starting ELO score for each datapoint.", alias="startingElo")
-    k_factor: Optional[StrictInt] = Field(default=None, description="The K-factor to use in the ELO calculation. Determines the maximum possible change in a player's Elo rating after a single match. Higher K-Factor values result in larger rating changes.", alias="kFactor")
-    scaling_factor: Optional[StrictInt] = Field(default=None, description="Scaling factor to use in the ELO calculation. Adjusts the sensitivity of the Elo rating system to differences in player ratings. It affects how much the rating changes based on the expected outcome versus the actual outcome.", alias="scalingFactor")
+    starting_elo: Optional[StrictInt] = Field(default=None, alias="startingElo")
+    k_factor: Optional[StrictInt] = Field(default=None, alias="kFactor")
+    scaling_factor: Optional[StrictInt] = Field(default=None, alias="scalingFactor")
     __properties: ClassVar[List[str]] = ["startingElo", "kFactor", "scalingFactor"]
 
     model_config = ConfigDict(

rapidata/api_client/models/evaluation_workflow_model.py

@@ -25,12 +25,12 @@ from typing_extensions import Self
 
 class EvaluationWorkflowModel(BaseModel):
     """
-    If the EvaluationWorkflow is chosen a validation set will be used as a source for all tasks. It functions similarly to the SimpleWorkflow as there is a 1:1 mapping between validation rapids and tasks.
+    EvaluationWorkflowModel
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for EvaluationWorkflow", alias="_t")
-    validation_set_id: StrictStr = Field(description="The Validation Set id is used to as a source for the tasks that will be sent to the user.", alias="validationSetId")
-    should_accept_incorrect: StrictBool = Field(description="Indicates if the user should get feedback on their answers if they answer wrong. If set to true the user will not notice that he was tested.", alias="shouldAcceptIncorrect")
-    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, description="The list of feature flags that will be applied to the rapids created by this workflow.", alias="featureFlags")
+    validation_set_id: StrictStr = Field(alias="validationSetId")
+    should_accept_incorrect: StrictBool = Field(alias="shouldAcceptIncorrect")
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="featureFlags")
     __properties: ClassVar[List[str]] = ["_t", "validationSetId", "shouldAcceptIncorrect", "featureFlags"]
 
     @field_validator('t')

rapidata/api_client/models/existing_asset_input.py

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

rapidata/api_client/models/file_asset.py

@@ -28,7 +28,7 @@ class FileAsset(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for FileAsset", alias="_t")
     file_name: StrictStr = Field(alias="fileName")
-    metadata: Optional[Dict[str, CompareWorkflowConfigMetadataValue]] = None
+    metadata: Optional[Dict[str, FileAssetMetadataValue]] = None
     __properties: ClassVar[List[str]] = ["_t", "fileName", "metadata"]
 
     @field_validator('t')
@@ -99,7 +99,7 @@ class FileAsset(BaseModel):
             "_t": obj.get("_t") if obj.get("_t") is not None else 'FileAsset',
             "fileName": obj.get("fileName"),
             "metadata": dict(
-                (_k, CompareWorkflowConfigMetadataValue.from_dict(_v))
+                (_k, FileAssetMetadataValue.from_dict(_v))
                 for _k, _v in obj["metadata"].items()
             )
             if obj.get("metadata") is not None
@@ -107,7 +107,7 @@ class FileAsset(BaseModel):
         })
         return _obj
 
-from rapidata.api_client.models.compare_workflow_config_metadata_value import CompareWorkflowConfigMetadataValue
+from rapidata.api_client.models.file_asset_metadata_value import FileAssetMetadataValue
 # TODO: Rewrite to not use raise_errors
 FileAsset.model_rebuild(raise_errors=False)