rapidata 2.13.1__py3-none-any.whl → 2.14.0__py3-none-any.whl

rapidata/api_client/models/__init__.py

@@ -18,7 +18,6 @@ from rapidata.api_client.models.ab_test_selection import AbTestSelection
 from rapidata.api_client.models.ab_test_selection_a_inner import AbTestSelectionAInner
 from rapidata.api_client.models.add_campaign_artifact_result import AddCampaignArtifactResult
 from rapidata.api_client.models.add_campaign_model import AddCampaignModel
-from rapidata.api_client.models.add_campaign_model_user_filters_inner import AddCampaignModelUserFiltersInner
 from rapidata.api_client.models.add_validation_rapid_model import AddValidationRapidModel
 from rapidata.api_client.models.add_validation_rapid_model_payload import AddValidationRapidModelPayload
 from rapidata.api_client.models.add_validation_rapid_model_truth import AddValidationRapidModelTruth
@@ -75,6 +74,7 @@ from rapidata.api_client.models.create_complex_order_model import CreateComplexO
 from rapidata.api_client.models.create_complex_order_model_pipeline import CreateComplexOrderModelPipeline
 from rapidata.api_client.models.create_complex_order_result import CreateComplexOrderResult
 from rapidata.api_client.models.create_datapoint_from_urls_model import CreateDatapointFromUrlsModel
+from rapidata.api_client.models.create_datapoint_from_urls_model_metadata_inner import CreateDatapointFromUrlsModelMetadataInner
 from rapidata.api_client.models.create_datapoint_result import CreateDatapointResult
 from rapidata.api_client.models.create_dataset_artifact_model import CreateDatasetArtifactModel
 from rapidata.api_client.models.create_dataset_artifact_model_dataset import CreateDatasetArtifactModelDataset
@@ -90,10 +90,10 @@ from rapidata.api_client.models.create_simple_pipeline_model_artifacts_inner imp
 from rapidata.api_client.models.create_simple_pipeline_model_pipeline_steps_inner import CreateSimplePipelineModelPipelineStepsInner
 from rapidata.api_client.models.create_unsupported_order_model import CreateUnsupportedOrderModel
 from rapidata.api_client.models.custom_user_filter_model import CustomUserFilterModel
+from rapidata.api_client.models.datapoint import Datapoint
+from rapidata.api_client.models.datapoint_asset import DatapointAsset
 from rapidata.api_client.models.datapoint_metadata_model import DatapointMetadataModel
-from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import DatapointMetadataModelMetadataInner
 from rapidata.api_client.models.datapoint_model import DatapointModel
-from rapidata.api_client.models.datapoint_model_asset import DatapointModelAsset
 from rapidata.api_client.models.datapoint_state import DatapointState
 from rapidata.api_client.models.dataset_artifact_model import DatasetArtifactModel
 from rapidata.api_client.models.dataset_evaluation_step_model import DatasetEvaluationStepModel
@@ -128,10 +128,12 @@ from rapidata.api_client.models.get_datapoint_by_id_result import GetDatapointBy
 from rapidata.api_client.models.get_datapoints_by_dataset_id_result import GetDatapointsByDatasetIdResult
 from rapidata.api_client.models.get_dataset_by_id_result import GetDatasetByIdResult
 from rapidata.api_client.models.get_dataset_progress_result import GetDatasetProgressResult
+from rapidata.api_client.models.get_failed_datapoints_result import GetFailedDatapointsResult
 from rapidata.api_client.models.get_order_by_id_result import GetOrderByIdResult
 from rapidata.api_client.models.get_pipeline_by_id_result import GetPipelineByIdResult
 from rapidata.api_client.models.get_pipeline_by_id_result_artifacts_value import GetPipelineByIdResultArtifactsValue
 from rapidata.api_client.models.get_public_orders_result import GetPublicOrdersResult
+from rapidata.api_client.models.get_responses_result import GetResponsesResult
 from rapidata.api_client.models.get_simple_workflow_results_model import GetSimpleWorkflowResultsModel
 from rapidata.api_client.models.get_simple_workflow_results_result import GetSimpleWorkflowResultsResult
 from rapidata.api_client.models.get_simple_workflow_results_result_paged_result import GetSimpleWorkflowResultsResultPagedResult
@@ -171,7 +173,6 @@ from rapidata.api_client.models.named_entity_result import NamedEntityResult
 from rapidata.api_client.models.named_entity_truth import NamedEntityTruth
 from rapidata.api_client.models.never_ending_referee_config import NeverEndingRefereeConfig
 from rapidata.api_client.models.new_user_filter_model import NewUserFilterModel
-from rapidata.api_client.models.new_user_filter_model1 import NewUserFilterModel1
 from rapidata.api_client.models.newsletter_model import NewsletterModel
 from rapidata.api_client.models.not_available_yet_result import NotAvailableYetResult
 from rapidata.api_client.models.null_asset_model import NullAssetModel

rapidata/api_client/models/add_campaign_model.py

@@ -20,7 +20,7 @@ import json
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from rapidata.api_client.models.ab_test_selection_a_inner import AbTestSelectionAInner
-from rapidata.api_client.models.add_campaign_model_user_filters_inner import AddCampaignModelUserFiltersInner
+from rapidata.api_client.models.create_order_model_user_filters_inner import CreateOrderModelUserFiltersInner
 from rapidata.api_client.models.feature_flag import FeatureFlag
 from typing import Optional, Set
 from typing_extensions import Self
@@ -32,7 +32,7 @@ class AddCampaignModel(BaseModel):
     t: StrictStr = Field(description="Discriminator value for AddCampaignModel", alias="_t")
     artifact_id: Optional[StrictStr] = Field(default=None, description="The id of the campaign artifact. If not provided a random value will be used.", alias="artifactId")
     campaign_name: StrictStr = Field(description="The name of the campaign.", alias="campaignName")
-    user_filters: List[AddCampaignModelUserFiltersInner] = Field(description="The user filters to apply to the campaign.", alias="userFilters")
+    user_filters: List[CreateOrderModelUserFiltersInner] = Field(description="The user filters to apply to the campaign.", alias="userFilters")
     validation_set_id: Optional[StrictStr] = Field(default=None, description="A validation set that should be used.", alias="validationSetId")
     selections: Optional[List[AbTestSelectionAInner]] = Field(default=None, description="The selections that the campaign should have.")
     feature_flags: List[FeatureFlag] = Field(description="The feature flags that should be applied to the campaign.", alias="featureFlags")
@@ -137,7 +137,7 @@ class AddCampaignModel(BaseModel):
             "_t": obj.get("_t") if obj.get("_t") is not None else 'AddCampaignModel',
             "artifactId": obj.get("artifactId"),
             "campaignName": obj.get("campaignName"),
-            "userFilters": [AddCampaignModelUserFiltersInner.from_dict(_item) for _item in obj["userFilters"]] if obj.get("userFilters") is not None else None,
+            "userFilters": [CreateOrderModelUserFiltersInner.from_dict(_item) for _item in obj["userFilters"]] if obj.get("userFilters") is not None else None,
             "validationSetId": obj.get("validationSetId"),
             "selections": [AbTestSelectionAInner.from_dict(_item) for _item in obj["selections"]] if obj.get("selections") is not None else None,
             "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None,

rapidata/api_client/models/add_validation_rapid_model.py

@@ -21,7 +21,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, Stric
 from typing import Any, ClassVar, Dict, List, Optional, Union
 from rapidata.api_client.models.add_validation_rapid_model_payload import AddValidationRapidModelPayload
 from rapidata.api_client.models.add_validation_rapid_model_truth import AddValidationRapidModelTruth
-from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import DatapointMetadataModelMetadataInner
+from rapidata.api_client.models.create_datapoint_from_urls_model_metadata_inner import CreateDatapointFromUrlsModelMetadataInner
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -31,7 +31,7 @@ class AddValidationRapidModel(BaseModel):
     """ # noqa: E501
     validation_set_id: StrictStr = Field(description="The ID of the validation set to add the rapid to.", alias="validationSetId")
     payload: AddValidationRapidModelPayload
-    metadata: List[DatapointMetadataModelMetadataInner] = Field(description="Some metadata to attach to the rapid.")
+    metadata: List[CreateDatapointFromUrlsModelMetadataInner] = Field(description="Some metadata to attach to the rapid.")
     truth: AddValidationRapidModelTruth
     random_correct_probability: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The probability for an answer to be correct when randomly guessing.", alias="randomCorrectProbability")
     explanation: Optional[StrictStr] = Field(default=None, description="An explanation for the users if they answer the rapid incorrectly.")
@@ -113,7 +113,7 @@ class AddValidationRapidModel(BaseModel):
         _obj = cls.model_validate({
             "validationSetId": obj.get("validationSetId"),
             "payload": AddValidationRapidModelPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
-            "metadata": [DatapointMetadataModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
+            "metadata": [CreateDatapointFromUrlsModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
             "truth": AddValidationRapidModelTruth.from_dict(obj["truth"]) if obj.get("truth") is not None else None,
             "randomCorrectProbability": obj.get("randomCorrectProbability"),
             "explanation": obj.get("explanation")

rapidata/api_client/models/add_validation_text_rapid_model.py

@@ -21,7 +21,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, Stric
 from typing import Any, ClassVar, Dict, List, Optional, Union
 from rapidata.api_client.models.add_validation_rapid_model_payload import AddValidationRapidModelPayload
 from rapidata.api_client.models.add_validation_rapid_model_truth import AddValidationRapidModelTruth
-from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import DatapointMetadataModelMetadataInner
+from rapidata.api_client.models.create_datapoint_from_urls_model_metadata_inner import CreateDatapointFromUrlsModelMetadataInner
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -31,7 +31,7 @@ class AddValidationTextRapidModel(BaseModel):
     """ # noqa: E501
     validation_set_id: StrictStr = Field(description="The ID of the validation set to add the rapid to.", alias="validationSetId")
     payload: AddValidationRapidModelPayload
-    metadata: List[DatapointMetadataModelMetadataInner] = Field(description="Some metadata to attach to the rapid.")
+    metadata: List[CreateDatapointFromUrlsModelMetadataInner] = Field(description="Some metadata to attach to the rapid.")
     truth: AddValidationRapidModelTruth
     texts: List[StrictStr] = Field(description="The texts to use for the rapid.")
     random_correct_probability: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The probability for an answer to be correct when randomly guessing.", alias="randomCorrectProbability")
@@ -114,7 +114,7 @@ class AddValidationTextRapidModel(BaseModel):
         _obj = cls.model_validate({
             "validationSetId": obj.get("validationSetId"),
             "payload": AddValidationRapidModelPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
-            "metadata": [DatapointMetadataModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
+            "metadata": [CreateDatapointFromUrlsModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
             "truth": AddValidationRapidModelTruth.from_dict(obj["truth"]) if obj.get("truth") is not None else None,
             "texts": obj.get("texts"),
             "randomCorrectProbability": obj.get("randomCorrectProbability"),

rapidata/api_client/models/create_datapoint_from_urls_model.py

@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
-from typing import Any, ClassVar, Dict, List
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.create_datapoint_from_urls_model_metadata_inner import CreateDatapointFromUrlsModelMetadataInner
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,7 +28,9 @@ class CreateDatapointFromUrlsModel(BaseModel):
     The model for creating a datapoint from urls.
     """ # noqa: E501
     urls: List[StrictStr] = Field(description="The urls to fetch the assets from.  The urls must be publicly accessible.  A HEAD request will be made to each url to check if it is accessible.")
-    __properties: ClassVar[List[str]] = ["urls"]
+    metadata: Optional[List[CreateDatapointFromUrlsModelMetadataInner]] = Field(default=None, description="Additional metadata to attach to the datapoint.  Most commonly used to add a prompt to the datapoint using the Rapidata.Shared.Assets.Abstraction.Models.Metadata.Input.PromptMetadataInput.")
+    sort_index: Optional[StrictInt] = Field(default=None, description="The index will be used to keep the datapoints in order. Useful if upload is parallelized", alias="sortIndex")
+    __properties: ClassVar[List[str]] = ["urls", "metadata", "sortIndex"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -68,6 +71,23 @@ class CreateDatapointFromUrlsModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of each item in metadata (list)
+        _items = []
+        if self.metadata:
+            for _item_metadata in self.metadata:
+                if _item_metadata:
+                    _items.append(_item_metadata.to_dict())
+            _dict['metadata'] = _items
+        # set to None if metadata (nullable) is None
+        # and model_fields_set contains the field
+        if self.metadata is None and "metadata" in self.model_fields_set:
+            _dict['metadata'] = None
+
+        # set to None if sort_index (nullable) is None
+        # and model_fields_set contains the field
+        if self.sort_index is None and "sort_index" in self.model_fields_set:
+            _dict['sortIndex'] = None
+
         return _dict
 
     @classmethod
@@ -80,7 +100,9 @@ class CreateDatapointFromUrlsModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "urls": obj.get("urls")
+            "urls": obj.get("urls"),
+            "metadata": [CreateDatapointFromUrlsModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
+            "sortIndex": obj.get("sortIndex")
         })
         return _obj
 

rapidata/api_client/models/create_datapoint_from_urls_model_metadata_inner.py

@@ -0,0 +1,168 @@
+# 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
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from rapidata.api_client.models.private_text_metadata_input import PrivateTextMetadataInput
+from rapidata.api_client.models.prompt_metadata_input import PromptMetadataInput
+from rapidata.api_client.models.public_text_metadata_input import PublicTextMetadataInput
+from rapidata.api_client.models.transcription_metadata_input import TranscriptionMetadataInput
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+CREATEDATAPOINTFROMURLSMODELMETADATAINNER_ONE_OF_SCHEMAS = ["PrivateTextMetadataInput", "PromptMetadataInput", "PublicTextMetadataInput", "TranscriptionMetadataInput"]
+
+class CreateDatapointFromUrlsModelMetadataInner(BaseModel):
+    """
+    CreateDatapointFromUrlsModelMetadataInner
+    """
+    # data type: PrivateTextMetadataInput
+    oneof_schema_1_validator: Optional[PrivateTextMetadataInput] = None
+    # data type: PromptMetadataInput
+    oneof_schema_2_validator: Optional[PromptMetadataInput] = None
+    # data type: PublicTextMetadataInput
+    oneof_schema_3_validator: Optional[PublicTextMetadataInput] = None
+    # data type: TranscriptionMetadataInput
+    oneof_schema_4_validator: Optional[TranscriptionMetadataInput] = None
+    actual_instance: Optional[Union[PrivateTextMetadataInput, PromptMetadataInput, PublicTextMetadataInput, TranscriptionMetadataInput]] = None
+    one_of_schemas: Set[str] = { "PrivateTextMetadataInput", "PromptMetadataInput", "PublicTextMetadataInput", "TranscriptionMetadataInput" }
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    discriminator_value_class_map: Dict[str, str] = {
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = CreateDatapointFromUrlsModelMetadataInner.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: PrivateTextMetadataInput
+        if not isinstance(v, PrivateTextMetadataInput):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PrivateTextMetadataInput`")
+        else:
+            match += 1
+        # validate data type: PromptMetadataInput
+        if not isinstance(v, PromptMetadataInput):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PromptMetadataInput`")
+        else:
+            match += 1
+        # validate data type: PublicTextMetadataInput
+        if not isinstance(v, PublicTextMetadataInput):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PublicTextMetadataInput`")
+        else:
+            match += 1
+        # validate data type: TranscriptionMetadataInput
+        if not isinstance(v, TranscriptionMetadataInput):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `TranscriptionMetadataInput`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in CreateDatapointFromUrlsModelMetadataInner with oneOf schemas: PrivateTextMetadataInput, PromptMetadataInput, PublicTextMetadataInput, TranscriptionMetadataInput. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in CreateDatapointFromUrlsModelMetadataInner with oneOf schemas: PrivateTextMetadataInput, PromptMetadataInput, PublicTextMetadataInput, TranscriptionMetadataInput. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into PrivateTextMetadataInput
+        try:
+            instance.actual_instance = PrivateTextMetadataInput.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into PromptMetadataInput
+        try:
+            instance.actual_instance = PromptMetadataInput.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into PublicTextMetadataInput
+        try:
+            instance.actual_instance = PublicTextMetadataInput.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into TranscriptionMetadataInput
+        try:
+            instance.actual_instance = TranscriptionMetadataInput.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into CreateDatapointFromUrlsModelMetadataInner with oneOf schemas: PrivateTextMetadataInput, PromptMetadataInput, PublicTextMetadataInput, TranscriptionMetadataInput. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into CreateDatapointFromUrlsModelMetadataInner with oneOf schemas: PrivateTextMetadataInput, PromptMetadataInput, PublicTextMetadataInput, TranscriptionMetadataInput. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], PrivateTextMetadataInput, PromptMetadataInput, PublicTextMetadataInput, TranscriptionMetadataInput]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+

rapidata/api_client/models/create_datapoint_result.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from rapidata.api_client.models.base_error import BaseError
 from typing import Optional, Set
@@ -29,7 +29,8 @@ class CreateDatapointResult(BaseModel):
     """ # noqa: E501
     datapoint_id: StrictStr = Field(alias="datapointId")
     errors: Optional[List[BaseError]] = None
-    __properties: ClassVar[List[str]] = ["datapointId", "errors"]
+    created_count: Optional[StrictInt] = Field(default=None, alias="createdCount")
+    __properties: ClassVar[List[str]] = ["datapointId", "errors", "createdCount"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -90,7 +91,8 @@ class CreateDatapointResult(BaseModel):
 
         _obj = cls.model_validate({
             "datapointId": obj.get("datapointId"),
-            "errors": [BaseError.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
+            "errors": [BaseError.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None,
+            "createdCount": obj.get("createdCount")
         })
         return _obj
 

rapidata/api_client/models/datapoint.py

@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from rapidata.api_client.models.datapoint_asset import DatapointAsset
 from typing import Optional, Set
@@ -28,22 +28,12 @@ class Datapoint(BaseModel):
     """
     Datapoint
     """ # noqa: E501
-    t: StrictStr = Field(description="Discriminator value for Datapoint", alias="_t")
+    id: StrictStr
+    dataset_id: StrictStr = Field(alias="datasetId")
     sort_index: Optional[StrictInt] = Field(default=None, alias="sortIndex")
     asset: DatapointAsset
-    dataset_id: StrictStr = Field(alias="datasetId")
-    id: Optional[StrictStr] = None
-    deletion_date: Optional[datetime] = Field(default=None, alias="deletionDate")
-    deleter_id: Optional[StrictStr] = Field(default=None, alias="deleterId")
-    created_at: Optional[datetime] = Field(default=None, alias="createdAt")
-    __properties: ClassVar[List[str]] = ["_t", "sortIndex", "asset", "datasetId", "id", "deletionDate", "deleterId", "createdAt"]
-
-    @field_validator('t')
-    def t_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Datapoint']):
-            raise ValueError("must be one of enum values ('Datapoint')")
-        return value
+    created_at: datetime = Field(alias="createdAt")
+    __properties: ClassVar[List[str]] = ["id", "datasetId", "sortIndex", "asset", "createdAt"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -92,16 +82,6 @@ class Datapoint(BaseModel):
         if self.sort_index is None and "sort_index" in self.model_fields_set:
             _dict['sortIndex'] = None
 
-        # set to None if deletion_date (nullable) is None
-        # and model_fields_set contains the field
-        if self.deletion_date is None and "deletion_date" in self.model_fields_set:
-            _dict['deletionDate'] = None
-
-        # set to None if deleter_id (nullable) is None
-        # and model_fields_set contains the field
-        if self.deleter_id is None and "deleter_id" in self.model_fields_set:
-            _dict['deleterId'] = None
-
         return _dict
 
     @classmethod
@@ -114,13 +94,10 @@ class Datapoint(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "_t": obj.get("_t") if obj.get("_t") is not None else 'Datapoint',
+            "id": obj.get("id"),
+            "datasetId": obj.get("datasetId"),
             "sortIndex": obj.get("sortIndex"),
             "asset": DatapointAsset.from_dict(obj["asset"]) if obj.get("asset") is not None else None,
-            "datasetId": obj.get("datasetId"),
-            "id": obj.get("id"),
-            "deletionDate": obj.get("deletionDate"),
-            "deleterId": obj.get("deleterId"),
             "createdAt": obj.get("createdAt")
         })
         return _obj

rapidata/api_client/models/datapoint_asset.py

@@ -17,29 +17,29 @@ import json
 import pprint
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
 from typing import Any, List, Optional
-from rapidata.api_client.models.file_asset import FileAsset
-from rapidata.api_client.models.null_asset import NullAsset
-from rapidata.api_client.models.text_asset import TextAsset
+from rapidata.api_client.models.file_asset_model import FileAssetModel
+from rapidata.api_client.models.null_asset_model import NullAssetModel
+from rapidata.api_client.models.text_asset_model import TextAssetModel
 from pydantic import StrictStr, Field
 from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
-DATAPOINTASSET_ONE_OF_SCHEMAS = ["FileAsset", "MultiAsset", "NullAsset", "TextAsset"]
+DATAPOINTASSET_ONE_OF_SCHEMAS = ["FileAssetModel", "MultiAssetModel", "NullAssetModel", "TextAssetModel"]
 
 class DatapointAsset(BaseModel):
     """
     DatapointAsset
     """
-    # data type: FileAsset
-    oneof_schema_1_validator: Optional[FileAsset] = None
-    # data type: MultiAsset
-    oneof_schema_2_validator: Optional[MultiAsset] = None
-    # data type: NullAsset
-    oneof_schema_3_validator: Optional[NullAsset] = None
-    # data type: TextAsset
-    oneof_schema_4_validator: Optional[TextAsset] = None
-    actual_instance: Optional[Union[FileAsset, MultiAsset, NullAsset, TextAsset]] = None
-    one_of_schemas: Set[str] = { "FileAsset", "MultiAsset", "NullAsset", "TextAsset" }
+    # data type: FileAssetModel
+    oneof_schema_1_validator: Optional[FileAssetModel] = None
+    # data type: MultiAssetModel
+    oneof_schema_2_validator: Optional[MultiAssetModel] = None
+    # data type: NullAssetModel
+    oneof_schema_3_validator: Optional[NullAssetModel] = None
+    # data type: TextAssetModel
+    oneof_schema_4_validator: Optional[TextAssetModel] = None
+    actual_instance: Optional[Union[FileAssetModel, MultiAssetModel, NullAssetModel, TextAssetModel]] = None
+    one_of_schemas: Set[str] = { "FileAssetModel", "MultiAssetModel", "NullAssetModel", "TextAssetModel" }
 
     model_config = ConfigDict(
         validate_assignment=True,
@@ -65,32 +65,32 @@ class DatapointAsset(BaseModel):
         instance = DatapointAsset.model_construct()
         error_messages = []
         match = 0
-        # validate data type: FileAsset
-        if not isinstance(v, FileAsset):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `FileAsset`")
+        # validate data type: FileAssetModel
+        if not isinstance(v, FileAssetModel):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `FileAssetModel`")
         else:
             match += 1
-        # validate data type: MultiAsset
-        if not isinstance(v, MultiAsset):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `MultiAsset`")
+        # validate data type: MultiAssetModel
+        if not isinstance(v, MultiAssetModel):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `MultiAssetModel`")
         else:
             match += 1
-        # validate data type: NullAsset
-        if not isinstance(v, NullAsset):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `NullAsset`")
+        # validate data type: NullAssetModel
+        if not isinstance(v, NullAssetModel):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `NullAssetModel`")
         else:
             match += 1
-        # validate data type: TextAsset
-        if not isinstance(v, TextAsset):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `TextAsset`")
+        # validate data type: TextAssetModel
+        if not isinstance(v, TextAssetModel):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `TextAssetModel`")
         else:
             match += 1
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when setting `actual_instance` in DatapointAsset with oneOf schemas: FileAsset, MultiAsset, NullAsset, TextAsset. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when setting `actual_instance` in DatapointAsset with oneOf schemas: FileAssetModel, MultiAssetModel, NullAssetModel, TextAssetModel. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when setting `actual_instance` in DatapointAsset with oneOf schemas: FileAsset, MultiAsset, NullAsset, TextAsset. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when setting `actual_instance` in DatapointAsset with oneOf schemas: FileAssetModel, MultiAssetModel, NullAssetModel, TextAssetModel. Details: " + ", ".join(error_messages))
         else:
             return v
 
@@ -105,37 +105,37 @@ class DatapointAsset(BaseModel):
         error_messages = []
         match = 0
 
-        # deserialize data into FileAsset
+        # deserialize data into FileAssetModel
         try:
-            instance.actual_instance = FileAsset.from_json(json_str)
+            instance.actual_instance = FileAssetModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into MultiAsset
+        # deserialize data into MultiAssetModel
         try:
-            instance.actual_instance = MultiAsset.from_json(json_str)
+            instance.actual_instance = MultiAssetModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into NullAsset
+        # deserialize data into NullAssetModel
         try:
-            instance.actual_instance = NullAsset.from_json(json_str)
+            instance.actual_instance = NullAssetModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into TextAsset
+        # deserialize data into TextAssetModel
         try:
-            instance.actual_instance = TextAsset.from_json(json_str)
+            instance.actual_instance = TextAssetModel.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
 
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when deserializing the JSON string into DatapointAsset with oneOf schemas: FileAsset, MultiAsset, NullAsset, TextAsset. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when deserializing the JSON string into DatapointAsset with oneOf schemas: FileAssetModel, MultiAssetModel, NullAssetModel, TextAssetModel. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when deserializing the JSON string into DatapointAsset with oneOf schemas: FileAsset, MultiAsset, NullAsset, TextAsset. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when deserializing the JSON string into DatapointAsset with oneOf schemas: FileAssetModel, MultiAssetModel, NullAssetModel, TextAssetModel. Details: " + ", ".join(error_messages))
         else:
             return instance
 
@@ -149,7 +149,7 @@ class DatapointAsset(BaseModel):
         else:
             return json.dumps(self.actual_instance)
 
-    def to_dict(self) -> Optional[Union[Dict[str, Any], FileAsset, MultiAsset, NullAsset, TextAsset]]:
+    def to_dict(self) -> Optional[Union[Dict[str, Any], FileAssetModel, MultiAssetModel, NullAssetModel, TextAssetModel]]:
         """Returns the dict representation of the actual instance"""
         if self.actual_instance is None:
             return None
@@ -164,7 +164,7 @@ class DatapointAsset(BaseModel):
         """Returns the string representation of the actual instance"""
         return pprint.pformat(self.model_dump())
 
-from rapidata.api_client.models.multi_asset import MultiAsset
+from rapidata.api_client.models.multi_asset_model import MultiAssetModel
 # TODO: Rewrite to not use raise_errors
 DatapointAsset.model_rebuild(raise_errors=False)
 

rapidata/api_client/models/datapoint_metadata_model.py

@@ -19,7 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import DatapointMetadataModelMetadataInner
+from rapidata.api_client.models.create_datapoint_from_urls_model_metadata_inner import CreateDatapointFromUrlsModelMetadataInner
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,7 +28,7 @@ class DatapointMetadataModel(BaseModel):
     The model for creating a datapoint.
     """ # noqa: E501
     dataset_id: StrictStr = Field(description="The id of the dataset to create the datapoint in.", alias="datasetId")
-    metadata: List[DatapointMetadataModelMetadataInner] = Field(description="The metadata of the datapoint.")
+    metadata: List[CreateDatapointFromUrlsModelMetadataInner] = Field(description="The metadata of the datapoint.")
     sort_index: Optional[StrictInt] = Field(default=None, description="The index will be used to keep the datapoints in order. Useful if upload is parallelized", alias="sortIndex")
     __properties: ClassVar[List[str]] = ["datasetId", "metadata", "sortIndex"]
 
@@ -96,7 +96,7 @@ class DatapointMetadataModel(BaseModel):
 
         _obj = cls.model_validate({
             "datasetId": obj.get("datasetId"),
-            "metadata": [DatapointMetadataModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
+            "metadata": [CreateDatapointFromUrlsModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
             "sortIndex": obj.get("sortIndex")
         })
         return _obj