rapidata 1.1.0__py3-none-any.whl → 1.2.1__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'
                     ]
                 )
             )
@@ -315,12 +301,13 @@ class DatasetApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,
@@ -337,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)],
@@ -352,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
@@ -380,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,
@@ -389,7 +381,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -403,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)],
@@ -418,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
@@ -446,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,
@@ -455,7 +452,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -469,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)],
@@ -485,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
@@ -512,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,
@@ -521,7 +523,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -530,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,
@@ -542,6 +545,7 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -555,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
 
 
@@ -574,15 +578,29 @@ 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] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,
@@ -599,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)],
@@ -615,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
@@ -645,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,
@@ -655,7 +669,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -669,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)],
@@ -685,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
@@ -715,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,
@@ -725,7 +735,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -739,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)],
@@ -756,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
@@ -785,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,
@@ -795,7 +801,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -804,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,
@@ -830,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
 
 
@@ -851,28 +854,16 @@ 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] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,
@@ -889,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)],
@@ -905,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
@@ -935,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,
@@ -945,7 +936,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -959,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)],
@@ -975,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
@@ -1005,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,
@@ -1015,7 +1006,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1029,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)],
@@ -1046,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
@@ -1075,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,
@@ -1085,7 +1076,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1094,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,
@@ -1120,29 +1111,50 @@ 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] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,
@@ -1159,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)],
@@ -1175,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
@@ -1205,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,
@@ -1215,7 +1227,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1229,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)],
@@ -1245,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
@@ -1275,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,
@@ -1285,7 +1297,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1299,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)],
@@ -1316,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
@@ -1345,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,
@@ -1355,7 +1367,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1364,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,
@@ -1377,7 +1389,6 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -1391,49 +1402,30 @@ 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] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,
@@ -1450,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)],
@@ -1466,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
@@ -1494,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,
@@ -1517,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)],
@@ -1533,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
@@ -1561,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,
@@ -1584,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)],
@@ -1600,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
@@ -1628,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,
@@ -1646,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,
@@ -1658,6 +1660,7 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -1671,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`
@@ -1695,9 +1702,7 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
+                        'multipart/form-data'
                     ]
                 )
             )
@@ -1706,12 +1711,13 @@ class DatasetApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,
@@ -1728,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)],
@@ -1744,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
@@ -1775,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,
@@ -1785,7 +1787,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1799,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)],
@@ -1815,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
@@ -1846,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,
@@ -1856,7 +1854,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1870,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)],
@@ -1887,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
@@ -1917,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,
@@ -1927,7 +1921,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UploadDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1936,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,
@@ -1949,7 +1942,6 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -1963,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:
@@ -1982,7 +1979,9 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'multipart/form-data'
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
                     ]
                 )
             )
@@ -1991,12 +1990,13 @@ class DatasetApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,
@@ -2013,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)],
@@ -2028,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
@@ -2057,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,
@@ -2066,7 +2070,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2080,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)],
@@ -2095,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
@@ -2124,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,
@@ -2133,7 +2141,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2147,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)],
@@ -2163,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
@@ -2191,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,
@@ -2200,7 +2212,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadDatapointsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2209,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,
@@ -2221,6 +2234,7 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -2234,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:
@@ -2258,9 +2267,7 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
+                        'multipart/form-data'
                     ]
                 )
             )
@@ -2269,12 +2276,13 @@ class DatasetApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer'
+            'bearer', 
+            'oauth2'
         ]
 
         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,