arize 8.0.0a14__py3-none-any.whl → 8.0.0a16__py3-none-any.whl

arize/_generated/api_client/api/experiments_api.py

@@ -3,7 +3,7 @@
 """
     Arize REST API
 
-    API specification for the backend data server. The API is hosted globally at https://app.arize.com/api/v1 or in your own environment. You can access the OpenAPI spec for this API at https://app.arize.com/api/v1/spec.yaml 
+    API specification for the backend data server. The API is hosted globally at https://api.arize.com/v2 or in your own environment. You can access the OpenAPI spec for this API at https://api.arize.com/v2/spec.yaml 
 
     The version of the OpenAPI document: 0.0.1
     Generated by OpenAPI Generator (https://openapi-generator.tech)
@@ -19,7 +19,10 @@ from typing_extensions import Annotated
 from pydantic import Field, StrictInt, StrictStr
 from typing import Optional
 from typing_extensions import Annotated
+from arize._generated.api_client.models.experiment import Experiment
+from arize._generated.api_client.models.experiments_create_request import ExperimentsCreateRequest
 from arize._generated.api_client.models.experiments_list200_response import ExperimentsList200Response
+from arize._generated.api_client.models.experiments_runs_list200_response import ExperimentsRunsList200Response
 
 from arize._generated.api_client.api_client import ApiClient, RequestSerialized
 from arize._generated.api_client.api_response import ApiResponse
@@ -39,6 +42,295 @@ class ExperimentsApi:
         self.api_client = api_client
 
 
+    @validate_call
+    def experiments_create(
+        self,
+        experiments_create_request: Annotated[ExperimentsCreateRequest, Field(description="Body containing experiment creation parameters")],
+        _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,
+    ) -> Experiment:
+        """Create a new experiment with run data
+
+
+        :param experiments_create_request: Body containing experiment creation parameters (required)
+        :type experiments_create_request: ExperimentsCreateRequest
+        :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._experiments_create_serialize(
+            experiments_create_request=experiments_create_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '201': "Experiment",
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '409': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        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 experiments_create_with_http_info(
+        self,
+        experiments_create_request: Annotated[ExperimentsCreateRequest, Field(description="Body containing experiment creation parameters")],
+        _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[Experiment]:
+        """Create a new experiment with run data
+
+
+        :param experiments_create_request: Body containing experiment creation parameters (required)
+        :type experiments_create_request: ExperimentsCreateRequest
+        :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._experiments_create_serialize(
+            experiments_create_request=experiments_create_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '201': "Experiment",
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '409': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        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 experiments_create_without_preload_content(
+        self,
+        experiments_create_request: Annotated[ExperimentsCreateRequest, Field(description="Body containing experiment creation parameters")],
+        _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:
+        """Create a new experiment with run data
+
+
+        :param experiments_create_request: Body containing experiment creation parameters (required)
+        :type experiments_create_request: ExperimentsCreateRequest
+        :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._experiments_create_serialize(
+            experiments_create_request=experiments_create_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '201': "Experiment",
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '409': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _experiments_create_serialize(
+        self,
+        experiments_create_request,
+        _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 experiments_create_request is not None:
+            _body_params = experiments_create_request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/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'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v2/experiments',
+            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 experiments_delete(
         self,
@@ -55,8 +347,428 @@ class ExperimentsApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Delete an experiment by ID
+    ) -> None:
+        """Delete an experiment by ID
+
+
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_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._experiments_delete_serialize(
+            experiment_id=experiment_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '404': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        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 experiments_delete_with_http_info(
+        self,
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
+        _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[None]:
+        """Delete an experiment by ID
+
+
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_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._experiments_delete_serialize(
+            experiment_id=experiment_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '404': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        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 experiments_delete_without_preload_content(
+        self,
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
+        _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:
+        """Delete an experiment by ID
+
+
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_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._experiments_delete_serialize(
+            experiment_id=experiment_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '404': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _experiments_delete_serialize(
+        self,
+        experiment_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 experiment_id is not None:
+            _path_params['experimentId'] = experiment_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(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='DELETE',
+            resource_path='/v2/experiments/{experimentId}',
+            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 experiments_get(
+        self,
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
+        _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,
+    ) -> Experiment:
+        """Get experiment by ID
+
+
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_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._experiments_get_serialize(
+            experiment_id=experiment_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Experiment",
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '404': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        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 experiments_get_with_http_info(
+        self,
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
+        _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[Experiment]:
+        """Get experiment by ID
+
+
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_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._experiments_get_serialize(
+            experiment_id=experiment_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Experiment",
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '404': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        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 experiments_get_without_preload_content(
+        self,
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
+        _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:
+        """Get experiment by ID
 
 
         :param experiment_id: The unique identifier of the experiment (required)
@@ -83,7 +795,7 @@ class ExperimentsApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._experiments_delete_serialize(
+        _param = self._experiments_get_serialize(
             experiment_id=experiment_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -92,7 +804,7 @@ class ExperimentsApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "Experiment",
             '400': "Error",
             '401': "Error",
             '403': "Error",
@@ -104,6 +816,141 @@ class ExperimentsApi:
             *_param,
             _request_timeout=_request_timeout
         )
+        return response_data.response
+
+
+    def _experiments_get_serialize(
+        self,
+        experiment_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 experiment_id is not None:
+            _path_params['experimentId'] = experiment_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(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v2/experiments/{experimentId}',
+            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 experiments_list(
+        self,
+        dataset_id: Annotated[Optional[StrictStr], Field(description="Filter experiments to a particular dataset ID")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to return")] = 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,
+    ) -> ExperimentsList200Response:
+        """List experiments
+
+
+        :param dataset_id: Filter experiments to a particular dataset ID
+        :type dataset_id: str
+        :param limit: Maximum number of items to return
+        :type limit: int
+        :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._experiments_list_serialize(
+            dataset_id=dataset_id,
+            limit=limit,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ExperimentsList200Response",
+            '400': "Error",
+            '401': "Error",
+            '403': "Error",
+            '422': "Error",
+            '429': "Error",
+        }
+        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,
@@ -112,9 +959,10 @@ class ExperimentsApi:
 
 
     @validate_call
-    def experiments_delete_with_http_info(
+    def experiments_list_with_http_info(
         self,
-        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
+        dataset_id: Annotated[Optional[StrictStr], Field(description="Filter experiments to a particular dataset ID")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to return")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -127,12 +975,14 @@ class ExperimentsApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Delete an experiment by ID
+    ) -> ApiResponse[ExperimentsList200Response]:
+        """List experiments
 
 
-        :param experiment_id: The unique identifier of the experiment (required)
-        :type experiment_id: str
+        :param dataset_id: Filter experiments to a particular dataset ID
+        :type dataset_id: str
+        :param limit: Maximum number of items to return
+        :type limit: int
         :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
@@ -155,8 +1005,9 @@ class ExperimentsApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._experiments_delete_serialize(
-            experiment_id=experiment_id,
+        _param = self._experiments_list_serialize(
+            dataset_id=dataset_id,
+            limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -164,11 +1015,10 @@ class ExperimentsApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "ExperimentsList200Response",
             '400': "Error",
             '401': "Error",
             '403': "Error",
-            '404': "Error",
             '422': "Error",
             '429': "Error",
         }
@@ -184,9 +1034,10 @@ class ExperimentsApi:
 
 
     @validate_call
-    def experiments_delete_without_preload_content(
+    def experiments_list_without_preload_content(
         self,
-        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
+        dataset_id: Annotated[Optional[StrictStr], Field(description="Filter experiments to a particular dataset ID")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to return")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -200,11 +1051,13 @@ class ExperimentsApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Delete an experiment by ID
+        """List experiments
 
 
-        :param experiment_id: The unique identifier of the experiment (required)
-        :type experiment_id: str
+        :param dataset_id: Filter experiments to a particular dataset ID
+        :type dataset_id: str
+        :param limit: Maximum number of items to return
+        :type limit: int
         :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 +1080,9 @@ class ExperimentsApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._experiments_delete_serialize(
-            experiment_id=experiment_id,
+        _param = self._experiments_list_serialize(
+            dataset_id=dataset_id,
+            limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -236,11 +1090,10 @@ class ExperimentsApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "ExperimentsList200Response",
             '400': "Error",
             '401': "Error",
             '403': "Error",
-            '404': "Error",
             '422': "Error",
             '429': "Error",
         }
@@ -251,9 +1104,10 @@ class ExperimentsApi:
         return response_data.response
 
 
-    def _experiments_delete_serialize(
+    def _experiments_list_serialize(
         self,
-        experiment_id,
+        dataset_id,
+        limit,
         _request_auth,
         _content_type,
         _headers,
@@ -275,9 +1129,15 @@ class ExperimentsApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if experiment_id is not None:
-            _path_params['experimentId'] = experiment_id
         # process the query parameters
+        if dataset_id is not None:
+            
+            _query_params.append(('datasetId', dataset_id))
+            
+        if limit is not None:
+            
+            _query_params.append(('limit', limit))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -298,8 +1158,8 @@ class ExperimentsApi:
         ]
 
         return self.api_client.param_serialize(
-            method='DELETE',
-            resource_path='/api/v1/experiments/{experimentId}',
+            method='GET',
+            resource_path='/v2/experiments',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -316,9 +1176,9 @@ class ExperimentsApi:
 
 
     @validate_call
-    def experiments_list(
+    def experiments_runs_list(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The unique identifier of the dataset")],
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
         limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to return")] = None,
         _request_timeout: Union[
             None,
@@ -332,12 +1192,12 @@ class ExperimentsApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ExperimentsList200Response:
-        """List experiments for a given dataset
+    ) -> ExperimentsRunsList200Response:
+        """List experiment runs for a specific experiment
 
 
-        :param dataset_id: The unique identifier of the dataset (required)
-        :type dataset_id: str
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_id: str
         :param limit: Maximum number of items to return
         :type limit: int
         :param _request_timeout: timeout setting for this request. If one
@@ -362,8 +1222,8 @@ class ExperimentsApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._experiments_list_serialize(
-            dataset_id=dataset_id,
+        _param = self._experiments_runs_list_serialize(
+            experiment_id=experiment_id,
             limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -372,10 +1232,11 @@ class ExperimentsApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ExperimentsList200Response",
+            '200': "ExperimentsRunsList200Response",
             '400': "Error",
             '401': "Error",
             '403': "Error",
+            '404': "Error",
             '422': "Error",
             '429': "Error",
         }
@@ -391,9 +1252,9 @@ class ExperimentsApi:
 
 
     @validate_call
-    def experiments_list_with_http_info(
+    def experiments_runs_list_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The unique identifier of the dataset")],
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
         limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to return")] = None,
         _request_timeout: Union[
             None,
@@ -407,12 +1268,12 @@ class ExperimentsApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ExperimentsList200Response]:
-        """List experiments for a given dataset
+    ) -> ApiResponse[ExperimentsRunsList200Response]:
+        """List experiment runs for a specific experiment
 
 
-        :param dataset_id: The unique identifier of the dataset (required)
-        :type dataset_id: str
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_id: str
         :param limit: Maximum number of items to return
         :type limit: int
         :param _request_timeout: timeout setting for this request. If one
@@ -437,8 +1298,8 @@ class ExperimentsApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._experiments_list_serialize(
-            dataset_id=dataset_id,
+        _param = self._experiments_runs_list_serialize(
+            experiment_id=experiment_id,
             limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -447,10 +1308,11 @@ class ExperimentsApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ExperimentsList200Response",
+            '200': "ExperimentsRunsList200Response",
             '400': "Error",
             '401': "Error",
             '403': "Error",
+            '404': "Error",
             '422': "Error",
             '429': "Error",
         }
@@ -466,9 +1328,9 @@ class ExperimentsApi:
 
 
     @validate_call
-    def experiments_list_without_preload_content(
+    def experiments_runs_list_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The unique identifier of the dataset")],
+        experiment_id: Annotated[StrictStr, Field(description="The unique identifier of the experiment")],
         limit: Annotated[Optional[StrictInt], Field(description="Maximum number of items to return")] = None,
         _request_timeout: Union[
             None,
@@ -483,11 +1345,11 @@ class ExperimentsApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """List experiments for a given dataset
+        """List experiment runs for a specific experiment
 
 
-        :param dataset_id: The unique identifier of the dataset (required)
-        :type dataset_id: str
+        :param experiment_id: The unique identifier of the experiment (required)
+        :type experiment_id: str
         :param limit: Maximum number of items to return
         :type limit: int
         :param _request_timeout: timeout setting for this request. If one
@@ -512,8 +1374,8 @@ class ExperimentsApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._experiments_list_serialize(
-            dataset_id=dataset_id,
+        _param = self._experiments_runs_list_serialize(
+            experiment_id=experiment_id,
             limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -522,10 +1384,11 @@ class ExperimentsApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ExperimentsList200Response",
+            '200': "ExperimentsRunsList200Response",
             '400': "Error",
             '401': "Error",
             '403': "Error",
+            '404': "Error",
             '422': "Error",
             '429': "Error",
         }
@@ -536,9 +1399,9 @@ class ExperimentsApi:
         return response_data.response
 
 
-    def _experiments_list_serialize(
+    def _experiments_runs_list_serialize(
         self,
-        dataset_id,
+        experiment_id,
         limit,
         _request_auth,
         _content_type,
@@ -561,8 +1424,8 @@ class ExperimentsApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if dataset_id is not None:
-            _path_params['datasetId'] = dataset_id
+        if experiment_id is not None:
+            _path_params['experimentId'] = experiment_id
         # process the query parameters
         if limit is not None:
             
@@ -589,7 +1452,7 @@ class ExperimentsApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/api/v1/datasets/{datasetId}/experiments',
+            resource_path='/v2/experiments/{experimentId}/runs',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,