rapidata 2.15.0__py3-none-any.whl → 2.16.0__py3-none-any.whl

rapidata/api_client/api/dataset_api.py

@@ -19,13 +19,18 @@ from typing_extensions import Annotated
 from pydantic import Field, StrictBytes, StrictStr
 from typing import List, Optional, Tuple, Union
 from typing_extensions import Annotated
+from rapidata.api_client.models.create_datapoint_from_files_model import CreateDatapointFromFilesModel
+from rapidata.api_client.models.create_datapoint_from_text_sources_model import CreateDatapointFromTextSourcesModel
 from rapidata.api_client.models.create_datapoint_from_urls_model import CreateDatapointFromUrlsModel
 from rapidata.api_client.models.create_datapoint_result import CreateDatapointResult
+from rapidata.api_client.models.create_datapoints_from_s3_bucket_model import CreateDatapointsFromS3BucketModel
 from rapidata.api_client.models.datapoint_metadata_model import DatapointMetadataModel
+from rapidata.api_client.models.get_datapoints_by_dataset_id_result import GetDatapointsByDatasetIdResult
 from rapidata.api_client.models.get_dataset_by_id_result import GetDatasetByIdResult
 from rapidata.api_client.models.get_dataset_progress_result import GetDatasetProgressResult
 from rapidata.api_client.models.get_failed_datapoints_result import GetFailedDatapointsResult
 from rapidata.api_client.models.import_from_file_result import ImportFromFileResult
+from rapidata.api_client.models.update_dataset_name_model import UpdateDatasetNameModel
 from rapidata.api_client.models.upload_files_from_s3_bucket_model import UploadFilesFromS3BucketModel
 from rapidata.api_client.models.upload_from_s3_result import UploadFromS3Result
 from rapidata.api_client.models.upload_text_sources_to_dataset_model import UploadTextSourcesToDatasetModel
@@ -49,7 +54,439 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_creat_text_datapoint_post(
+    def dataset_createdatapoint_post(
+        self,
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[DatapointMetadataModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> CreateDatapointResult:
+        """(Deprecated) Creates a single datapoint.
+
+        If multiple files are uploaded, a multi asset datapoint will be created.
+
+        :param files:
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        warnings.warn("POST /dataset/createdatapoint is deprecated.", DeprecationWarning)
+
+        _param = self._dataset_createdatapoint_post_serialize(
+            files=files,
+            model=model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def dataset_createdatapoint_post_with_http_info(
+        self,
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[DatapointMetadataModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[CreateDatapointResult]:
+        """(Deprecated) Creates a single datapoint.
+
+        If multiple files are uploaded, a multi asset datapoint will be created.
+
+        :param files:
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        warnings.warn("POST /dataset/createdatapoint is deprecated.", DeprecationWarning)
+
+        _param = self._dataset_createdatapoint_post_serialize(
+            files=files,
+            model=model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def dataset_createdatapoint_post_without_preload_content(
+        self,
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[DatapointMetadataModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """(Deprecated) Creates a single datapoint.
+
+        If multiple files are uploaded, a multi asset datapoint will be created.
+
+        :param files:
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        warnings.warn("POST /dataset/createdatapoint is deprecated.", DeprecationWarning)
+
+        _param = self._dataset_createdatapoint_post_serialize(
+            files=files,
+            model=model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _dataset_createdatapoint_post_serialize(
+        self,
+        files,
+        model,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'files': 'multi',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # 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
+
+
+        # 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', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/dataset/createdatapoint',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def dataset_creattextdatapoint_post(
+        self,
+        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)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> CreateDatapointResult:
+        """(Deprecated) Creates new datapoints from text sources.
+
+        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        warnings.warn("POST /dataset/creattextdatapoint is deprecated.", DeprecationWarning)
+
+        _param = self._dataset_creattextdatapoint_post_serialize(
+            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def dataset_creattextdatapoint_post_with_http_info(
+        self,
+        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)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[CreateDatapointResult]:
+        """(Deprecated) Creates new datapoints from text sources.
+
+        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        warnings.warn("POST /dataset/creattextdatapoint is deprecated.", DeprecationWarning)
+
+        _param = self._dataset_creattextdatapoint_post_serialize(
+            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def dataset_creattextdatapoint_post_without_preload_content(
         self,
         upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
@@ -64,13 +501,1578 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """(Deprecated) Creates new datapoints from text sources.
+
+        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        warnings.warn("POST /dataset/creattextdatapoint is deprecated.", DeprecationWarning)
+
+        _param = self._dataset_creattextdatapoint_post_serialize(
+            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _dataset_creattextdatapoint_post_serialize(
+        self,
+        upload_text_sources_to_dataset_model,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # 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:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/dataset/creattextdatapoint',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_csv_post(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
+        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)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ImportFromFileResult:
+        """Creates multiple datapoints from a csv.
+
+
+        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ImportFromFileResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_csv_post_with_http_info(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
+        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)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[ImportFromFileResult]:
+        """Creates multiple datapoints from a csv.
+
+
+        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ImportFromFileResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_csv_post_without_preload_content(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
+        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)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Creates multiple datapoints from a csv.
+
+
+        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ImportFromFileResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _dataset_dataset_id_datapoints_csv_post_serialize(
+        self,
+        dataset_id,
+        file,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
+        # process the query parameters
+        # 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', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/dataset/{datasetId}/datapoints/csv',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_failed_get(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> GetFailedDatapointsResult:
+        """Gets a list of all datapoints that failed to upload.
+
+        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL  and the URL is not accessible.
+
+        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :type dataset_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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+            dataset_id=dataset_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetFailedDatapointsResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_failed_get_with_http_info(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[GetFailedDatapointsResult]:
+        """Gets a list of all datapoints that failed to upload.
+
+        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL  and the URL is not accessible.
+
+        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :type dataset_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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+            dataset_id=dataset_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetFailedDatapointsResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_failed_get_without_preload_content(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Gets a list of all datapoints that failed to upload.
+
+        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL  and the URL is not accessible.
+
+        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :type dataset_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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+            dataset_id=dataset_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetFailedDatapointsResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _dataset_dataset_id_datapoints_failed_get_serialize(
+        self,
+        dataset_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # 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'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/dataset/{datasetId}/datapoints/failed',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_files_post(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[CreateDatapointFromFilesModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> CreateDatapointResult:
+        """Creates a single datapoint by uploading files.
+
+        If multiple files are uploaded, a multi asset datapoint will be created.
+
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param files:
+        :type files: List[bytearray]
+        :param model:
+        :type model: CreateDatapointFromFilesModel
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
+            model=model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_files_post_with_http_info(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[CreateDatapointFromFilesModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[CreateDatapointResult]:
+        """Creates a single datapoint by uploading files.
+
+        If multiple files are uploaded, a multi asset datapoint will be created.
+
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param files:
+        :type files: List[bytearray]
+        :param model:
+        :type model: CreateDatapointFromFilesModel
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
+            model=model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_files_post_without_preload_content(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[CreateDatapointFromFilesModel] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Creates a single datapoint by uploading files.
+
+        If multiple files are uploaded, a multi asset datapoint will be created.
+
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param files:
+        :type files: List[bytearray]
+        :param model:
+        :type model: CreateDatapointFromFilesModel
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
+            dataset_id=dataset_id,
+            files=files,
+            model=model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateDatapointResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _dataset_dataset_id_datapoints_files_post_serialize(
+        self,
+        dataset_id,
+        files,
+        model,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'files': 'multi',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
+        # 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
+
+
+        # 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', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/dataset/{datasetId}/datapoints/files',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_get(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> GetDatapointsByDatasetIdResult:
+        """Gets all datapoints of a dataset.
+
+
+        :param dataset_id: The id of the dataset to get the datapoints of. (required)
+        :type dataset_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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_get_serialize(
+            dataset_id=dataset_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetDatapointsByDatasetIdResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_get_with_http_info(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[GetDatapointsByDatasetIdResult]:
+        """Gets all datapoints of a dataset.
+
+
+        :param dataset_id: The id of the dataset to get the datapoints of. (required)
+        :type dataset_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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_get_serialize(
+            dataset_id=dataset_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetDatapointsByDatasetIdResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_get_without_preload_content(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Gets all datapoints of a dataset.
+
+
+        :param dataset_id: The id of the dataset to get the datapoints of. (required)
+        :type dataset_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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_get_serialize(
+            dataset_id=dataset_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetDatapointsByDatasetIdResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _dataset_dataset_id_datapoints_get_serialize(
+        self,
+        dataset_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # 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'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/dataset/{datasetId}/datapoints',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_s3_post(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
+        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> UploadFromS3Result:
+        """Uploads files from an S3 bucket to a dataset.
+
+        A new datapoint will be created for each file in the bucket.
+
+        :param dataset_id: The id of the dataset to upload the files to. (required)
+        :type dataset_id: str
+        :param create_datapoints_from_s3_bucket_model: The body of the request.
+        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UploadFromS3Result",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_s3_post_with_http_info(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
+        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[UploadFromS3Result]:
+        """Uploads files from an S3 bucket to a dataset.
+
+        A new datapoint will be created for each file in the bucket.
+
+        :param dataset_id: The id of the dataset to upload the files to. (required)
+        :type dataset_id: str
+        :param create_datapoints_from_s3_bucket_model: The body of the request.
+        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UploadFromS3Result",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_s3_post_without_preload_content(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
+        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _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.
+
+        A new datapoint will be created for each file in the bucket.
+
+        :param dataset_id: The id of the dataset to upload the files to. (required)
+        :type dataset_id: str
+        :param create_datapoints_from_s3_bucket_model: The body of the request.
+        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UploadFromS3Result",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _dataset_dataset_id_datapoints_s3_post_serialize(
+        self,
+        dataset_id,
+        create_datapoints_from_s3_bucket_model,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if create_datapoints_from_s3_bucket_model is not None:
+            _body_params = create_datapoints_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:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/dataset/{datasetId}/datapoints/s3',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def dataset_dataset_id_datapoints_texts_post(
+        self,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> CreateDatapointResult:
-        """Creates new datapoints from text sources.
+        """Creates a single datapoint from text sources.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        If multiple text sources are uploaded, a multi asset datapoint will be created.
 
-        :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 create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_text_sources_model: The body of the request.
+        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
         :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
@@ -93,8 +2095,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_creat_text_datapoint_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -116,9 +2119,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_creat_text_datapoint_post_with_http_info(
+    def dataset_dataset_id_datapoints_texts_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[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -132,12 +2136,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[CreateDatapointResult]:
-        """Creates new datapoints from text sources.
+        """Creates a single datapoint from text sources.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        If multiple text sources are uploaded, a multi asset datapoint will be created.
 
-        :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 create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_text_sources_model: The body of the request.
+        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
         :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
@@ -160,8 +2166,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_creat_text_datapoint_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -183,9 +2190,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_creat_text_datapoint_post_without_preload_content(
+    def dataset_dataset_id_datapoints_texts_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[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -199,12 +2207,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.
+        """Creates a single datapoint from text sources.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        If multiple text sources are uploaded, a multi asset datapoint will be created.
 
-        :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 create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_text_sources_model: The body of the request.
+        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
         :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
@@ -227,8 +2237,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_creat_text_datapoint_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -245,9 +2256,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_creat_text_datapoint_post_serialize(
+    def _dataset_dataset_id_datapoints_texts_post_serialize(
         self,
-        upload_text_sources_to_dataset_model,
+        dataset_id,
+        create_datapoint_from_text_sources_model,
         _request_auth,
         _content_type,
         _headers,
@@ -269,12 +2281,14 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if upload_text_sources_to_dataset_model is not None:
-            _body_params = upload_text_sources_to_dataset_model
+        if create_datapoint_from_text_sources_model is not None:
+            _body_params = create_datapoint_from_text_sources_model
 
 
         # set the HTTP header `Accept`
@@ -311,7 +2325,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/CreatTextDatapoint',
+            resource_path='/dataset/{datasetId}/datapoints/texts',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -328,10 +2342,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_create_datapoint_post(
+    def dataset_dataset_id_datapoints_urls_post(
         self,
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -345,14 +2359,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> CreateDatapointResult:
-        """Creates a single datapoint.
+        """Creates a single datapoint where the assets are fetched from the specified urls.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        Passing in multiple urls will create a single datapoint with a MultiAsset.  Each url will be fetched and stored as a sub-asset of the MultiAsset.  <para />  If any of the urls are not accessible, the request will fail.
 
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_urls_model: The body of the request.
+        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
         :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
@@ -375,9 +2389,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_create_datapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -399,10 +2413,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_create_datapoint_post_with_http_info(
+    def dataset_dataset_id_datapoints_urls_post_with_http_info(
         self,
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -416,14 +2430,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[CreateDatapointResult]:
-        """Creates a single datapoint.
+        """Creates a single datapoint where the assets are fetched from the specified urls.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        Passing in multiple urls will create a single datapoint with a MultiAsset.  Each url will be fetched and stored as a sub-asset of the MultiAsset.  <para />  If any of the urls are not accessible, the request will fail.
 
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_urls_model: The body of the request.
+        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
         :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,9 +2460,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_create_datapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -470,10 +2484,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_create_datapoint_post_without_preload_content(
+    def dataset_dataset_id_datapoints_urls_post_without_preload_content(
         self,
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -487,14 +2501,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Creates a single datapoint.
+        """Creates a single datapoint where the assets are fetched from the specified urls.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        Passing in multiple urls will create a single datapoint with a MultiAsset.  Each url will be fetched and stored as a sub-asset of the MultiAsset.  <para />  If any of the urls are not accessible, the request will fail.
 
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_urls_model: The body of the request.
+        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
         :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
@@ -517,9 +2531,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_create_datapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -536,10 +2550,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_create_datapoint_post_serialize(
+    def _dataset_dataset_id_datapoints_urls_post_serialize(
         self,
-        files,
-        model,
+        dataset_id,
+        create_datapoint_from_urls_model,
         _request_auth,
         _content_type,
         _headers,
@@ -549,7 +2563,6 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -562,14 +2575,14 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
         # 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 create_datapoint_from_urls_model is not None:
+            _body_params = create_datapoint_from_urls_model
 
 
         # set the HTTP header `Accept`
@@ -589,7 +2602,9 @@ class DatasetApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'multipart/form-data'
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
                     ]
                 )
             )
@@ -604,7 +2619,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/CreateDatapoint',
+            resource_path='/dataset/{datasetId}/datapoints/urls',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -621,9 +2636,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_failed_get(
+    def dataset_dataset_id_get(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -636,12 +2651,11 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetFailedDatapointsResult:
-        """Gets a list of all datapoints that failed to upload.
+    ) -> GetDatasetByIdResult:
+        """Gets a dataset by its id.
 
-        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL  and the URL is not accessible.
 
-        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :param dataset_id: The id of the dataset to get. (required)
         :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -665,7 +2679,7 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+        _param = self._dataset_dataset_id_get_serialize(
             dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -674,7 +2688,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetFailedDatapointsResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -688,9 +2702,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_failed_get_with_http_info(
+    def dataset_dataset_id_get_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -703,12 +2717,11 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetFailedDatapointsResult]:
-        """Gets a list of all datapoints that failed to upload.
+    ) -> ApiResponse[GetDatasetByIdResult]:
+        """Gets a dataset by its id.
 
-        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL  and the URL is not accessible.
 
-        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :param dataset_id: The id of the dataset to get. (required)
         :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -732,7 +2745,7 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+        _param = self._dataset_dataset_id_get_serialize(
             dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -741,7 +2754,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetFailedDatapointsResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -755,9 +2768,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_failed_get_without_preload_content(
+    def dataset_dataset_id_get_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -771,11 +2784,10 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Gets a list of all datapoints that failed to upload.
+        """Gets a dataset by its id.
 
-        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL  and the URL is not accessible.
 
-        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :param dataset_id: The id of the dataset to get. (required)
         :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -799,7 +2811,7 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+        _param = self._dataset_dataset_id_get_serialize(
             dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -808,7 +2820,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetFailedDatapointsResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -817,7 +2829,7 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_dataset_id_datapoints_failed_get_serialize(
+    def _dataset_dataset_id_get_serialize(
         self,
         dataset_id,
         _request_auth,
@@ -868,7 +2880,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/dataset/{datasetId}/datapoints/failed',
+            resource_path='/dataset/{datasetId}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -885,10 +2897,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_urls_post(
+    def dataset_dataset_id_name_patch(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
+        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -901,15 +2913,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateDatapointResult:
-        """Creates new datapoint where the assets are fetched from the specified urls.
+    ) -> None:
+        """Updates the name of a dataset.
 
-        Passing in multiple urls will create a single datapoint with a MultiAsset.  Each url will be fetched and stored as a sub-asset of the MultiAsset.  <para />  If any of the urls are not accessible, the request will fail.
 
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :param dataset_id: The id of the dataset to update. (required)
         :type dataset_id: str
-        :param create_datapoint_from_urls_model: The body of the request.
-        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
+        :param update_dataset_name_model: The body of the request.
+        :type update_dataset_name_model: UpdateDatasetNameModel
         :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
@@ -932,9 +2943,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+        _param = self._dataset_dataset_id_name_patch_serialize(
             dataset_id=dataset_id,
-            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
+            update_dataset_name_model=update_dataset_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -942,7 +2953,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -956,10 +2967,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_urls_post_with_http_info(
+    def dataset_dataset_id_name_patch_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
+        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -972,15 +2983,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[CreateDatapointResult]:
-        """Creates new datapoint where the assets are fetched from the specified urls.
+    ) -> ApiResponse[None]:
+        """Updates the name of a dataset.
 
-        Passing in multiple urls will create a single datapoint with a MultiAsset.  Each url will be fetched and stored as a sub-asset of the MultiAsset.  <para />  If any of the urls are not accessible, the request will fail.
 
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :param dataset_id: The id of the dataset to update. (required)
         :type dataset_id: str
-        :param create_datapoint_from_urls_model: The body of the request.
-        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
+        :param update_dataset_name_model: The body of the request.
+        :type update_dataset_name_model: UpdateDatasetNameModel
         :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
@@ -1003,9 +3013,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+        _param = self._dataset_dataset_id_name_patch_serialize(
             dataset_id=dataset_id,
-            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
+            update_dataset_name_model=update_dataset_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1013,7 +3023,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1027,10 +3037,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_urls_post_without_preload_content(
+    def dataset_dataset_id_name_patch_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
+        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1044,14 +3054,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Creates new datapoint where the assets are fetched from the specified urls.
+        """Updates the name of a dataset.
 
-        Passing in multiple urls will create a single datapoint with a MultiAsset.  Each url will be fetched and stored as a sub-asset of the MultiAsset.  <para />  If any of the urls are not accessible, the request will fail.
 
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :param dataset_id: The id of the dataset to update. (required)
         :type dataset_id: str
-        :param create_datapoint_from_urls_model: The body of the request.
-        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
+        :param update_dataset_name_model: The body of the request.
+        :type update_dataset_name_model: UpdateDatasetNameModel
         :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
@@ -1074,9 +3083,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+        _param = self._dataset_dataset_id_name_patch_serialize(
             dataset_id=dataset_id,
-            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
+            update_dataset_name_model=update_dataset_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1084,7 +3093,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1093,10 +3102,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_dataset_id_datapoints_urls_post_serialize(
+    def _dataset_dataset_id_name_patch_serialize(
         self,
         dataset_id,
-        create_datapoint_from_urls_model,
+        update_dataset_name_model,
         _request_auth,
         _content_type,
         _headers,
@@ -1124,19 +3133,10 @@ class DatasetApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if create_datapoint_from_urls_model is not None:
-            _body_params = create_datapoint_from_urls_model
+        if update_dataset_name_model is not None:
+            _body_params = update_dataset_name_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:
@@ -1161,8 +3161,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/{datasetId}/datapoints/urls',
+            method='PATCH',
+            resource_path='/dataset/{datasetId}/name',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1440,7 +3440,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_get_by_id_get(
+    def dataset_getbyid_get(
         self,
         id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
         _request_timeout: Union[
@@ -1456,7 +3456,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> GetDatasetByIdResult:
-        """Gets a dataset by its id.
+        """(Deprecated) Gets a dataset by its id.
 
 
         :param id: The id of the dataset to get.
@@ -1482,8 +3482,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("GET /dataset/getbyid is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_get_by_id_get_serialize(
+        _param = self._dataset_getbyid_get_serialize(
             id=id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1506,7 +3507,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_get_by_id_get_with_http_info(
+    def dataset_getbyid_get_with_http_info(
         self,
         id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
         _request_timeout: Union[
@@ -1522,7 +3523,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[GetDatasetByIdResult]:
-        """Gets a dataset by its id.
+        """(Deprecated) Gets a dataset by its id.
 
 
         :param id: The id of the dataset to get.
@@ -1548,8 +3549,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("GET /dataset/getbyid is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_get_by_id_get_serialize(
+        _param = self._dataset_getbyid_get_serialize(
             id=id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1572,7 +3574,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_get_by_id_get_without_preload_content(
+    def dataset_getbyid_get_without_preload_content(
         self,
         id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
         _request_timeout: Union[
@@ -1588,7 +3590,7 @@ 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.
+        """(Deprecated) Gets a dataset by its id.
 
 
         :param id: The id of the dataset to get.
@@ -1614,8 +3616,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("GET /dataset/getbyid is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_get_by_id_get_serialize(
+        _param = self._dataset_getbyid_get_serialize(
             id=id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1633,7 +3636,7 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_get_by_id_get_serialize(
+    def _dataset_getbyid_get_serialize(
         self,
         id,
         _request_auth,
@@ -1686,7 +3689,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/Dataset/GetById',
+            resource_path='/dataset/getbyid',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1720,7 +3723,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ImportFromFileResult:
-        """Imports datapoints from a csv file.
+        """(Deprecated) Imports datapoints from a csv file.
 
 
         :param dataset_id: The id of the dataset to import the datapoints to.
@@ -1748,6 +3751,7 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/import is deprecated.", DeprecationWarning)
 
         _param = self._dataset_import_post_serialize(
             dataset_id=dataset_id,
@@ -1790,7 +3794,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[ImportFromFileResult]:
-        """Imports datapoints from a csv file.
+        """(Deprecated) Imports datapoints from a csv file.
 
 
         :param dataset_id: The id of the dataset to import the datapoints to.
@@ -1818,6 +3822,7 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/import is deprecated.", DeprecationWarning)
 
         _param = self._dataset_import_post_serialize(
             dataset_id=dataset_id,
@@ -1860,7 +3865,7 @@ 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.
+        """(Deprecated) Imports datapoints from a csv file.
 
 
         :param dataset_id: The id of the dataset to import the datapoints to.
@@ -1888,6 +3893,7 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/import is deprecated.", DeprecationWarning)
 
         _param = self._dataset_import_post_serialize(
             dataset_id=dataset_id,
@@ -1977,7 +3983,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/Import',
+            resource_path='/dataset/import',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1994,7 +4000,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_update_name_post(
+    def dataset_updatename_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,
@@ -2011,7 +4017,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Updates the name of a dataset.
+        """(Deprecated) Updates the name of a dataset.
 
 
         :param id: The id of the dataset to update.
@@ -2039,8 +4045,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/updatename is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_update_name_post_serialize(
+        _param = self._dataset_updatename_post_serialize(
             id=id,
             name=name,
             _request_auth=_request_auth,
@@ -2064,7 +4071,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_update_name_post_with_http_info(
+    def dataset_updatename_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,
@@ -2081,7 +4088,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Updates the name of a dataset.
+        """(Deprecated) Updates the name of a dataset.
 
 
         :param id: The id of the dataset to update.
@@ -2109,8 +4116,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/updatename is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_update_name_post_serialize(
+        _param = self._dataset_updatename_post_serialize(
             id=id,
             name=name,
             _request_auth=_request_auth,
@@ -2134,7 +4142,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_update_name_post_without_preload_content(
+    def dataset_updatename_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,
@@ -2151,7 +4159,7 @@ 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.
+        """(Deprecated) Updates the name of a dataset.
 
 
         :param id: The id of the dataset to update.
@@ -2179,8 +4187,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/updatename is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_update_name_post_serialize(
+        _param = self._dataset_updatename_post_serialize(
             id=id,
             name=name,
             _request_auth=_request_auth,
@@ -2199,7 +4208,7 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_update_name_post_serialize(
+    def _dataset_updatename_post_serialize(
         self,
         id,
         name,
@@ -2248,7 +4257,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/UpdateName',
+            resource_path='/dataset/updatename',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2265,7 +4274,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_files_from_s3_post(
+    def dataset_uploadfilesfroms3_post(
         self,
         upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
@@ -2281,7 +4290,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> UploadFromS3Result:
-        """Uploads files from an S3 bucket to a dataset.
+        """(Deprecated) Uploads files from an S3 bucket to a dataset.
 
         A new datapoint will be created for each file in the bucket.
 
@@ -2308,8 +4317,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/uploadfilesfroms3 is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_upload_files_from_s3_post_serialize(
+        _param = self._dataset_uploadfilesfroms3_post_serialize(
             upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2332,7 +4342,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_files_from_s3_post_with_http_info(
+    def dataset_uploadfilesfroms3_post_with_http_info(
         self,
         upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
@@ -2348,7 +4358,7 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[UploadFromS3Result]:
-        """Uploads files from an S3 bucket to a dataset.
+        """(Deprecated) Uploads files from an S3 bucket to a dataset.
 
         A new datapoint will be created for each file in the bucket.
 
@@ -2375,8 +4385,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/uploadfilesfroms3 is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_upload_files_from_s3_post_serialize(
+        _param = self._dataset_uploadfilesfroms3_post_serialize(
             upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2399,7 +4410,7 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_upload_files_from_s3_post_without_preload_content(
+    def dataset_uploadfilesfroms3_post_without_preload_content(
         self,
         upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
@@ -2415,7 +4426,7 @@ 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.
+        """(Deprecated) Uploads files from an S3 bucket to a dataset.
 
         A new datapoint will be created for each file in the bucket.
 
@@ -2442,8 +4453,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
+        warnings.warn("POST /dataset/uploadfilesfroms3 is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_upload_files_from_s3_post_serialize(
+        _param = self._dataset_uploadfilesfroms3_post_serialize(
             upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2461,7 +4473,7 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_upload_files_from_s3_post_serialize(
+    def _dataset_uploadfilesfroms3_post_serialize(
         self,
         upload_files_from_s3_bucket_model,
         _request_auth,
@@ -2527,7 +4539,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Dataset/UploadFilesFromS3',
+            resource_path='/dataset/uploadfilesfroms3',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,