rapidata 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

rapidata/api_client/api/dataset_api.py

@@ -45,10 +45,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_create_datapoint_post(
+    def dataset_creat_text_datapoint_post(
         self,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -62,14 +61,12 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> UploadDatapointsResult:
-        """Creates a single datapoint.
+        """Creates new datapoints from text sources.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        If multiple text sources are uploaded, a new datapoint will be created for each text source.
 
-        :param files: The image files to upload.
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param upload_text_sources_to_dataset_model: The body of the request.
+        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -92,9 +89,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_create_datapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_creat_text_datapoint_post_serialize(
+            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -116,10 +112,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_create_datapoint_post_with_http_info(
+    def dataset_creat_text_datapoint_post_with_http_info(
         self,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -133,14 +128,12 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[UploadDatapointsResult]:
-        """Creates a single datapoint.
+        """Creates new datapoints from text sources.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        If multiple text sources are uploaded, a new datapoint will be created for each text source.
 
-        :param files: The image files to upload.
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param upload_text_sources_to_dataset_model: The body of the request.
+        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -163,9 +156,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_create_datapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_creat_text_datapoint_post_serialize(
+            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -187,10 +179,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_create_datapoint_post_without_preload_content(
+    def dataset_creat_text_datapoint_post_without_preload_content(
         self,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -204,14 +195,12 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Creates a single datapoint.
+        """Creates new datapoints from text sources.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        If multiple text sources are uploaded, a new datapoint will be created for each text source.
 
-        :param files: The image files to upload.
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param upload_text_sources_to_dataset_model: The body of the request.
+        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -234,9 +223,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_create_datapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_creat_text_datapoint_post_serialize(
+            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -253,10 +241,9 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_create_datapoint_post_serialize(
+    def _dataset_creat_text_datapoint_post_serialize(
         self,
-        files,
-        model,
+        upload_text_sources_to_dataset_model,
         _request_auth,
         _content_type,
         _headers,
@@ -266,7 +253,6 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -282,11 +268,9 @@ class DatasetApi:
         # process the query parameters
         # process the header parameters
         # process the form parameters
-        if files is not None:
-            _files['files'] = files
-        if model is not None:
-            _form_params.append(('model', model))
         # process the body parameter
+        if upload_text_sources_to_dataset_model is not None:
+            _body_params = upload_text_sources_to_dataset_model
 
 
         # set the HTTP header `Accept`
@@ -306,7 +290,9 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'multipart/form-data'
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
                     ]
                 )
             )
@@ -321,7 +307,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/CreateDatapoint',
+            resource_path='/Dataset/CreatTextDatapoint',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -338,9 +324,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_get_by_id_get(
+    def dataset_create_datapoint_post(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
+        model: Optional[DatapointMetadataModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -353,12 +340,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetDatasetByIdResult:
-        """Gets a dataset by its id.
+    ) -> UploadDatapointsResult:
+        """Creates a single datapoint.
 
+        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param id: The id of the dataset to get.
-        :type id: str
+        :param files: The image files to upload.
+        :type files: List[bytearray]
+        :param model:
+        :type model: DatapointMetadataModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -381,8 +371,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_get_by_id_get_serialize(
-            id=id,
+        _param = self._dataset_create_datapoint_post_serialize(
+            files=files,
+            model=model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -390,7 +381,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -404,9 +395,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_get_by_id_get_with_http_info(
+    def dataset_create_datapoint_post_with_http_info(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
+        model: Optional[DatapointMetadataModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -419,12 +411,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetDatasetByIdResult]:
-        """Gets a dataset by its id.
+    ) -> ApiResponse[UploadDatapointsResult]:
+        """Creates a single datapoint.
 
+        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param id: The id of the dataset to get.
-        :type id: str
+        :param files: The image files to upload.
+        :type files: List[bytearray]
+        :param model:
+        :type model: DatapointMetadataModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -447,8 +442,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_get_by_id_get_serialize(
-            id=id,
+        _param = self._dataset_create_datapoint_post_serialize(
+            files=files,
+            model=model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -456,7 +452,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -470,9 +466,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_get_by_id_get_without_preload_content(
+    def dataset_create_datapoint_post_without_preload_content(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
+        model: Optional[DatapointMetadataModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -486,11 +483,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Gets a dataset by its id.
+        """Creates a single datapoint.
 
+        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param id: The id of the dataset to get.
-        :type id: str
+        :param files: The image files to upload.
+        :type files: List[bytearray]
+        :param model:
+        :type model: DatapointMetadataModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -513,8 +513,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_get_by_id_get_serialize(
-            id=id,
+        _param = self._dataset_create_datapoint_post_serialize(
+            files=files,
+            model=model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -522,7 +523,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -531,9 +532,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_get_by_id_get_serialize(
+    def _dataset_create_datapoint_post_serialize(
         self,
-        id,
+        files,
+        model,
         _request_auth,
         _content_type,
         _headers,
@@ -543,6 +545,7 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -556,12 +559,12 @@ class DatasetApi:
 
         # process the path parameters
         # process the query parameters
-        if id is not None:
-            
-            _query_params.append(('id', id))
-            
         # process the header parameters
         # process the form parameters
+        if files is not None:
+            _files['files'] = files
+        if model is not None:
+            _form_params.append(('model', model))
         # process the body parameter
 
 
@@ -575,6 +578,19 @@ class DatasetApi:
                 ]
             )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'multipart/form-data'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -583,8 +599,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/Dataset/GetById',
+            method='POST',
+            resource_path='/Dataset/CreateDatapoint',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -601,10 +617,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_import_post(
+    def dataset_get_by_id_get(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -617,14 +632,12 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ImportFromFileResult:
-        """Imports datapoints from a csv file.
+    ) -> GetDatasetByIdResult:
+        """Gets a dataset by its id.
 
 
-        :param dataset_id: The id of the dataset to import the datapoints to.
-        :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
+        :param id: The id of the dataset to get.
+        :type id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -647,9 +660,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_import_post_serialize(
-            dataset_id=dataset_id,
-            file=file,
+        _param = self._dataset_get_by_id_get_serialize(
+            id=id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -657,7 +669,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -671,10 +683,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_import_post_with_http_info(
+    def dataset_get_by_id_get_with_http_info(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -687,14 +698,12 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ImportFromFileResult]:
-        """Imports datapoints from a csv file.
+    ) -> ApiResponse[GetDatasetByIdResult]:
+        """Gets a dataset by its id.
 
 
-        :param dataset_id: The id of the dataset to import the datapoints to.
-        :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
+        :param id: The id of the dataset to get.
+        :type id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -717,9 +726,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_import_post_serialize(
-            dataset_id=dataset_id,
-            file=file,
+        _param = self._dataset_get_by_id_get_serialize(
+            id=id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -727,7 +735,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -741,10 +749,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_import_post_without_preload_content(
+    def dataset_get_by_id_get_without_preload_content(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -758,13 +765,11 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Imports datapoints from a csv file.
+        """Gets a dataset by its id.
 
 
-        :param dataset_id: The id of the dataset to import the datapoints to.
-        :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
+        :param id: The id of the dataset to get.
+        :type id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -787,9 +792,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_import_post_serialize(
-            dataset_id=dataset_id,
-            file=file,
+        _param = self._dataset_get_by_id_get_serialize(
+            id=id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -797,7 +801,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -806,10 +810,9 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_import_post_serialize(
+    def _dataset_get_by_id_get_serialize(
         self,
-        dataset_id,
-        file,
+        id,
         _request_auth,
         _content_type,
         _headers,
@@ -832,14 +835,12 @@ class DatasetApi:
 
         # process the path parameters
         # process the query parameters
-        if dataset_id is not None:
+        if id is not None:
             
-            _query_params.append(('datasetId', dataset_id))
+            _query_params.append(('id', id))
             
         # process the header parameters
         # process the form parameters
-        if file is not None:
-            _files['file'] = file
         # process the body parameter
 
 
@@ -853,19 +854,6 @@ class DatasetApi:
                 ]
             )
 
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'multipart/form-data'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -874,8 +862,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Dataset/Import',
+            method='GET',
+            resource_path='/Dataset/GetById',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -892,10 +880,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_update_name_post(
+    def dataset_import_post(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
-        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -908,14 +896,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Updates the name of a dataset.
+    ) -> ImportFromFileResult:
+        """Imports datapoints from a csv file.
 
 
-        :param id: The id of the dataset to update.
-        :type id: str
-        :param name: The new name of the dataset.
-        :type name: str
+        :param dataset_id: The id of the dataset to import the datapoints to.
+        :type dataset_id: str
+        :param file: The csv file to import.
+        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -938,9 +926,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_update_name_post_serialize(
-            id=id,
-            name=name,
+        _param = self._dataset_import_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -948,7 +936,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -962,10 +950,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_update_name_post_with_http_info(
+    def dataset_import_post_with_http_info(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
-        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -978,14 +966,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Updates the name of a dataset.
+    ) -> ApiResponse[ImportFromFileResult]:
+        """Imports datapoints from a csv file.
 
 
-        :param id: The id of the dataset to update.
-        :type id: str
-        :param name: The new name of the dataset.
-        :type name: str
+        :param dataset_id: The id of the dataset to import the datapoints to.
+        :type dataset_id: str
+        :param file: The csv file to import.
+        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1008,9 +996,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_update_name_post_serialize(
-            id=id,
-            name=name,
+        _param = self._dataset_import_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1018,7 +1006,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1032,10 +1020,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_update_name_post_without_preload_content(
+    def dataset_import_post_without_preload_content(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
-        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1049,13 +1037,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Updates the name of a dataset.
+        """Imports datapoints from a csv file.
 
 
-        :param id: The id of the dataset to update.
-        :type id: str
-        :param name: The new name of the dataset.
-        :type name: str
+        :param dataset_id: The id of the dataset to import the datapoints to.
+        :type dataset_id: str
+        :param file: The csv file to import.
+        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1078,9 +1066,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_update_name_post_serialize(
-            id=id,
-            name=name,
+        _param = self._dataset_import_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1088,7 +1076,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1097,10 +1085,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_update_name_post_serialize(
+    def _dataset_import_post_serialize(
         self,
-        id,
-        name,
+        dataset_id,
+        file,
         _request_auth,
         _content_type,
         _headers,
@@ -1123,20 +1111,40 @@ class DatasetApi:
 
         # process the path parameters
         # process the query parameters
-        if id is not None:
-            
-            _query_params.append(('id', id))
-            
-        if name is not None:
+        if dataset_id is not None:
             
-            _query_params.append(('name', name))
+            _query_params.append(('datasetId', dataset_id))
             
         # process the header parameters
         # process the form parameters
+        if file is not None:
+            _files['file'] = file
         # process the body parameter
 
 
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'text/plain', 
+                    'application/json', 
+                    'text/json'
+                ]
+            )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'multipart/form-data'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -1146,7 +1154,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/UpdateName',
+            resource_path='/Dataset/Import',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1163,10 +1171,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_datapoint_post(
+    def dataset_update_name_post(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the datapoint to.")] = None,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to create the asset from.")] = None,
+        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
+        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1179,14 +1187,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UploadDatapointsResult:
-        """Creates a new multi asset datapoint.
+    ) -> None:
+        """Updates the name of a dataset.
 
 
-        :param dataset_id: The id of the dataset to upload the datapoint to.
-        :type dataset_id: str
-        :param files: The image files to create the asset from.
-        :type files: List[bytearray]
+        :param id: The id of the dataset to update.
+        :type id: str
+        :param name: The new name of the dataset.
+        :type name: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1209,9 +1217,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_datapoint_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
+        _param = self._dataset_update_name_post_serialize(
+            id=id,
+            name=name,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1219,7 +1227,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1233,10 +1241,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_datapoint_post_with_http_info(
+    def dataset_update_name_post_with_http_info(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the datapoint to.")] = None,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to create the asset from.")] = None,
+        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
+        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1249,14 +1257,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UploadDatapointsResult]:
-        """Creates a new multi asset datapoint.
+    ) -> ApiResponse[None]:
+        """Updates the name of a dataset.
 
 
-        :param dataset_id: The id of the dataset to upload the datapoint to.
-        :type dataset_id: str
-        :param files: The image files to create the asset from.
-        :type files: List[bytearray]
+        :param id: The id of the dataset to update.
+        :type id: str
+        :param name: The new name of the dataset.
+        :type name: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1279,9 +1287,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_datapoint_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
+        _param = self._dataset_update_name_post_serialize(
+            id=id,
+            name=name,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1289,7 +1297,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1303,10 +1311,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_datapoint_post_without_preload_content(
+    def dataset_update_name_post_without_preload_content(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the datapoint to.")] = None,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to create the asset from.")] = None,
+        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
+        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1320,13 +1328,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Creates a new multi asset datapoint.
+        """Updates the name of a dataset.
 
 
-        :param dataset_id: The id of the dataset to upload the datapoint to.
-        :type dataset_id: str
-        :param files: The image files to create the asset from.
-        :type files: List[bytearray]
+        :param id: The id of the dataset to update.
+        :type id: str
+        :param name: The new name of the dataset.
+        :type name: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1349,9 +1357,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_datapoint_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
+        _param = self._dataset_update_name_post_serialize(
+            id=id,
+            name=name,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1359,7 +1367,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1368,10 +1376,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_upload_datapoint_post_serialize(
+    def _dataset_update_name_post_serialize(
         self,
-        dataset_id,
-        files,
+        id,
+        name,
         _request_auth,
         _content_type,
         _headers,
@@ -1381,7 +1389,6 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -1395,40 +1402,20 @@ class DatasetApi:
 
         # process the path parameters
         # process the query parameters
-        if dataset_id is not None:
+        if id is not None:
             
-            _query_params.append(('datasetId', dataset_id))
+            _query_params.append(('id', id))
+            
+        if name is not None:
+            
+            _query_params.append(('name', name))
             
         # process the header parameters
         # process the form parameters
-        if files is not None:
-            _files['files'] = files
         # process the body parameter
 
 
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
 
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'multipart/form-data'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -1438,7 +1425,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/UploadDatapoint',
+            resource_path='/Dataset/UpdateName',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1455,9 +1442,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_files_from_s3_post(
+    def dataset_upload_datapoint_post(
         self,
-        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the datapoint to.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to create the asset from.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1471,12 +1459,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> UploadDatapointsResult:
-        """Uploads files from an S3 bucket to a dataset.
+        """Creates a new multi asset datapoint.
 
-        A new datapoint will be created for each file in the bucket.
 
-        :param upload_files_from_s3_bucket_model: The body of the request.
-        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
+        :param dataset_id: The id of the dataset to upload the datapoint to.
+        :type dataset_id: str
+        :param files: The image files to create the asset from.
+        :type files: List[bytearray]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1499,8 +1488,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_files_from_s3_post_serialize(
-            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
+        _param = self._dataset_upload_datapoint_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1522,9 +1512,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_files_from_s3_post_with_http_info(
+    def dataset_upload_datapoint_post_with_http_info(
         self,
-        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the datapoint to.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to create the asset from.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1538,12 +1529,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[UploadDatapointsResult]:
-        """Uploads files from an S3 bucket to a dataset.
+        """Creates a new multi asset datapoint.
 
-        A new datapoint will be created for each file in the bucket.
 
-        :param upload_files_from_s3_bucket_model: The body of the request.
-        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
+        :param dataset_id: The id of the dataset to upload the datapoint to.
+        :type dataset_id: str
+        :param files: The image files to create the asset from.
+        :type files: List[bytearray]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1566,8 +1558,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_files_from_s3_post_serialize(
-            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
+        _param = self._dataset_upload_datapoint_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1589,9 +1582,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_files_from_s3_post_without_preload_content(
+    def dataset_upload_datapoint_post_without_preload_content(
         self,
-        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the datapoint to.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to create the asset from.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1605,12 +1599,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Uploads files from an S3 bucket to a dataset.
+        """Creates a new multi asset datapoint.
 
-        A new datapoint will be created for each file in the bucket.
 
-        :param upload_files_from_s3_bucket_model: The body of the request.
-        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
+        :param dataset_id: The id of the dataset to upload the datapoint to.
+        :type dataset_id: str
+        :param files: The image files to create the asset from.
+        :type files: List[bytearray]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1633,8 +1628,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_files_from_s3_post_serialize(
-            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
+        _param = self._dataset_upload_datapoint_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1651,9 +1647,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_upload_files_from_s3_post_serialize(
+    def _dataset_upload_datapoint_post_serialize(
         self,
-        upload_files_from_s3_bucket_model,
+        dataset_id,
+        files,
         _request_auth,
         _content_type,
         _headers,
@@ -1663,6 +1660,7 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -1676,11 +1674,15 @@ class DatasetApi:
 
         # process the path parameters
         # process the query parameters
+        if dataset_id is not None:
+            
+            _query_params.append(('datasetId', dataset_id))
+            
         # process the header parameters
         # process the form parameters
+        if files is not None:
+            _files['files'] = files
         # process the body parameter
-        if upload_files_from_s3_bucket_model is not None:
-            _body_params = upload_files_from_s3_bucket_model
 
 
         # set the HTTP header `Accept`
@@ -1700,9 +1702,7 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
+                        'multipart/form-data'
                     ]
                 )
             )
@@ -1717,7 +1717,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/UploadFilesFromS3',
+            resource_path='/Dataset/UploadDatapoint',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1734,10 +1734,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_images_to_dataset_post(
+    def dataset_upload_files_from_s3_post(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the images to.")] = None,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
+        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1750,15 +1749,13 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Uploads images to a dataset.
+    ) -> UploadDatapointsResult:
+        """Uploads files from an S3 bucket to a dataset.
 
-        If multiple files are uploaded, a new datapoint will be created for each file.
+        A new datapoint will be created for each file in the bucket.
 
-        :param dataset_id: The id of the dataset to upload the images to.
-        :type dataset_id: str
-        :param files: The image files to upload.
-        :type files: List[bytearray]
+        :param upload_files_from_s3_bucket_model: The body of the request.
+        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1781,9 +1778,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_images_to_dataset_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
+        _param = self._dataset_upload_files_from_s3_post_serialize(
+            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1791,7 +1787,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1805,10 +1801,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_images_to_dataset_post_with_http_info(
+    def dataset_upload_files_from_s3_post_with_http_info(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the images to.")] = None,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
+        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1821,15 +1816,13 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Uploads images to a dataset.
+    ) -> ApiResponse[UploadDatapointsResult]:
+        """Uploads files from an S3 bucket to a dataset.
 
-        If multiple files are uploaded, a new datapoint will be created for each file.
+        A new datapoint will be created for each file in the bucket.
 
-        :param dataset_id: The id of the dataset to upload the images to.
-        :type dataset_id: str
-        :param files: The image files to upload.
-        :type files: List[bytearray]
+        :param upload_files_from_s3_bucket_model: The body of the request.
+        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1852,9 +1845,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_images_to_dataset_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
+        _param = self._dataset_upload_files_from_s3_post_serialize(
+            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1862,7 +1854,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1876,10 +1868,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_images_to_dataset_post_without_preload_content(
+    def dataset_upload_files_from_s3_post_without_preload_content(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the images to.")] = None,
-        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
+        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1893,14 +1884,12 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Uploads images to a dataset.
+        """Uploads files from an S3 bucket to a dataset.
 
-        If multiple files are uploaded, a new datapoint will be created for each file.
+        A new datapoint will be created for each file in the bucket.
 
-        :param dataset_id: The id of the dataset to upload the images to.
-        :type dataset_id: str
-        :param files: The image files to upload.
-        :type files: List[bytearray]
+        :param upload_files_from_s3_bucket_model: The body of the request.
+        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1923,9 +1912,8 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_images_to_dataset_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
+        _param = self._dataset_upload_files_from_s3_post_serialize(
+            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1933,7 +1921,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1942,10 +1930,9 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_upload_images_to_dataset_post_serialize(
+    def _dataset_upload_files_from_s3_post_serialize(
         self,
-        dataset_id,
-        files,
+        upload_files_from_s3_bucket_model,
         _request_auth,
         _content_type,
         _headers,
@@ -1955,7 +1942,6 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -1969,17 +1955,22 @@ class DatasetApi:
 
         # process the path parameters
         # process the query parameters
-        if dataset_id is not None:
-            
-            _query_params.append(('datasetId', dataset_id))
-            
         # process the header parameters
         # process the form parameters
-        if files is not None:
-            _files['files'] = files
         # process the body parameter
+        if upload_files_from_s3_bucket_model is not None:
+            _body_params = upload_files_from_s3_bucket_model
 
 
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'text/plain', 
+                    'application/json', 
+                    'text/json'
+                ]
+            )
 
         # set the HTTP header `Content-Type`
         if _content_type:
@@ -1988,7 +1979,9 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'multipart/form-data'
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
                     ]
                 )
             )
@@ -2003,7 +1996,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/UploadImagesToDataset',
+            resource_path='/Dataset/UploadFilesFromS3',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2020,9 +2013,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_text_sources_to_dataset_post(
+    def dataset_upload_images_to_dataset_post(
         self,
-        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the images to.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2035,13 +2029,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UploadDatapointsResult:
-        """Creates new datapoints from text sources.
+    ) -> None:
+        """Uploads images to a dataset.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        If multiple files are uploaded, a new datapoint will be created for each file.
 
-        :param upload_text_sources_to_dataset_model: The body of the request.
-        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
+        :param dataset_id: The id of the dataset to upload the images to.
+        :type dataset_id: str
+        :param files: The image files to upload.
+        :type files: List[bytearray]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2064,8 +2060,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_text_sources_to_dataset_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_upload_images_to_dataset_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2073,7 +2070,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2087,9 +2084,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_text_sources_to_dataset_post_with_http_info(
+    def dataset_upload_images_to_dataset_post_with_http_info(
         self,
-        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the images to.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2102,13 +2100,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UploadDatapointsResult]:
-        """Creates new datapoints from text sources.
+    ) -> ApiResponse[None]:
+        """Uploads images to a dataset.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        If multiple files are uploaded, a new datapoint will be created for each file.
 
-        :param upload_text_sources_to_dataset_model: The body of the request.
-        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
+        :param dataset_id: The id of the dataset to upload the images to.
+        :type dataset_id: str
+        :param files: The image files to upload.
+        :type files: List[bytearray]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2131,8 +2131,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_text_sources_to_dataset_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_upload_images_to_dataset_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2140,7 +2141,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2154,9 +2155,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_text_sources_to_dataset_post_without_preload_content(
+    def dataset_upload_images_to_dataset_post_without_preload_content(
         self,
-        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to upload the images to.")] = None,
+        files: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The image files to upload.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2170,12 +2172,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Creates new datapoints from text sources.
+        """Uploads images to a dataset.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        If multiple files are uploaded, a new datapoint will be created for each file.
 
-        :param upload_text_sources_to_dataset_model: The body of the request.
-        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
+        :param dataset_id: The id of the dataset to upload the images to.
+        :type dataset_id: str
+        :param files: The image files to upload.
+        :type files: List[bytearray]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2198,8 +2202,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_upload_text_sources_to_dataset_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_upload_images_to_dataset_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2207,7 +2212,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2216,9 +2221,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_upload_text_sources_to_dataset_post_serialize(
+    def _dataset_upload_images_to_dataset_post_serialize(
         self,
-        upload_text_sources_to_dataset_model,
+        dataset_id,
+        files,
         _request_auth,
         _content_type,
         _headers,
@@ -2228,6 +2234,7 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -2241,22 +2248,17 @@ class DatasetApi:
 
         # process the path parameters
         # process the query parameters
+        if dataset_id is not None:
+            
+            _query_params.append(('datasetId', dataset_id))
+            
         # process the header parameters
         # process the form parameters
+        if files is not None:
+            _files['files'] = files
         # process the body parameter
-        if upload_text_sources_to_dataset_model is not None:
-            _body_params = upload_text_sources_to_dataset_model
 
 
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
 
         # set the HTTP header `Content-Type`
         if _content_type:
@@ -2265,9 +2267,7 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
+                        'multipart/form-data'
                     ]
                 )
             )
@@ -2282,7 +2282,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/UploadTextSourcesToDataset',
+            resource_path='/Dataset/UploadImagesToDataset',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,