From 91d4e50179fe67e307d2ca013e7208a0ab7c07ac Mon Sep 17 00:00:00 2001 From: "Yuan (Bob) Gong" Date: Tue, 23 Jun 2020 21:21:45 +0800 Subject: [PATCH] doc(sdk/client): fix kfp-server-api py client's docstring format (#4047) * Pull templates from upstream 4.3.1 * update templates according to OpenAPITools/openapi-generator/pull/6391 * regenerate python client --- .../api/experiment_service_api.py | 162 ++++++++--- .../kfp_server_api/api/job_service_api.py | 162 ++++++++--- .../api/pipeline_service_api.py | 268 ++++++++++++----- .../api/pipeline_upload_service_api.py | 68 +++-- .../kfp_server_api/api/run_service_api.py | 268 ++++++++++++----- .../models/api_cron_schedule.py | 6 +- .../kfp_server_api/models/api_experiment.py | 12 +- .../models/api_get_template_response.py | 2 +- .../kfp_server_api/models/api_job.py | 30 +- .../models/api_list_experiments_response.py | 6 +- .../models/api_list_jobs_response.py | 6 +- .../api_list_pipeline_versions_response.py | 6 +- .../models/api_list_pipelines_response.py | 6 +- .../models/api_list_runs_response.py | 6 +- .../kfp_server_api/models/api_parameter.py | 4 +- .../models/api_periodic_schedule.py | 6 +- .../kfp_server_api/models/api_pipeline.py | 16 +- .../models/api_pipeline_runtime.py | 4 +- .../models/api_pipeline_spec.py | 10 +- .../models/api_pipeline_version.py | 14 +- .../models/api_read_artifact_response.py | 2 +- .../models/api_report_run_metrics_request.py | 4 +- .../models/api_report_run_metrics_response.py | 2 +- .../kfp_server_api/models/api_resource_key.py | 4 +- .../models/api_resource_reference.py | 6 +- .../kfp_server_api/models/api_run.py | 26 +- .../kfp_server_api/models/api_run_detail.py | 4 +- .../kfp_server_api/models/api_run_metric.py | 8 +- .../kfp_server_api/models/api_status.py | 6 +- .../kfp_server_api/models/api_trigger.py | 4 +- .../kfp_server_api/models/api_url.py | 2 +- .../kfp_server_api/models/protobuf_any.py | 4 +- ...trics_response_report_run_metric_result.py | 8 +- .../python_http_client_template/api.mustache | 270 ++++++++++++++++++ .../model.mustache | 246 ++++++++++++++++ 35 files changed, 1287 insertions(+), 371 deletions(-) create mode 100644 backend/api/python_http_client_template/api.mustache create mode 100644 backend/api/python_http_client_template/model.mustache diff --git a/backend/api/python_http_client/kfp_server_api/api/experiment_service_api.py b/backend/api/python_http_client/kfp_server_api/api/experiment_service_api.py index 58fa86d5d1c..42e9b227eb0 100644 --- a/backend/api/python_http_client/kfp_server_api/api/experiment_service_api.py +++ b/backend/api/python_http_client/kfp_server_api/api/experiment_service_api.py @@ -55,11 +55,14 @@ def archive_experiment(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.archive_experiment(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be archived. (required) + :param id: The ID of the experiment to be archived. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -67,9 +70,10 @@ def archive_experiment(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.archive_experiment_with_http_info(id, **kwargs) # noqa: E501 @@ -79,23 +83,29 @@ def archive_experiment_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.archive_experiment_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be archived. (required) + :param id: The ID of the experiment to be archived. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -167,11 +177,14 @@ def create_experiment(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_experiment(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiExperiment body: The experiment to be created. (required) + :param body: The experiment to be created. (required) + :type body: ApiExperiment + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -179,9 +192,10 @@ def create_experiment(self, body, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiExperiment + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiExperiment """ kwargs['_return_http_data_only'] = True return self.create_experiment_with_http_info(body, **kwargs) # noqa: E501 @@ -191,23 +205,29 @@ def create_experiment_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_experiment_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiExperiment body: The experiment to be created. (required) + :param body: The experiment to be created. (required) + :type body: ApiExperiment + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiExperiment, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiExperiment, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -283,11 +303,14 @@ def delete_experiment(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_experiment(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be deleted. (required) + :param id: The ID of the experiment to be deleted. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -295,9 +318,10 @@ def delete_experiment(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.delete_experiment_with_http_info(id, **kwargs) # noqa: E501 @@ -307,23 +331,29 @@ def delete_experiment_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_experiment_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be deleted. (required) + :param id: The ID of the experiment to be deleted. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -395,11 +425,14 @@ def get_experiment(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_experiment(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be retrieved. (required) + :param id: The ID of the experiment to be retrieved. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -407,9 +440,10 @@ def get_experiment(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiExperiment + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiExperiment """ kwargs['_return_http_data_only'] = True return self.get_experiment_with_http_info(id, **kwargs) # noqa: E501 @@ -419,23 +453,29 @@ def get_experiment_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_experiment_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be retrieved. (required) + :param id: The ID of the experiment to be retrieved. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiExperiment, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiExperiment, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -507,16 +547,24 @@ def list_experiment(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_experiment(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListExperiment call or can be omitted when fetching the first page. - :param int page_size: The number of experiments to be listed per page. If there are more experiments than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). - :param str resource_reference_key_type: The type of the resource that referred to. - :param str resource_reference_key_id: The ID of the resource that referred to. + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListExperiment call or can be omitted when fetching the first page. + :type page_token: str + :param page_size: The number of experiments to be listed per page. If there are more experiments than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. + :type sort_by: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param resource_reference_key_type: The type of the resource that referred to. + :type resource_reference_key_type: str + :param resource_reference_key_id: The ID of the resource that referred to. + :type resource_reference_key_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -524,9 +572,10 @@ def list_experiment(self, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiListExperimentsResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiListExperimentsResponse """ kwargs['_return_http_data_only'] = True return self.list_experiment_with_http_info(**kwargs) # noqa: E501 @@ -536,28 +585,39 @@ def list_experiment_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_experiment_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListExperiment call or can be omitted when fetching the first page. - :param int page_size: The number of experiments to be listed per page. If there are more experiments than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). - :param str resource_reference_key_type: The type of the resource that referred to. - :param str resource_reference_key_id: The ID of the resource that referred to. + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListExperiment call or can be omitted when fetching the first page. + :type page_token: str + :param page_size: The number of experiments to be listed per page. If there are more experiments than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. + :type sort_by: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param resource_reference_key_type: The type of the resource that referred to. + :type resource_reference_key_type: str + :param resource_reference_key_id: The ID of the resource that referred to. + :type resource_reference_key_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiListExperimentsResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiListExperimentsResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -640,11 +700,14 @@ def unarchive_experiment(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.unarchive_experiment(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be restored. (required) + :param id: The ID of the experiment to be restored. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -652,9 +715,10 @@ def unarchive_experiment(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.unarchive_experiment_with_http_info(id, **kwargs) # noqa: E501 @@ -664,23 +728,29 @@ def unarchive_experiment_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.unarchive_experiment_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the experiment to be restored. (required) + :param id: The ID of the experiment to be restored. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/backend/api/python_http_client/kfp_server_api/api/job_service_api.py b/backend/api/python_http_client/kfp_server_api/api/job_service_api.py index 13d77ad6b88..94d8979acdf 100644 --- a/backend/api/python_http_client/kfp_server_api/api/job_service_api.py +++ b/backend/api/python_http_client/kfp_server_api/api/job_service_api.py @@ -55,11 +55,14 @@ def create_job(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_job(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiJob body: The job to be created (required) + :param body: The job to be created (required) + :type body: ApiJob + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -67,9 +70,10 @@ def create_job(self, body, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiJob + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiJob """ kwargs['_return_http_data_only'] = True return self.create_job_with_http_info(body, **kwargs) # noqa: E501 @@ -79,23 +83,29 @@ def create_job_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_job_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiJob body: The job to be created (required) + :param body: The job to be created (required) + :type body: ApiJob + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiJob, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiJob, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -171,11 +181,14 @@ def delete_job(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_job(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be deleted (required) + :param id: The ID of the job to be deleted (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -183,9 +196,10 @@ def delete_job(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.delete_job_with_http_info(id, **kwargs) # noqa: E501 @@ -195,23 +209,29 @@ def delete_job_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_job_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be deleted (required) + :param id: The ID of the job to be deleted (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -283,11 +303,14 @@ def disable_job(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.disable_job(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be disabled (required) + :param id: The ID of the job to be disabled (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -295,9 +318,10 @@ def disable_job(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.disable_job_with_http_info(id, **kwargs) # noqa: E501 @@ -307,23 +331,29 @@ def disable_job_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.disable_job_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be disabled (required) + :param id: The ID of the job to be disabled (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -395,11 +425,14 @@ def enable_job(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.enable_job(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be enabled (required) + :param id: The ID of the job to be enabled (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -407,9 +440,10 @@ def enable_job(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.enable_job_with_http_info(id, **kwargs) # noqa: E501 @@ -419,23 +453,29 @@ def enable_job_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.enable_job_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be enabled (required) + :param id: The ID of the job to be enabled (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -507,11 +547,14 @@ def get_job(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_job(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be retrieved (required) + :param id: The ID of the job to be retrieved (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -519,9 +562,10 @@ def get_job(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiJob + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiJob """ kwargs['_return_http_data_only'] = True return self.get_job_with_http_info(id, **kwargs) # noqa: E501 @@ -531,23 +575,29 @@ def get_job_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_job_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the job to be retrieved (required) + :param id: The ID of the job to be retrieved (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiJob, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiJob, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -619,16 +669,24 @@ def list_jobs(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_jobs(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListJobs call or can be omitted when fetching the first page. - :param int page_size: The number of jobs to be listed per page. If there are more jobs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\". Ascending by default. - :param str resource_reference_key_type: The type of the resource that referred to. - :param str resource_reference_key_id: The ID of the resource that referred to. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListJobs call or can be omitted when fetching the first page. + :type page_token: str + :param page_size: The number of jobs to be listed per page. If there are more jobs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\". Ascending by default. + :type sort_by: str + :param resource_reference_key_type: The type of the resource that referred to. + :type resource_reference_key_type: str + :param resource_reference_key_id: The ID of the resource that referred to. + :type resource_reference_key_id: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -636,9 +694,10 @@ def list_jobs(self, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiListJobsResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiListJobsResponse """ kwargs['_return_http_data_only'] = True return self.list_jobs_with_http_info(**kwargs) # noqa: E501 @@ -648,28 +707,39 @@ def list_jobs_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_jobs_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListJobs call or can be omitted when fetching the first page. - :param int page_size: The number of jobs to be listed per page. If there are more jobs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\". Ascending by default. - :param str resource_reference_key_type: The type of the resource that referred to. - :param str resource_reference_key_id: The ID of the resource that referred to. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListJobs call or can be omitted when fetching the first page. + :type page_token: str + :param page_size: The number of jobs to be listed per page. If there are more jobs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\". Ascending by default. + :type sort_by: str + :param resource_reference_key_type: The type of the resource that referred to. + :type resource_reference_key_type: str + :param resource_reference_key_id: The ID of the resource that referred to. + :type resource_reference_key_id: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiListJobsResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiListJobsResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/backend/api/python_http_client/kfp_server_api/api/pipeline_service_api.py b/backend/api/python_http_client/kfp_server_api/api/pipeline_service_api.py index 1614e41f3d3..d0d5bc0a031 100644 --- a/backend/api/python_http_client/kfp_server_api/api/pipeline_service_api.py +++ b/backend/api/python_http_client/kfp_server_api/api/pipeline_service_api.py @@ -55,11 +55,14 @@ def create_pipeline(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_pipeline(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiPipeline body: (required) + :param body: (required) + :type body: ApiPipeline + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -67,9 +70,10 @@ def create_pipeline(self, body, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiPipeline + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiPipeline """ kwargs['_return_http_data_only'] = True return self.create_pipeline_with_http_info(body, **kwargs) # noqa: E501 @@ -79,23 +83,29 @@ def create_pipeline_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_pipeline_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiPipeline body: (required) + :param body: (required) + :type body: ApiPipeline + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiPipeline, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiPipeline, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -171,11 +181,14 @@ def create_pipeline_version(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_pipeline_version(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiPipelineVersion body: ResourceReference inside PipelineVersion specifies the pipeline that this version belongs to. (required) + :param body: ResourceReference inside PipelineVersion specifies the pipeline that this version belongs to. (required) + :type body: ApiPipelineVersion + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -183,9 +196,10 @@ def create_pipeline_version(self, body, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiPipelineVersion + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiPipelineVersion """ kwargs['_return_http_data_only'] = True return self.create_pipeline_version_with_http_info(body, **kwargs) # noqa: E501 @@ -195,23 +209,29 @@ def create_pipeline_version_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_pipeline_version_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiPipelineVersion body: ResourceReference inside PipelineVersion specifies the pipeline that this version belongs to. (required) + :param body: ResourceReference inside PipelineVersion specifies the pipeline that this version belongs to. (required) + :type body: ApiPipelineVersion + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiPipelineVersion, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiPipelineVersion, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -287,11 +307,14 @@ def delete_pipeline(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_pipeline(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the pipeline to be deleted. (required) + :param id: The ID of the pipeline to be deleted. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -299,9 +322,10 @@ def delete_pipeline(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.delete_pipeline_with_http_info(id, **kwargs) # noqa: E501 @@ -311,23 +335,29 @@ def delete_pipeline_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_pipeline_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the pipeline to be deleted. (required) + :param id: The ID of the pipeline to be deleted. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -399,11 +429,14 @@ def delete_pipeline_version(self, version_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_pipeline_version(version_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str version_id: The ID of the pipeline version to be deleted. (required) + :param version_id: The ID of the pipeline version to be deleted. (required) + :type version_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -411,9 +444,10 @@ def delete_pipeline_version(self, version_id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.delete_pipeline_version_with_http_info(version_id, **kwargs) # noqa: E501 @@ -423,23 +457,29 @@ def delete_pipeline_version_with_http_info(self, version_id, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_pipeline_version_with_http_info(version_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str version_id: The ID of the pipeline version to be deleted. (required) + :param version_id: The ID of the pipeline version to be deleted. (required) + :type version_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -511,11 +551,14 @@ def get_pipeline(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pipeline(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the pipeline to be retrieved. (required) + :param id: The ID of the pipeline to be retrieved. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -523,9 +566,10 @@ def get_pipeline(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiPipeline + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiPipeline """ kwargs['_return_http_data_only'] = True return self.get_pipeline_with_http_info(id, **kwargs) # noqa: E501 @@ -535,23 +579,29 @@ def get_pipeline_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pipeline_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the pipeline to be retrieved. (required) + :param id: The ID of the pipeline to be retrieved. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiPipeline, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiPipeline, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -623,11 +673,14 @@ def get_pipeline_version(self, version_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pipeline_version(version_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str version_id: The ID of the pipeline version to be retrieved. (required) + :param version_id: The ID of the pipeline version to be retrieved. (required) + :type version_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -635,9 +688,10 @@ def get_pipeline_version(self, version_id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiPipelineVersion + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiPipelineVersion """ kwargs['_return_http_data_only'] = True return self.get_pipeline_version_with_http_info(version_id, **kwargs) # noqa: E501 @@ -647,23 +701,29 @@ def get_pipeline_version_with_http_info(self, version_id, **kwargs): # noqa: E5 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pipeline_version_with_http_info(version_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str version_id: The ID of the pipeline version to be retrieved. (required) + :param version_id: The ID of the pipeline version to be retrieved. (required) + :type version_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiPipelineVersion, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiPipelineVersion, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -735,11 +795,14 @@ def get_pipeline_version_template(self, version_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pipeline_version_template(version_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str version_id: The ID of the pipeline version whose template is to be retrieved. (required) + :param version_id: The ID of the pipeline version whose template is to be retrieved. (required) + :type version_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -747,9 +810,10 @@ def get_pipeline_version_template(self, version_id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiGetTemplateResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiGetTemplateResponse """ kwargs['_return_http_data_only'] = True return self.get_pipeline_version_template_with_http_info(version_id, **kwargs) # noqa: E501 @@ -759,23 +823,29 @@ def get_pipeline_version_template_with_http_info(self, version_id, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pipeline_version_template_with_http_info(version_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str version_id: The ID of the pipeline version whose template is to be retrieved. (required) + :param version_id: The ID of the pipeline version whose template is to be retrieved. (required) + :type version_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiGetTemplateResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiGetTemplateResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -847,11 +917,14 @@ def get_template(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_template(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the pipeline whose template is to be retrieved. (required) + :param id: The ID of the pipeline whose template is to be retrieved. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -859,9 +932,10 @@ def get_template(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiGetTemplateResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiGetTemplateResponse """ kwargs['_return_http_data_only'] = True return self.get_template_with_http_info(id, **kwargs) # noqa: E501 @@ -871,23 +945,29 @@ def get_template_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_template_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the pipeline whose template is to be retrieved. (required) + :param id: The ID of the pipeline whose template is to be retrieved. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiGetTemplateResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiGetTemplateResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -959,16 +1039,24 @@ def list_pipeline_versions(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_pipeline_versions(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str resource_key_type: The type of the resource that referred to. - :param str resource_key_id: The ID of the resource that referred to. - :param int page_size: The number of pipeline versions to be listed per page. If there are more pipeline versions than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelineVersions call or can be omitted when fetching the first page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. - :param str filter: A base-64 encoded, JSON-serialized Filter protocol buffer (see filter.proto). + :param resource_key_type: The type of the resource that referred to. + :type resource_key_type: str + :param resource_key_id: The ID of the resource that referred to. + :type resource_key_id: str + :param page_size: The number of pipeline versions to be listed per page. If there are more pipeline versions than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelineVersions call or can be omitted when fetching the first page. + :type page_token: str + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. + :type sort_by: str + :param filter: A base-64 encoded, JSON-serialized Filter protocol buffer (see filter.proto). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -976,9 +1064,10 @@ def list_pipeline_versions(self, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiListPipelineVersionsResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiListPipelineVersionsResponse """ kwargs['_return_http_data_only'] = True return self.list_pipeline_versions_with_http_info(**kwargs) # noqa: E501 @@ -988,28 +1077,39 @@ def list_pipeline_versions_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_pipeline_versions_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str resource_key_type: The type of the resource that referred to. - :param str resource_key_id: The ID of the resource that referred to. - :param int page_size: The number of pipeline versions to be listed per page. If there are more pipeline versions than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelineVersions call or can be omitted when fetching the first page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. - :param str filter: A base-64 encoded, JSON-serialized Filter protocol buffer (see filter.proto). + :param resource_key_type: The type of the resource that referred to. + :type resource_key_type: str + :param resource_key_id: The ID of the resource that referred to. + :type resource_key_id: str + :param page_size: The number of pipeline versions to be listed per page. If there are more pipeline versions than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelineVersions call or can be omitted when fetching the first page. + :type page_token: str + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. + :type sort_by: str + :param filter: A base-64 encoded, JSON-serialized Filter protocol buffer (see filter.proto). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiListPipelineVersionsResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiListPipelineVersionsResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -1092,14 +1192,20 @@ def list_pipelines(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_pipelines(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelines call. - :param int page_size: The number of pipelines to be listed per page. If there are more pipelines than this number, the response message will contain a valid value in the nextPageToken field. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelines call. + :type page_token: str + :param page_size: The number of pipelines to be listed per page. If there are more pipelines than this number, the response message will contain a valid value in the nextPageToken field. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. + :type sort_by: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -1107,9 +1213,10 @@ def list_pipelines(self, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiListPipelinesResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiListPipelinesResponse """ kwargs['_return_http_data_only'] = True return self.list_pipelines_with_http_info(**kwargs) # noqa: E501 @@ -1119,26 +1226,35 @@ def list_pipelines_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_pipelines_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelines call. - :param int page_size: The number of pipelines to be listed per page. If there are more pipelines than this number, the response message will contain a valid value in the nextPageToken field. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListPipelines call. + :type page_token: str + :param page_size: The number of pipelines to be listed per page. If there are more pipelines than this number, the response message will contain a valid value in the nextPageToken field. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" Ascending by default. + :type sort_by: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiListPipelinesResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiListPipelinesResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/backend/api/python_http_client/kfp_server_api/api/pipeline_upload_service_api.py b/backend/api/python_http_client/kfp_server_api/api/pipeline_upload_service_api.py index 96ae9299c3d..78636e61043 100644 --- a/backend/api/python_http_client/kfp_server_api/api/pipeline_upload_service_api.py +++ b/backend/api/python_http_client/kfp_server_api/api/pipeline_upload_service_api.py @@ -55,13 +55,18 @@ def upload_pipeline(self, uploadfile, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_pipeline(uploadfile, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param file uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) - :param str name: - :param str description: + :param uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) + :type uploadfile: file + :param name: + :type name: str + :param description: + :type description: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -69,9 +74,10 @@ def upload_pipeline(self, uploadfile, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiPipeline + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiPipeline """ kwargs['_return_http_data_only'] = True return self.upload_pipeline_with_http_info(uploadfile, **kwargs) # noqa: E501 @@ -81,25 +87,33 @@ def upload_pipeline_with_http_info(self, uploadfile, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_pipeline_with_http_info(uploadfile, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param file uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) - :param str name: - :param str description: + :param uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) + :type uploadfile: file + :param name: + :type name: str + :param description: + :type description: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiPipeline, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiPipeline, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -181,13 +195,18 @@ def upload_pipeline_version(self, uploadfile, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_pipeline_version(uploadfile, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param file uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) - :param str name: - :param str pipelineid: + :param uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) + :type uploadfile: file + :param name: + :type name: str + :param pipelineid: + :type pipelineid: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -195,9 +214,10 @@ def upload_pipeline_version(self, uploadfile, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiPipelineVersion + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiPipelineVersion """ kwargs['_return_http_data_only'] = True return self.upload_pipeline_version_with_http_info(uploadfile, **kwargs) # noqa: E501 @@ -207,25 +227,33 @@ def upload_pipeline_version_with_http_info(self, uploadfile, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_pipeline_version_with_http_info(uploadfile, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param file uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) - :param str name: - :param str pipelineid: + :param uploadfile: The pipeline to upload. Maximum size of 32MB is supported. (required) + :type uploadfile: file + :param name: + :type name: str + :param pipelineid: + :type pipelineid: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiPipelineVersion, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiPipelineVersion, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/backend/api/python_http_client/kfp_server_api/api/run_service_api.py b/backend/api/python_http_client/kfp_server_api/api/run_service_api.py index d412865aee9..052997f772e 100644 --- a/backend/api/python_http_client/kfp_server_api/api/run_service_api.py +++ b/backend/api/python_http_client/kfp_server_api/api/run_service_api.py @@ -55,11 +55,14 @@ def archive_run(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.archive_run(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the run to be archived. (required) + :param id: The ID of the run to be archived. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -67,9 +70,10 @@ def archive_run(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.archive_run_with_http_info(id, **kwargs) # noqa: E501 @@ -79,23 +83,29 @@ def archive_run_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.archive_run_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the run to be archived. (required) + :param id: The ID of the run to be archived. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -167,11 +177,14 @@ def create_run(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_run(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiRun body: (required) + :param body: (required) + :type body: ApiRun + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -179,9 +192,10 @@ def create_run(self, body, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiRunDetail + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiRunDetail """ kwargs['_return_http_data_only'] = True return self.create_run_with_http_info(body, **kwargs) # noqa: E501 @@ -191,23 +205,29 @@ def create_run_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_run_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param ApiRun body: (required) + :param body: (required) + :type body: ApiRun + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiRunDetail, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiRunDetail, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -283,11 +303,14 @@ def delete_run(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_run(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the run to be deleted. (required) + :param id: The ID of the run to be deleted. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -295,9 +318,10 @@ def delete_run(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.delete_run_with_http_info(id, **kwargs) # noqa: E501 @@ -307,23 +331,29 @@ def delete_run_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_run_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the run to be deleted. (required) + :param id: The ID of the run to be deleted. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -395,11 +425,14 @@ def get_run(self, run_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_run(run_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run to be retrieved. (required) + :param run_id: The ID of the run to be retrieved. (required) + :type run_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -407,9 +440,10 @@ def get_run(self, run_id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiRunDetail + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiRunDetail """ kwargs['_return_http_data_only'] = True return self.get_run_with_http_info(run_id, **kwargs) # noqa: E501 @@ -419,23 +453,29 @@ def get_run_with_http_info(self, run_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_run_with_http_info(run_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run to be retrieved. (required) + :param run_id: The ID of the run to be retrieved. (required) + :type run_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiRunDetail, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiRunDetail, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -507,16 +547,24 @@ def list_runs(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_runs(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListRuns call or can be omitted when fetching the first page. - :param int page_size: The number of runs to be listed per page. If there are more runs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" (Example, \"name asc\" or \"id desc\"). Ascending by default. - :param str resource_reference_key_type: The type of the resource that referred to. - :param str resource_reference_key_id: The ID of the resource that referred to. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListRuns call or can be omitted when fetching the first page. + :type page_token: str + :param page_size: The number of runs to be listed per page. If there are more runs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" (Example, \"name asc\" or \"id desc\"). Ascending by default. + :type sort_by: str + :param resource_reference_key_type: The type of the resource that referred to. + :type resource_reference_key_type: str + :param resource_reference_key_id: The ID of the resource that referred to. + :type resource_reference_key_id: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -524,9 +572,10 @@ def list_runs(self, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiListRunsResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiListRunsResponse """ kwargs['_return_http_data_only'] = True return self.list_runs_with_http_info(**kwargs) # noqa: E501 @@ -536,28 +585,39 @@ def list_runs_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.list_runs_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListRuns call or can be omitted when fetching the first page. - :param int page_size: The number of runs to be listed per page. If there are more runs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. - :param str sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" (Example, \"name asc\" or \"id desc\"). Ascending by default. - :param str resource_reference_key_type: The type of the resource that referred to. - :param str resource_reference_key_id: The ID of the resource that referred to. - :param str filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :param page_token: A page token to request the next page of results. The token is acquried from the nextPageToken field of the response from the previous ListRuns call or can be omitted when fetching the first page. + :type page_token: str + :param page_size: The number of runs to be listed per page. If there are more runs than this number, the response message will contain a nextPageToken field you can use to fetch the next page. + :type page_size: int + :param sort_by: Can be format of \"field_name\", \"field_name asc\" or \"field_name desc\" (Example, \"name asc\" or \"id desc\"). Ascending by default. + :type sort_by: str + :param resource_reference_key_type: The type of the resource that referred to. + :type resource_reference_key_type: str + :param resource_reference_key_id: The ID of the resource that referred to. + :type resource_reference_key_id: str + :param filter: A url-encoded, JSON-serialized Filter protocol buffer (see [filter.proto](https://github.com/kubeflow/pipelines/ blob/master/backend/api/filter.proto)). + :type filter: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiListRunsResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiListRunsResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -640,13 +700,18 @@ def read_artifact(self, run_id, node_id, artifact_name, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_artifact(run_id, node_id, artifact_name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run. (required) - :param str node_id: The ID of the running node. (required) - :param str artifact_name: The name of the artifact. (required) + :param run_id: The ID of the run. (required) + :type run_id: str + :param node_id: The ID of the running node. (required) + :type node_id: str + :param artifact_name: The name of the artifact. (required) + :type artifact_name: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -654,9 +719,10 @@ def read_artifact(self, run_id, node_id, artifact_name, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiReadArtifactResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiReadArtifactResponse """ kwargs['_return_http_data_only'] = True return self.read_artifact_with_http_info(run_id, node_id, artifact_name, **kwargs) # noqa: E501 @@ -666,25 +732,33 @@ def read_artifact_with_http_info(self, run_id, node_id, artifact_name, **kwargs) This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.read_artifact_with_http_info(run_id, node_id, artifact_name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run. (required) - :param str node_id: The ID of the running node. (required) - :param str artifact_name: The name of the artifact. (required) + :param run_id: The ID of the run. (required) + :type run_id: str + :param node_id: The ID of the running node. (required) + :type node_id: str + :param artifact_name: The name of the artifact. (required) + :type artifact_name: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiReadArtifactResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiReadArtifactResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -770,12 +844,16 @@ def report_run_metrics(self, run_id, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.report_run_metrics(run_id, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: Required. The parent run ID of the metric. (required) - :param ApiReportRunMetricsRequest body: (required) + :param run_id: Required. The parent run ID of the metric. (required) + :type run_id: str + :param body: (required) + :type body: ApiReportRunMetricsRequest + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -783,9 +861,10 @@ def report_run_metrics(self, run_id, body, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiReportRunMetricsResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiReportRunMetricsResponse """ kwargs['_return_http_data_only'] = True return self.report_run_metrics_with_http_info(run_id, body, **kwargs) # noqa: E501 @@ -795,24 +874,31 @@ def report_run_metrics_with_http_info(self, run_id, body, **kwargs): # noqa: E5 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.report_run_metrics_with_http_info(run_id, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: Required. The parent run ID of the metric. (required) - :param ApiReportRunMetricsRequest body: (required) + :param run_id: Required. The parent run ID of the metric. (required) + :type run_id: str + :param body: (required) + :type body: ApiReportRunMetricsRequest + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(ApiReportRunMetricsResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiReportRunMetricsResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -895,11 +981,14 @@ def retry_run(self, run_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.retry_run(run_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run to be retried. (required) + :param run_id: The ID of the run to be retried. (required) + :type run_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -907,9 +996,10 @@ def retry_run(self, run_id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.retry_run_with_http_info(run_id, **kwargs) # noqa: E501 @@ -919,23 +1009,29 @@ def retry_run_with_http_info(self, run_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.retry_run_with_http_info(run_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run to be retried. (required) + :param run_id: The ID of the run to be retried. (required) + :type run_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -1007,11 +1103,14 @@ def terminate_run(self, run_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.terminate_run(run_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run to be terminated. (required) + :param run_id: The ID of the run to be terminated. (required) + :type run_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -1019,9 +1118,10 @@ def terminate_run(self, run_id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.terminate_run_with_http_info(run_id, **kwargs) # noqa: E501 @@ -1031,23 +1131,29 @@ def terminate_run_with_http_info(self, run_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.terminate_run_with_http_info(run_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str run_id: The ID of the run to be terminated. (required) + :param run_id: The ID of the run to be terminated. (required) + :type run_id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -1119,11 +1225,14 @@ def unarchive_run(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.unarchive_run(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the run to be restored. (required) + :param id: The ID of the run to be restored. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -1131,9 +1240,10 @@ def unarchive_run(self, id, **kwargs): # noqa: E501 number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: object + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: object """ kwargs['_return_http_data_only'] = True return self.unarchive_run_with_http_info(id, **kwargs) # noqa: E501 @@ -1143,23 +1253,29 @@ def unarchive_run_with_http_info(self, id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.unarchive_run_with_http_info(id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str id: The ID of the run to be restored. (required) + :param id: The ID of the run to be restored. (required) + :type id: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :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. - :return: tuple(object, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/backend/api/python_http_client/kfp_server_api/models/api_cron_schedule.py b/backend/api/python_http_client/kfp_server_api/models/api_cron_schedule.py index 61809582794..955b4ad866b 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_cron_schedule.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_cron_schedule.py @@ -92,7 +92,7 @@ def start_time(self, start_time): :param start_time: The start_time of this ApiCronSchedule. # noqa: E501 - :type: datetime + :type start_time: datetime """ self._start_time = start_time @@ -113,7 +113,7 @@ def end_time(self, end_time): :param end_time: The end_time of this ApiCronSchedule. # noqa: E501 - :type: datetime + :type end_time: datetime """ self._end_time = end_time @@ -134,7 +134,7 @@ def cron(self, cron): :param cron: The cron of this ApiCronSchedule. # noqa: E501 - :type: str + :type cron: str """ self._cron = cron diff --git a/backend/api/python_http_client/kfp_server_api/models/api_experiment.py b/backend/api/python_http_client/kfp_server_api/models/api_experiment.py index 93883be1ece..849243a2dfd 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_experiment.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_experiment.py @@ -109,7 +109,7 @@ def id(self, id): Output. Unique experiment ID. Generated by API server. # noqa: E501 :param id: The id of this ApiExperiment. # noqa: E501 - :type: str + :type id: str """ self._id = id @@ -132,7 +132,7 @@ def name(self, name): Required input field. Unique experiment name provided by user. # noqa: E501 :param name: The name of this ApiExperiment. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -153,7 +153,7 @@ def description(self, description): :param description: The description of this ApiExperiment. # noqa: E501 - :type: str + :type description: str """ self._description = description @@ -176,7 +176,7 @@ def created_at(self, created_at): Output. The time that the experiment created. # noqa: E501 :param created_at: The created_at of this ApiExperiment. # noqa: E501 - :type: datetime + :type created_at: datetime """ self._created_at = created_at @@ -199,7 +199,7 @@ def resource_references(self, resource_references): Optional input field. Specify which resource this run belongs to. For Experiment, the only valid resource reference is a single Namespace. # noqa: E501 :param resource_references: The resource_references of this ApiExperiment. # noqa: E501 - :type: list[ApiResourceReference] + :type resource_references: list[ApiResourceReference] """ self._resource_references = resource_references @@ -220,7 +220,7 @@ def storage_state(self, storage_state): :param storage_state: The storage_state of this ApiExperiment. # noqa: E501 - :type: ExperimentStorageState + :type storage_state: ExperimentStorageState """ self._storage_state = storage_state diff --git a/backend/api/python_http_client/kfp_server_api/models/api_get_template_response.py b/backend/api/python_http_client/kfp_server_api/models/api_get_template_response.py index 37fd58241be..a9aab9e4b34 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_get_template_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_get_template_response.py @@ -84,7 +84,7 @@ def template(self, template): The template of the pipeline specified in a GetTemplate request, or of a pipeline version specified in a GetPipelinesVersionTemplate request. # noqa: E501 :param template: The template of this ApiGetTemplateResponse. # noqa: E501 - :type: str + :type template: str """ self._template = template diff --git a/backend/api/python_http_client/kfp_server_api/models/api_job.py b/backend/api/python_http_client/kfp_server_api/models/api_job.py index 9aa58722bc0..1fd859a9c75 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_job.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_job.py @@ -154,7 +154,7 @@ def id(self, id): Output. Unique run ID. Generated by API server. # noqa: E501 :param id: The id of this ApiJob. # noqa: E501 - :type: str + :type id: str """ self._id = id @@ -177,7 +177,7 @@ def name(self, name): Required input field. Job name provided by user. Not unique. # noqa: E501 :param name: The name of this ApiJob. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -198,7 +198,7 @@ def description(self, description): :param description: The description of this ApiJob. # noqa: E501 - :type: str + :type description: str """ self._description = description @@ -219,7 +219,7 @@ def pipeline_spec(self, pipeline_spec): :param pipeline_spec: The pipeline_spec of this ApiJob. # noqa: E501 - :type: ApiPipelineSpec + :type pipeline_spec: ApiPipelineSpec """ self._pipeline_spec = pipeline_spec @@ -242,7 +242,7 @@ def resource_references(self, resource_references): Optional input field. Specify which resource this job belongs to. # noqa: E501 :param resource_references: The resource_references of this ApiJob. # noqa: E501 - :type: list[ApiResourceReference] + :type resource_references: list[ApiResourceReference] """ self._resource_references = resource_references @@ -265,7 +265,7 @@ def service_account(self, service_account): Optional input field. Specify which Kubernetes service account this job uses. # noqa: E501 :param service_account: The service_account of this ApiJob. # noqa: E501 - :type: str + :type service_account: str """ self._service_account = service_account @@ -286,7 +286,7 @@ def max_concurrency(self, max_concurrency): :param max_concurrency: The max_concurrency of this ApiJob. # noqa: E501 - :type: str + :type max_concurrency: str """ self._max_concurrency = max_concurrency @@ -307,7 +307,7 @@ def trigger(self, trigger): :param trigger: The trigger of this ApiJob. # noqa: E501 - :type: ApiTrigger + :type trigger: ApiTrigger """ self._trigger = trigger @@ -328,7 +328,7 @@ def mode(self, mode): :param mode: The mode of this ApiJob. # noqa: E501 - :type: JobMode + :type mode: JobMode """ self._mode = mode @@ -351,7 +351,7 @@ def created_at(self, created_at): Output. The time this job is created. # noqa: E501 :param created_at: The created_at of this ApiJob. # noqa: E501 - :type: datetime + :type created_at: datetime """ self._created_at = created_at @@ -374,7 +374,7 @@ def updated_at(self, updated_at): Output. The last time this job is updated. # noqa: E501 :param updated_at: The updated_at of this ApiJob. # noqa: E501 - :type: datetime + :type updated_at: datetime """ self._updated_at = updated_at @@ -395,7 +395,7 @@ def status(self, status): :param status: The status of this ApiJob. # noqa: E501 - :type: str + :type status: str """ self._status = status @@ -418,7 +418,7 @@ def error(self, error): In case any error happens retrieving a job field, only job ID and the error message is returned. Client has the flexibility of choosing how to handle error. This is especially useful during listing call. # noqa: E501 :param error: The error of this ApiJob. # noqa: E501 - :type: str + :type error: str """ self._error = error @@ -441,7 +441,7 @@ def enabled(self, enabled): Input. Whether the job is enabled or not. # noqa: E501 :param enabled: The enabled of this ApiJob. # noqa: E501 - :type: bool + :type enabled: bool """ self._enabled = enabled @@ -464,7 +464,7 @@ def no_catchup(self, no_catchup): Optional input field. Whether the job should catch up if behind schedule. If true, the job will only schedule the latest interval if behind schedule. If false, the job will catch up on each past interval. # noqa: E501 :param no_catchup: The no_catchup of this ApiJob. # noqa: E501 - :type: bool + :type no_catchup: bool """ self._no_catchup = no_catchup diff --git a/backend/api/python_http_client/kfp_server_api/models/api_list_experiments_response.py b/backend/api/python_http_client/kfp_server_api/models/api_list_experiments_response.py index df256083232..26b88d79ea2 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_list_experiments_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_list_experiments_response.py @@ -94,7 +94,7 @@ def experiments(self, experiments): A list of experiments returned. # noqa: E501 :param experiments: The experiments of this ApiListExperimentsResponse. # noqa: E501 - :type: list[ApiExperiment] + :type experiments: list[ApiExperiment] """ self._experiments = experiments @@ -117,7 +117,7 @@ def total_size(self, total_size): The total number of experiments for the given query. # noqa: E501 :param total_size: The total_size of this ApiListExperimentsResponse. # noqa: E501 - :type: int + :type total_size: int """ self._total_size = total_size @@ -140,7 +140,7 @@ def next_page_token(self, next_page_token): The token to list the next page of experiments. # noqa: E501 :param next_page_token: The next_page_token of this ApiListExperimentsResponse. # noqa: E501 - :type: str + :type next_page_token: str """ self._next_page_token = next_page_token diff --git a/backend/api/python_http_client/kfp_server_api/models/api_list_jobs_response.py b/backend/api/python_http_client/kfp_server_api/models/api_list_jobs_response.py index 854f7f1369e..65f1ce6a93f 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_list_jobs_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_list_jobs_response.py @@ -94,7 +94,7 @@ def jobs(self, jobs): A list of jobs returned. # noqa: E501 :param jobs: The jobs of this ApiListJobsResponse. # noqa: E501 - :type: list[ApiJob] + :type jobs: list[ApiJob] """ self._jobs = jobs @@ -117,7 +117,7 @@ def total_size(self, total_size): The total number of jobs for the given query. # noqa: E501 :param total_size: The total_size of this ApiListJobsResponse. # noqa: E501 - :type: int + :type total_size: int """ self._total_size = total_size @@ -140,7 +140,7 @@ def next_page_token(self, next_page_token): The token to list the next page of jobs. # noqa: E501 :param next_page_token: The next_page_token of this ApiListJobsResponse. # noqa: E501 - :type: str + :type next_page_token: str """ self._next_page_token = next_page_token diff --git a/backend/api/python_http_client/kfp_server_api/models/api_list_pipeline_versions_response.py b/backend/api/python_http_client/kfp_server_api/models/api_list_pipeline_versions_response.py index 8873b9f41ee..a9878dbd84d 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_list_pipeline_versions_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_list_pipeline_versions_response.py @@ -92,7 +92,7 @@ def versions(self, versions): :param versions: The versions of this ApiListPipelineVersionsResponse. # noqa: E501 - :type: list[ApiPipelineVersion] + :type versions: list[ApiPipelineVersion] """ self._versions = versions @@ -115,7 +115,7 @@ def next_page_token(self, next_page_token): The token to list the next page of pipeline versions. # noqa: E501 :param next_page_token: The next_page_token of this ApiListPipelineVersionsResponse. # noqa: E501 - :type: str + :type next_page_token: str """ self._next_page_token = next_page_token @@ -138,7 +138,7 @@ def total_size(self, total_size): The total number of pipeline versions for the given query. # noqa: E501 :param total_size: The total_size of this ApiListPipelineVersionsResponse. # noqa: E501 - :type: int + :type total_size: int """ self._total_size = total_size diff --git a/backend/api/python_http_client/kfp_server_api/models/api_list_pipelines_response.py b/backend/api/python_http_client/kfp_server_api/models/api_list_pipelines_response.py index 2d1eacacbe1..5141dd70e16 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_list_pipelines_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_list_pipelines_response.py @@ -92,7 +92,7 @@ def pipelines(self, pipelines): :param pipelines: The pipelines of this ApiListPipelinesResponse. # noqa: E501 - :type: list[ApiPipeline] + :type pipelines: list[ApiPipeline] """ self._pipelines = pipelines @@ -115,7 +115,7 @@ def total_size(self, total_size): The total number of pipelines for the given query. # noqa: E501 :param total_size: The total_size of this ApiListPipelinesResponse. # noqa: E501 - :type: int + :type total_size: int """ self._total_size = total_size @@ -138,7 +138,7 @@ def next_page_token(self, next_page_token): The token to list the next page of pipelines. # noqa: E501 :param next_page_token: The next_page_token of this ApiListPipelinesResponse. # noqa: E501 - :type: str + :type next_page_token: str """ self._next_page_token = next_page_token diff --git a/backend/api/python_http_client/kfp_server_api/models/api_list_runs_response.py b/backend/api/python_http_client/kfp_server_api/models/api_list_runs_response.py index d09fc05cd38..57393719bf2 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_list_runs_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_list_runs_response.py @@ -92,7 +92,7 @@ def runs(self, runs): :param runs: The runs of this ApiListRunsResponse. # noqa: E501 - :type: list[ApiRun] + :type runs: list[ApiRun] """ self._runs = runs @@ -115,7 +115,7 @@ def total_size(self, total_size): The total number of runs for the given query. # noqa: E501 :param total_size: The total_size of this ApiListRunsResponse. # noqa: E501 - :type: int + :type total_size: int """ self._total_size = total_size @@ -138,7 +138,7 @@ def next_page_token(self, next_page_token): The token to list the next page of runs. # noqa: E501 :param next_page_token: The next_page_token of this ApiListRunsResponse. # noqa: E501 - :type: str + :type next_page_token: str """ self._next_page_token = next_page_token diff --git a/backend/api/python_http_client/kfp_server_api/models/api_parameter.py b/backend/api/python_http_client/kfp_server_api/models/api_parameter.py index 70eeb8dcb0d..c98089232b4 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_parameter.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_parameter.py @@ -87,7 +87,7 @@ def name(self, name): :param name: The name of this ApiParameter. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -108,7 +108,7 @@ def value(self, value): :param value: The value of this ApiParameter. # noqa: E501 - :type: str + :type value: str """ self._value = value diff --git a/backend/api/python_http_client/kfp_server_api/models/api_periodic_schedule.py b/backend/api/python_http_client/kfp_server_api/models/api_periodic_schedule.py index cf0e9dada21..2c864e7760c 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_periodic_schedule.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_periodic_schedule.py @@ -92,7 +92,7 @@ def start_time(self, start_time): :param start_time: The start_time of this ApiPeriodicSchedule. # noqa: E501 - :type: datetime + :type start_time: datetime """ self._start_time = start_time @@ -113,7 +113,7 @@ def end_time(self, end_time): :param end_time: The end_time of this ApiPeriodicSchedule. # noqa: E501 - :type: datetime + :type end_time: datetime """ self._end_time = end_time @@ -134,7 +134,7 @@ def interval_second(self, interval_second): :param interval_second: The interval_second of this ApiPeriodicSchedule. # noqa: E501 - :type: str + :type interval_second: str """ self._interval_second = interval_second diff --git a/backend/api/python_http_client/kfp_server_api/models/api_pipeline.py b/backend/api/python_http_client/kfp_server_api/models/api_pipeline.py index 38557809f70..4b875cf5771 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_pipeline.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_pipeline.py @@ -119,7 +119,7 @@ def id(self, id): Output. Unique pipeline ID. Generated by API server. # noqa: E501 :param id: The id of this ApiPipeline. # noqa: E501 - :type: str + :type id: str """ self._id = id @@ -142,7 +142,7 @@ def created_at(self, created_at): Output. The time this pipeline is created. # noqa: E501 :param created_at: The created_at of this ApiPipeline. # noqa: E501 - :type: datetime + :type created_at: datetime """ self._created_at = created_at @@ -165,7 +165,7 @@ def name(self, name): Optional input field. Pipeline name provided by user. If not specified, file name is used as pipeline name. # noqa: E501 :param name: The name of this ApiPipeline. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -188,7 +188,7 @@ def description(self, description): Optional input field. Describing the purpose of the job. # noqa: E501 :param description: The description of this ApiPipeline. # noqa: E501 - :type: str + :type description: str """ self._description = description @@ -211,7 +211,7 @@ def parameters(self, parameters): Output. The input parameters for this pipeline. TODO(jingzhang36): replace this parameters field with the parameters field inside PipelineVersion when all usage of the former has been changed to use the latter. # noqa: E501 :param parameters: The parameters of this ApiPipeline. # noqa: E501 - :type: list[ApiParameter] + :type parameters: list[ApiParameter] """ self._parameters = parameters @@ -232,7 +232,7 @@ def url(self, url): :param url: The url of this ApiPipeline. # noqa: E501 - :type: ApiUrl + :type url: ApiUrl """ self._url = url @@ -255,7 +255,7 @@ def error(self, error): In case any error happens retrieving a pipeline field, only pipeline ID and the error message is returned. Client has the flexibility of choosing how to handle error. This is especially useful during listing call. # noqa: E501 :param error: The error of this ApiPipeline. # noqa: E501 - :type: str + :type error: str """ self._error = error @@ -276,7 +276,7 @@ def default_version(self, default_version): :param default_version: The default_version of this ApiPipeline. # noqa: E501 - :type: ApiPipelineVersion + :type default_version: ApiPipelineVersion """ self._default_version = default_version diff --git a/backend/api/python_http_client/kfp_server_api/models/api_pipeline_runtime.py b/backend/api/python_http_client/kfp_server_api/models/api_pipeline_runtime.py index cb203af31e2..01035670282 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_pipeline_runtime.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_pipeline_runtime.py @@ -89,7 +89,7 @@ def pipeline_manifest(self, pipeline_manifest): Output. The runtime JSON manifest of the pipeline, including the status of pipeline steps and fields need for UI visualization etc. # noqa: E501 :param pipeline_manifest: The pipeline_manifest of this ApiPipelineRuntime. # noqa: E501 - :type: str + :type pipeline_manifest: str """ self._pipeline_manifest = pipeline_manifest @@ -112,7 +112,7 @@ def workflow_manifest(self, workflow_manifest): Output. The runtime JSON manifest of the argo workflow. This is deprecated after pipeline_runtime_manifest is in use. # noqa: E501 :param workflow_manifest: The workflow_manifest of this ApiPipelineRuntime. # noqa: E501 - :type: str + :type workflow_manifest: str """ self._workflow_manifest = workflow_manifest diff --git a/backend/api/python_http_client/kfp_server_api/models/api_pipeline_spec.py b/backend/api/python_http_client/kfp_server_api/models/api_pipeline_spec.py index 3119d654b25..b6120c17861 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_pipeline_spec.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_pipeline_spec.py @@ -104,7 +104,7 @@ def pipeline_id(self, pipeline_id): Optional input field. The ID of the pipeline user uploaded before. # noqa: E501 :param pipeline_id: The pipeline_id of this ApiPipelineSpec. # noqa: E501 - :type: str + :type pipeline_id: str """ self._pipeline_id = pipeline_id @@ -127,7 +127,7 @@ def pipeline_name(self, pipeline_name): Optional output field. The name of the pipeline. Not empty if the pipeline id is not empty. # noqa: E501 :param pipeline_name: The pipeline_name of this ApiPipelineSpec. # noqa: E501 - :type: str + :type pipeline_name: str """ self._pipeline_name = pipeline_name @@ -150,7 +150,7 @@ def workflow_manifest(self, workflow_manifest): Optional input field. The marshalled raw argo JSON workflow. This will be deprecated when pipeline_manifest is in use. # noqa: E501 :param workflow_manifest: The workflow_manifest of this ApiPipelineSpec. # noqa: E501 - :type: str + :type workflow_manifest: str """ self._workflow_manifest = workflow_manifest @@ -173,7 +173,7 @@ def pipeline_manifest(self, pipeline_manifest): Optional input field. The raw pipeline JSON spec. # noqa: E501 :param pipeline_manifest: The pipeline_manifest of this ApiPipelineSpec. # noqa: E501 - :type: str + :type pipeline_manifest: str """ self._pipeline_manifest = pipeline_manifest @@ -196,7 +196,7 @@ def parameters(self, parameters): The parameter user provide to inject to the pipeline JSON. If a default value of a parameter exist in the JSON, the value user provided here will replace. # noqa: E501 :param parameters: The parameters of this ApiPipelineSpec. # noqa: E501 - :type: list[ApiParameter] + :type parameters: list[ApiParameter] """ self._parameters = parameters diff --git a/backend/api/python_http_client/kfp_server_api/models/api_pipeline_version.py b/backend/api/python_http_client/kfp_server_api/models/api_pipeline_version.py index 5387bee5ccc..f5853758d29 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_pipeline_version.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_pipeline_version.py @@ -114,7 +114,7 @@ def id(self, id): Output. Unique version ID. Generated by API server. # noqa: E501 :param id: The id of this ApiPipelineVersion. # noqa: E501 - :type: str + :type id: str """ self._id = id @@ -137,7 +137,7 @@ def name(self, name): Optional input field. Version name provided by user. # noqa: E501 :param name: The name of this ApiPipelineVersion. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -160,7 +160,7 @@ def created_at(self, created_at): Output. The time this pipeline version is created. # noqa: E501 :param created_at: The created_at of this ApiPipelineVersion. # noqa: E501 - :type: datetime + :type created_at: datetime """ self._created_at = created_at @@ -183,7 +183,7 @@ def parameters(self, parameters): Output. The input parameters for this pipeline. # noqa: E501 :param parameters: The parameters of this ApiPipelineVersion. # noqa: E501 - :type: list[ApiParameter] + :type parameters: list[ApiParameter] """ self._parameters = parameters @@ -206,7 +206,7 @@ def code_source_url(self, code_source_url): Input. Optional. Pipeline version code source. # noqa: E501 :param code_source_url: The code_source_url of this ApiPipelineVersion. # noqa: E501 - :type: str + :type code_source_url: str """ self._code_source_url = code_source_url @@ -227,7 +227,7 @@ def package_url(self, package_url): :param package_url: The package_url of this ApiPipelineVersion. # noqa: E501 - :type: ApiUrl + :type package_url: ApiUrl """ self._package_url = package_url @@ -250,7 +250,7 @@ def resource_references(self, resource_references): Input. Required. E.g., specify which pipeline this pipeline version belongs to. # noqa: E501 :param resource_references: The resource_references of this ApiPipelineVersion. # noqa: E501 - :type: list[ApiResourceReference] + :type resource_references: list[ApiResourceReference] """ self._resource_references = resource_references diff --git a/backend/api/python_http_client/kfp_server_api/models/api_read_artifact_response.py b/backend/api/python_http_client/kfp_server_api/models/api_read_artifact_response.py index b39ef289cb0..a723b8c733d 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_read_artifact_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_read_artifact_response.py @@ -84,7 +84,7 @@ def data(self, data): The bytes of the artifact content. # noqa: E501 :param data: The data of this ApiReadArtifactResponse. # noqa: E501 - :type: str + :type data: str """ if (self.local_vars_configuration.client_side_validation and data is not None and not re.search(r'^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$', data)): # noqa: E501 diff --git a/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_request.py b/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_request.py index c6d64e3dc51..5dee2a6dfd4 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_request.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_request.py @@ -89,7 +89,7 @@ def run_id(self, run_id): Required. The parent run ID of the metric. # noqa: E501 :param run_id: The run_id of this ApiReportRunMetricsRequest. # noqa: E501 - :type: str + :type run_id: str """ self._run_id = run_id @@ -112,7 +112,7 @@ def metrics(self, metrics): List of metrics to report. # noqa: E501 :param metrics: The metrics of this ApiReportRunMetricsRequest. # noqa: E501 - :type: list[ApiRunMetric] + :type metrics: list[ApiRunMetric] """ self._metrics = metrics diff --git a/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_response.py b/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_response.py index fb87652974a..cb3a2e29491 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_response.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_report_run_metrics_response.py @@ -82,7 +82,7 @@ def results(self, results): :param results: The results of this ApiReportRunMetricsResponse. # noqa: E501 - :type: list[ReportRunMetricsResponseReportRunMetricResult] + :type results: list[ReportRunMetricsResponseReportRunMetricResult] """ self._results = results diff --git a/backend/api/python_http_client/kfp_server_api/models/api_resource_key.py b/backend/api/python_http_client/kfp_server_api/models/api_resource_key.py index 326a3089af9..56064f432fe 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_resource_key.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_resource_key.py @@ -87,7 +87,7 @@ def type(self, type): :param type: The type of this ApiResourceKey. # noqa: E501 - :type: ApiResourceType + :type type: ApiResourceType """ self._type = type @@ -110,7 +110,7 @@ def id(self, id): The ID of the resource that referred to. # noqa: E501 :param id: The id of this ApiResourceKey. # noqa: E501 - :type: str + :type id: str """ self._id = id diff --git a/backend/api/python_http_client/kfp_server_api/models/api_resource_reference.py b/backend/api/python_http_client/kfp_server_api/models/api_resource_reference.py index 3a6dba6fa1a..2179aab1c84 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_resource_reference.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_resource_reference.py @@ -92,7 +92,7 @@ def key(self, key): :param key: The key of this ApiResourceReference. # noqa: E501 - :type: ApiResourceKey + :type key: ApiResourceKey """ self._key = key @@ -115,7 +115,7 @@ def name(self, name): The name of the resource that referred to. # noqa: E501 :param name: The name of this ApiResourceReference. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -136,7 +136,7 @@ def relationship(self, relationship): :param relationship: The relationship of this ApiResourceReference. # noqa: E501 - :type: ApiRelationship + :type relationship: ApiRelationship """ self._relationship = relationship diff --git a/backend/api/python_http_client/kfp_server_api/models/api_run.py b/backend/api/python_http_client/kfp_server_api/models/api_run.py index 92cd18cb33c..fe945f6f658 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_run.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_run.py @@ -144,7 +144,7 @@ def id(self, id): Output. Unique run ID. Generated by API server. # noqa: E501 :param id: The id of this ApiRun. # noqa: E501 - :type: str + :type id: str """ self._id = id @@ -167,7 +167,7 @@ def name(self, name): Required input field. Name provided by user, or auto generated if run is created by scheduled job. Not unique. # noqa: E501 :param name: The name of this ApiRun. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -188,7 +188,7 @@ def storage_state(self, storage_state): :param storage_state: The storage_state of this ApiRun. # noqa: E501 - :type: RunStorageState + :type storage_state: RunStorageState """ self._storage_state = storage_state @@ -209,7 +209,7 @@ def description(self, description): :param description: The description of this ApiRun. # noqa: E501 - :type: str + :type description: str """ self._description = description @@ -230,7 +230,7 @@ def pipeline_spec(self, pipeline_spec): :param pipeline_spec: The pipeline_spec of this ApiRun. # noqa: E501 - :type: ApiPipelineSpec + :type pipeline_spec: ApiPipelineSpec """ self._pipeline_spec = pipeline_spec @@ -253,7 +253,7 @@ def resource_references(self, resource_references): Optional input field. Specify which resource this run belongs to. When creating a run from a particular pipeline version, the pipeline version can be specified here. # noqa: E501 :param resource_references: The resource_references of this ApiRun. # noqa: E501 - :type: list[ApiResourceReference] + :type resource_references: list[ApiResourceReference] """ self._resource_references = resource_references @@ -276,7 +276,7 @@ def service_account(self, service_account): Optional input field. Specify which Kubernetes service account this run uses. # noqa: E501 :param service_account: The service_account of this ApiRun. # noqa: E501 - :type: str + :type service_account: str """ self._service_account = service_account @@ -299,7 +299,7 @@ def created_at(self, created_at): Output. The time that the run created. # noqa: E501 :param created_at: The created_at of this ApiRun. # noqa: E501 - :type: datetime + :type created_at: datetime """ self._created_at = created_at @@ -322,7 +322,7 @@ def scheduled_at(self, scheduled_at): Output. When this run is scheduled to run. This could be different from created_at. For example, if a run is from a backfilling job that was supposed to run 2 month ago, the scheduled_at is 2 month ago, v.s. created_at is the current time. # noqa: E501 :param scheduled_at: The scheduled_at of this ApiRun. # noqa: E501 - :type: datetime + :type scheduled_at: datetime """ self._scheduled_at = scheduled_at @@ -345,7 +345,7 @@ def finished_at(self, finished_at): Output. The time this run is finished. # noqa: E501 :param finished_at: The finished_at of this ApiRun. # noqa: E501 - :type: datetime + :type finished_at: datetime """ self._finished_at = finished_at @@ -366,7 +366,7 @@ def status(self, status): :param status: The status of this ApiRun. # noqa: E501 - :type: str + :type status: str """ self._status = status @@ -389,7 +389,7 @@ def error(self, error): In case any error happens retrieving a run field, only run ID and the error message is returned. Client has the flexibility of choosing how to handle error. This is especially useful during listing call. # noqa: E501 :param error: The error of this ApiRun. # noqa: E501 - :type: str + :type error: str """ self._error = error @@ -412,7 +412,7 @@ def metrics(self, metrics): Output. The metrics of the run. The metrics are reported by ReportMetrics API. # noqa: E501 :param metrics: The metrics of this ApiRun. # noqa: E501 - :type: list[ApiRunMetric] + :type metrics: list[ApiRunMetric] """ self._metrics = metrics diff --git a/backend/api/python_http_client/kfp_server_api/models/api_run_detail.py b/backend/api/python_http_client/kfp_server_api/models/api_run_detail.py index c3b415c4c9c..e90e8a1e372 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_run_detail.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_run_detail.py @@ -87,7 +87,7 @@ def run(self, run): :param run: The run of this ApiRunDetail. # noqa: E501 - :type: ApiRun + :type run: ApiRun """ self._run = run @@ -108,7 +108,7 @@ def pipeline_runtime(self, pipeline_runtime): :param pipeline_runtime: The pipeline_runtime of this ApiRunDetail. # noqa: E501 - :type: ApiPipelineRuntime + :type pipeline_runtime: ApiPipelineRuntime """ self._pipeline_runtime = pipeline_runtime diff --git a/backend/api/python_http_client/kfp_server_api/models/api_run_metric.py b/backend/api/python_http_client/kfp_server_api/models/api_run_metric.py index dc619da336f..193a27e2514 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_run_metric.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_run_metric.py @@ -99,7 +99,7 @@ def name(self, name): Required. The user defined name of the metric. It must between 1 and 63 characters long and must conform to the following regular expression: `[a-z]([-a-z0-9]*[a-z0-9])?`. # noqa: E501 :param name: The name of this ApiRunMetric. # noqa: E501 - :type: str + :type name: str """ self._name = name @@ -122,7 +122,7 @@ def node_id(self, node_id): Required. The runtime node ID which reports the metric. The node ID can be found in the RunDetail.workflow.Status. Metric with same (node_id, name) are considerd as duplicate. Only the first reporting will be recorded. Max length is 128. # noqa: E501 :param node_id: The node_id of this ApiRunMetric. # noqa: E501 - :type: str + :type node_id: str """ self._node_id = node_id @@ -145,7 +145,7 @@ def number_value(self, number_value): The number value of the metric. # noqa: E501 :param number_value: The number_value of this ApiRunMetric. # noqa: E501 - :type: float + :type number_value: float """ self._number_value = number_value @@ -166,7 +166,7 @@ def format(self, format): :param format: The format of this ApiRunMetric. # noqa: E501 - :type: RunMetricFormat + :type format: RunMetricFormat """ self._format = format diff --git a/backend/api/python_http_client/kfp_server_api/models/api_status.py b/backend/api/python_http_client/kfp_server_api/models/api_status.py index 4b2a4d8a214..48093c5a246 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_status.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_status.py @@ -92,7 +92,7 @@ def error(self, error): :param error: The error of this ApiStatus. # noqa: E501 - :type: str + :type error: str """ self._error = error @@ -113,7 +113,7 @@ def code(self, code): :param code: The code of this ApiStatus. # noqa: E501 - :type: int + :type code: int """ self._code = code @@ -134,7 +134,7 @@ def details(self, details): :param details: The details of this ApiStatus. # noqa: E501 - :type: list[ProtobufAny] + :type details: list[ProtobufAny] """ self._details = details diff --git a/backend/api/python_http_client/kfp_server_api/models/api_trigger.py b/backend/api/python_http_client/kfp_server_api/models/api_trigger.py index e5e9f7fc5d7..b0950eff619 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_trigger.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_trigger.py @@ -87,7 +87,7 @@ def cron_schedule(self, cron_schedule): :param cron_schedule: The cron_schedule of this ApiTrigger. # noqa: E501 - :type: ApiCronSchedule + :type cron_schedule: ApiCronSchedule """ self._cron_schedule = cron_schedule @@ -108,7 +108,7 @@ def periodic_schedule(self, periodic_schedule): :param periodic_schedule: The periodic_schedule of this ApiTrigger. # noqa: E501 - :type: ApiPeriodicSchedule + :type periodic_schedule: ApiPeriodicSchedule """ self._periodic_schedule = periodic_schedule diff --git a/backend/api/python_http_client/kfp_server_api/models/api_url.py b/backend/api/python_http_client/kfp_server_api/models/api_url.py index e7b8767691b..e54254540ad 100644 --- a/backend/api/python_http_client/kfp_server_api/models/api_url.py +++ b/backend/api/python_http_client/kfp_server_api/models/api_url.py @@ -84,7 +84,7 @@ def pipeline_url(self, pipeline_url): URL of the pipeline definition or the pipeline version definition. # noqa: E501 :param pipeline_url: The pipeline_url of this ApiUrl. # noqa: E501 - :type: str + :type pipeline_url: str """ self._pipeline_url = pipeline_url diff --git a/backend/api/python_http_client/kfp_server_api/models/protobuf_any.py b/backend/api/python_http_client/kfp_server_api/models/protobuf_any.py index 70685e65232..44875820744 100644 --- a/backend/api/python_http_client/kfp_server_api/models/protobuf_any.py +++ b/backend/api/python_http_client/kfp_server_api/models/protobuf_any.py @@ -89,7 +89,7 @@ def type_url(self, type_url): A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading \".\" is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. # noqa: E501 :param type_url: The type_url of this ProtobufAny. # noqa: E501 - :type: str + :type type_url: str """ self._type_url = type_url @@ -112,7 +112,7 @@ def value(self, value): Must be a valid serialized protocol buffer of the above specified type. # noqa: E501 :param value: The value of this ProtobufAny. # noqa: E501 - :type: str + :type value: str """ if (self.local_vars_configuration.client_side_validation and value is not None and not re.search(r'^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$', value)): # noqa: E501 diff --git a/backend/api/python_http_client/kfp_server_api/models/report_run_metrics_response_report_run_metric_result.py b/backend/api/python_http_client/kfp_server_api/models/report_run_metrics_response_report_run_metric_result.py index 06fc66ca1db..6b89291fa1b 100644 --- a/backend/api/python_http_client/kfp_server_api/models/report_run_metrics_response_report_run_metric_result.py +++ b/backend/api/python_http_client/kfp_server_api/models/report_run_metrics_response_report_run_metric_result.py @@ -99,7 +99,7 @@ def metric_name(self, metric_name): Output. The name of the metric. # noqa: E501 :param metric_name: The metric_name of this ReportRunMetricsResponseReportRunMetricResult. # noqa: E501 - :type: str + :type metric_name: str """ self._metric_name = metric_name @@ -122,7 +122,7 @@ def metric_node_id(self, metric_node_id): Output. The ID of the node which reports the metric. # noqa: E501 :param metric_node_id: The metric_node_id of this ReportRunMetricsResponseReportRunMetricResult. # noqa: E501 - :type: str + :type metric_node_id: str """ self._metric_node_id = metric_node_id @@ -143,7 +143,7 @@ def status(self, status): :param status: The status of this ReportRunMetricsResponseReportRunMetricResult. # noqa: E501 - :type: ReportRunMetricsResponseReportRunMetricResultStatus + :type status: ReportRunMetricsResponseReportRunMetricResultStatus """ self._status = status @@ -166,7 +166,7 @@ def message(self, message): Output. The detailed message of the error of the reporting. # noqa: E501 :param message: The message of this ReportRunMetricsResponseReportRunMetricResult. # noqa: E501 - :type: str + :type message: str """ self._message = message diff --git a/backend/api/python_http_client_template/api.mustache b/backend/api/python_http_client_template/api.mustache new file mode 100644 index 00000000000..122e816cb5a --- /dev/null +++ b/backend/api/python_http_client_template/api.mustache @@ -0,0 +1,270 @@ +# coding: utf-8 + +{{>partial_header}} + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from {{packageName}}.api_client import ApiClient +from {{packageName}}.exceptions import ( # noqa: F401 + ApiTypeError, + ApiValueError +) + + +{{#operations}} +class {{classname}}(object): + """NOTE: This class is auto generated by OpenAPI Generator + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client +{{#operation}} + + def {{operationId}}(self, {{#sortParamsByRequiredFlag}}{{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}{{/sortParamsByRequiredFlag}}**kwargs): # noqa: E501 + """{{#summary}}{{{.}}}{{/summary}}{{^summary}}{{operationId}}{{/summary}} # noqa: E501 + +{{#notes}} + {{{notes}}} # noqa: E501 +{{/notes}} + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + +{{#sortParamsByRequiredFlag}} + >>> thread = api.{{operationId}}({{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}async_req=True) +{{/sortParamsByRequiredFlag}} +{{^sortParamsByRequiredFlag}} + >>> thread = api.{{operationId}}({{#allParams}}{{#required}}{{paramName}}={{paramName}}_value, {{/required}}{{/allParams}}async_req=True) +{{/sortParamsByRequiredFlag}} + >>> result = thread.get() + +{{#allParams}} + :param {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}} + :type {{paramName}}: {{dataType}}{{#optional}}, optional{{/optional}} +{{/allParams}} + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :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. + :return: Returns the result object. + If the method is called asynchronously, + returns the request thread. + :rtype: {{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}None{{/returnType}} + """ + kwargs['_return_http_data_only'] = True + return self.{{operationId}}_with_http_info({{#sortParamsByRequiredFlag}}{{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}{{/sortParamsByRequiredFlag}}**kwargs) # noqa: E501 + + def {{operationId}}_with_http_info(self, {{#sortParamsByRequiredFlag}}{{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}{{/sortParamsByRequiredFlag}}**kwargs): # noqa: E501 + """{{#summary}}{{{.}}}{{/summary}}{{^summary}}{{operationId}}{{/summary}} # noqa: E501 + +{{#notes}} + {{{notes}}} # noqa: E501 +{{/notes}} + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + +{{#sortParamsByRequiredFlag}} + >>> thread = api.{{operationId}}_with_http_info({{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}async_req=True) +{{/sortParamsByRequiredFlag}} +{{^sortParamsByRequiredFlag}} + >>> thread = api.{{operationId}}_with_http_info({{#allParams}}{{#required}}{{paramName}}={{paramName}}_value, {{/required}}{{/allParams}}async_req=True) +{{/sortParamsByRequiredFlag}} + >>> result = thread.get() + +{{#allParams}} + :param {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}} + :type {{paramName}}: {{dataType}}{{#optional}}, optional{{/optional}} +{{/allParams}} + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional + :param _return_http_data_only: response data without head status code + and headers + :type _return_http_data_only: bool, optional + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :type _preload_content: bool, optional + :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. + :return: Returns the result object. + If the method is called asynchronously, + returns the request thread. + :rtype: {{#returnType}}tuple({{returnType}}, status_code(int), headers(HTTPHeaderDict)){{/returnType}}{{^returnType}}None{{/returnType}} + """ + + {{#servers.0}} + local_var_hosts = [ +{{#servers}} + '{{{url}}}'{{^-last}},{{/-last}} +{{/servers}} + ] + local_var_host = local_var_hosts[0] + if kwargs.get('_host_index'): + _host_index = int(kwargs.get('_host_index')) + if _host_index < 0 or _host_index >= len(local_var_hosts): + raise ApiValueError( + "Invalid host index. Must be 0 <= index < %s" + % len(local_var_host) + ) + local_var_host = local_var_hosts[_host_index] + {{/servers.0}} + local_var_params = locals() + + all_params = [ +{{#allParams}} + '{{paramName}}'{{#hasMore}},{{/hasMore}} +{{/allParams}} + ] + all_params.extend( + [ + 'async_req', + '_return_http_data_only', + '_preload_content', + '_request_timeout' + ] + ) + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params{{#servers.0}} and key != "_host_index"{{/servers.0}}: + raise ApiTypeError( + "Got an unexpected keyword argument '%s'" + " to method {{operationId}}" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] +{{#allParams}} +{{^isNullable}} +{{#required}} + # verify the required parameter '{{paramName}}' is set + if self.api_client.client_side_validation and ('{{paramName}}' not in local_var_params or # noqa: E501 + local_var_params['{{paramName}}'] is None): # noqa: E501 + raise ApiValueError("Missing the required parameter `{{paramName}}` when calling `{{operationId}}`") # noqa: E501 +{{/required}} +{{/isNullable}} +{{/allParams}} + +{{#allParams}} +{{#hasValidation}} + {{#maxLength}} + if self.api_client.client_side_validation and ('{{paramName}}' in local_var_params and # noqa: E501 + len(local_var_params['{{paramName}}']) > {{maxLength}}): # noqa: E501 + raise ApiValueError("Invalid value for parameter `{{paramName}}` when calling `{{operationId}}`, length must be less than or equal to `{{maxLength}}`") # noqa: E501 + {{/maxLength}} + {{#minLength}} + if self.api_client.client_side_validation and ('{{paramName}}' in local_var_params and # noqa: E501 + len(local_var_params['{{paramName}}']) < {{minLength}}): # noqa: E501 + raise ApiValueError("Invalid value for parameter `{{paramName}}` when calling `{{operationId}}`, length must be greater than or equal to `{{minLength}}`") # noqa: E501 + {{/minLength}} + {{#maximum}} + if self.api_client.client_side_validation and '{{paramName}}' in local_var_params and local_var_params['{{paramName}}'] >{{#exclusiveMaximum}}={{/exclusiveMaximum}} {{maximum}}: # noqa: E501 + raise ApiValueError("Invalid value for parameter `{{paramName}}` when calling `{{operationId}}`, must be a value less than {{^exclusiveMaximum}}or equal to {{/exclusiveMaximum}}`{{maximum}}`") # noqa: E501 + {{/maximum}} + {{#minimum}} + if self.api_client.client_side_validation and '{{paramName}}' in local_var_params and local_var_params['{{paramName}}'] <{{#exclusiveMinimum}}={{/exclusiveMinimum}} {{minimum}}: # noqa: E501 + raise ApiValueError("Invalid value for parameter `{{paramName}}` when calling `{{operationId}}`, must be a value greater than {{^exclusiveMinimum}}or equal to {{/exclusiveMinimum}}`{{minimum}}`") # noqa: E501 + {{/minimum}} + {{#pattern}} + if self.api_client.client_side_validation and '{{paramName}}' in local_var_params and not re.search(r'{{{vendorExtensions.x-regex}}}', local_var_params['{{paramName}}']{{#vendorExtensions.x-modifiers}}{{#-first}}, flags={{/-first}}re.{{.}}{{^-last}} | {{/-last}}{{/vendorExtensions.x-modifiers}}): # noqa: E501 + raise ApiValueError("Invalid value for parameter `{{paramName}}` when calling `{{operationId}}`, must conform to the pattern `{{{pattern}}}`") # noqa: E501 + {{/pattern}} + {{#maxItems}} + if self.api_client.client_side_validation and ('{{paramName}}' in local_var_params and # noqa: E501 + len(local_var_params['{{paramName}}']) > {{maxItems}}): # noqa: E501 + raise ApiValueError("Invalid value for parameter `{{paramName}}` when calling `{{operationId}}`, number of items must be less than or equal to `{{maxItems}}`") # noqa: E501 + {{/maxItems}} + {{#minItems}} + if self.api_client.client_side_validation and ('{{paramName}}' in local_var_params and # noqa: E501 + len(local_var_params['{{paramName}}']) < {{minItems}}): # noqa: E501 + raise ApiValueError("Invalid value for parameter `{{paramName}}` when calling `{{operationId}}`, number of items must be greater than or equal to `{{minItems}}`") # noqa: E501 + {{/minItems}} +{{/hasValidation}} +{{#-last}} +{{/-last}} +{{/allParams}} + collection_formats = {} + + path_params = {} +{{#pathParams}} + if '{{paramName}}' in local_var_params: + path_params['{{baseName}}'] = local_var_params['{{paramName}}']{{#isListContainer}} # noqa: E501 + collection_formats['{{baseName}}'] = '{{collectionFormat}}'{{/isListContainer}} # noqa: E501 +{{/pathParams}} + + query_params = [] +{{#queryParams}} + if '{{paramName}}' in local_var_params and local_var_params['{{paramName}}'] is not None: # noqa: E501 + query_params.append(('{{baseName}}', local_var_params['{{paramName}}'])){{#isListContainer}} # noqa: E501 + collection_formats['{{baseName}}'] = '{{collectionFormat}}'{{/isListContainer}} # noqa: E501 +{{/queryParams}} + + header_params = {} +{{#headerParams}} + if '{{paramName}}' in local_var_params: + header_params['{{baseName}}'] = local_var_params['{{paramName}}']{{#isListContainer}} # noqa: E501 + collection_formats['{{baseName}}'] = '{{collectionFormat}}'{{/isListContainer}} # noqa: E501 +{{/headerParams}} + + form_params = [] + local_var_files = {} +{{#formParams}} + if '{{paramName}}' in local_var_params: + {{^isFile}}form_params.append(('{{baseName}}', local_var_params['{{paramName}}'])){{/isFile}}{{#isFile}}local_var_files['{{baseName}}'] = local_var_params['{{paramName}}']{{/isFile}}{{#isListContainer}} # noqa: E501 + collection_formats['{{baseName}}'] = '{{collectionFormat}}'{{/isListContainer}} # noqa: E501 +{{/formParams}} + + body_params = None +{{#bodyParam}} + if '{{paramName}}' in local_var_params: + body_params = local_var_params['{{paramName}}'] +{{/bodyParam}} + {{#hasProduces}} + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + [{{#produces}}'{{{mediaType}}}'{{#hasMore}}, {{/hasMore}}{{/produces}}]) # noqa: E501 + + {{/hasProduces}} + {{#hasConsumes}} + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + [{{#consumes}}'{{{mediaType}}}'{{#hasMore}}, {{/hasMore}}{{/consumes}}]) # noqa: E501 + + {{/hasConsumes}} + # Authentication setting + auth_settings = [{{#authMethods}}'{{name}}'{{#hasMore}}, {{/hasMore}}{{/authMethods}}] # noqa: E501 + + return self.api_client.call_api( + '{{{path}}}', '{{httpMethod}}', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type={{#returnType}}'{{returnType}}'{{/returnType}}{{^returnType}}None{{/returnType}}, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + {{#servers.0}} + _host=local_var_host, + {{/servers.0}} + collection_formats=collection_formats) +{{/operation}} +{{/operations}} diff --git a/backend/api/python_http_client_template/model.mustache b/backend/api/python_http_client_template/model.mustache new file mode 100644 index 00000000000..2b3299a6f2b --- /dev/null +++ b/backend/api/python_http_client_template/model.mustache @@ -0,0 +1,246 @@ +# coding: utf-8 + +{{>partial_header}} + +import pprint +import re # noqa: F401 + +import six + +from {{packageName}}.configuration import Configuration + + +{{#models}} +{{#model}} +class {{classname}}(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """{{#allowableValues}} + + """ + allowed enum values + """ +{{#enumVars}} + {{name}} = {{{value}}}{{^-last}} +{{/-last}} +{{/enumVars}}{{/allowableValues}} + +{{#allowableValues}} + allowable_values = [{{#enumVars}}{{name}}{{^-last}}, {{/-last}}{{/enumVars}}] # noqa: E501 + +{{/allowableValues}} + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { +{{#vars}} + '{{name}}': '{{{dataType}}}'{{#hasMore}},{{/hasMore}} +{{/vars}} + } + + attribute_map = { +{{#vars}} + '{{name}}': '{{baseName}}'{{#hasMore}},{{/hasMore}} +{{/vars}} + } +{{#discriminator}} + + discriminator_value_class_map = { +{{#children}} + '{{^vendorExtensions.x-discriminator-value}}{{name}}{{/vendorExtensions.x-discriminator-value}}{{#vendorExtensions.x-discriminator-value}}{{{vendorExtensions.x-discriminator-value}}}{{/vendorExtensions.x-discriminator-value}}': '{{{classname}}}'{{^-last}},{{/-last}} +{{/children}} + } +{{/discriminator}} + + def __init__(self{{#vars}}, {{name}}={{#defaultValue}}{{{defaultValue}}}{{/defaultValue}}{{^defaultValue}}None{{/defaultValue}}{{/vars}}, local_vars_configuration=None): # noqa: E501 + """{{classname}} - a model defined in OpenAPI""" # noqa: E501 + if local_vars_configuration is None: + local_vars_configuration = Configuration() + self.local_vars_configuration = local_vars_configuration +{{#vars}}{{#-first}} +{{/-first}} + self._{{name}} = None +{{/vars}} + self.discriminator = {{#discriminator}}'{{{discriminatorName}}}'{{/discriminator}}{{^discriminator}}None{{/discriminator}} +{{#vars}}{{#-first}} +{{/-first}} +{{#required}} + self.{{name}} = {{name}} +{{/required}} +{{^required}} +{{#isNullable}} + self.{{name}} = {{name}} +{{/isNullable}} +{{^isNullable}} + if {{name}} is not None: + self.{{name}} = {{name}} +{{/isNullable}} +{{/required}} +{{/vars}} + +{{#vars}} + @property + def {{name}}(self): + """Gets the {{name}} of this {{classname}}. # noqa: E501 + +{{#description}} + {{{description}}} # noqa: E501 +{{/description}} + + :return: The {{name}} of this {{classname}}. # noqa: E501 + :rtype: {{dataType}} + """ + return self._{{name}} + + @{{name}}.setter + def {{name}}(self, {{name}}): + """Sets the {{name}} of this {{classname}}. + +{{#description}} + {{{description}}} # noqa: E501 +{{/description}} + + :param {{name}}: The {{name}} of this {{classname}}. # noqa: E501 + :type {{name}}: {{dataType}} + """ +{{^isNullable}} +{{#required}} + if self.local_vars_configuration.client_side_validation and {{name}} is None: # noqa: E501 + raise ValueError("Invalid value for `{{name}}`, must not be `None`") # noqa: E501 +{{/required}} +{{/isNullable}} +{{#isEnum}} +{{#isContainer}} + allowed_values = [{{#isNullable}}None,{{/isNullable}}{{#allowableValues}}{{#values}}{{#items.isString}}"{{/items.isString}}{{{this}}}{{#items.isString}}"{{/items.isString}}{{^-last}}, {{/-last}}{{/values}}{{/allowableValues}}] # noqa: E501 +{{#isListContainer}} + if (self.local_vars_configuration.client_side_validation and + not set({{{name}}}).issubset(set(allowed_values))): # noqa: E501 + raise ValueError( + "Invalid values for `{{{name}}}` [{0}], must be a subset of [{1}]" # noqa: E501 + .format(", ".join(map(str, set({{{name}}}) - set(allowed_values))), # noqa: E501 + ", ".join(map(str, allowed_values))) + ) +{{/isListContainer}} +{{#isMapContainer}} + if (self.local_vars_configuration.client_side_validation and + not set({{{name}}}.keys()).issubset(set(allowed_values))): # noqa: E501 + raise ValueError( + "Invalid keys in `{{{name}}}` [{0}], must be a subset of [{1}]" # noqa: E501 + .format(", ".join(map(str, set({{{name}}}.keys()) - set(allowed_values))), # noqa: E501 + ", ".join(map(str, allowed_values))) + ) +{{/isMapContainer}} +{{/isContainer}} +{{^isContainer}} + allowed_values = [{{#isNullable}}None,{{/isNullable}}{{#allowableValues}}{{#values}}{{#isString}}"{{/isString}}{{{this}}}{{#isString}}"{{/isString}}{{^-last}}, {{/-last}}{{/values}}{{/allowableValues}}] # noqa: E501 + if self.local_vars_configuration.client_side_validation and {{{name}}} not in allowed_values: # noqa: E501 + raise ValueError( + "Invalid value for `{{{name}}}` ({0}), must be one of {1}" # noqa: E501 + .format({{{name}}}, allowed_values) + ) +{{/isContainer}} +{{/isEnum}} +{{^isEnum}} +{{#hasValidation}} +{{#maxLength}} + if (self.local_vars_configuration.client_side_validation and + {{name}} is not None and len({{name}}) > {{maxLength}}): + raise ValueError("Invalid value for `{{name}}`, length must be less than or equal to `{{maxLength}}`") # noqa: E501 +{{/maxLength}} +{{#minLength}} + if (self.local_vars_configuration.client_side_validation and + {{name}} is not None and len({{name}}) < {{minLength}}): + raise ValueError("Invalid value for `{{name}}`, length must be greater than or equal to `{{minLength}}`") # noqa: E501 +{{/minLength}} +{{#maximum}} + if (self.local_vars_configuration.client_side_validation and + {{name}} is not None and {{name}} >{{#exclusiveMaximum}}={{/exclusiveMaximum}} {{maximum}}): # noqa: E501 + raise ValueError("Invalid value for `{{name}}`, must be a value less than {{^exclusiveMaximum}}or equal to {{/exclusiveMaximum}}`{{maximum}}`") # noqa: E501 +{{/maximum}} +{{#minimum}} + if (self.local_vars_configuration.client_side_validation and + {{name}} is not None and {{name}} <{{#exclusiveMinimum}}={{/exclusiveMinimum}} {{minimum}}): # noqa: E501 + raise ValueError("Invalid value for `{{name}}`, must be a value greater than {{^exclusiveMinimum}}or equal to {{/exclusiveMinimum}}`{{minimum}}`") # noqa: E501 +{{/minimum}} +{{#pattern}} + if (self.local_vars_configuration.client_side_validation and + {{name}} is not None and not re.search(r'{{{vendorExtensions.x-regex}}}', {{name}}{{#vendorExtensions.x-modifiers}}{{#-first}}, flags={{/-first}}re.{{.}}{{^-last}} | {{/-last}}{{/vendorExtensions.x-modifiers}})): # noqa: E501 + raise ValueError(r"Invalid value for `{{name}}`, must be a follow pattern or equal to `{{{pattern}}}`") # noqa: E501 +{{/pattern}} +{{#maxItems}} + if (self.local_vars_configuration.client_side_validation and + {{name}} is not None and len({{name}}) > {{maxItems}}): + raise ValueError("Invalid value for `{{name}}`, number of items must be less than or equal to `{{maxItems}}`") # noqa: E501 +{{/maxItems}} +{{#minItems}} + if (self.local_vars_configuration.client_side_validation and + {{name}} is not None and len({{name}}) < {{minItems}}): + raise ValueError("Invalid value for `{{name}}`, number of items must be greater than or equal to `{{minItems}}`") # noqa: E501 +{{/minItems}} +{{/hasValidation}} +{{/isEnum}} + + self._{{name}} = {{name}} + +{{/vars}} +{{#discriminator}} + def get_real_child_model(self, data): + """Returns the real base class specified by the discriminator""" + discriminator_key = self.attribute_map[self.discriminator] + discriminator_value = data[discriminator_key] + return self.discriminator_value_class_map.get(discriminator_value) + +{{/discriminator}} + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, {{classname}}): + return False + + return self.to_dict() == other.to_dict() + + def __ne__(self, other): + """Returns true if both objects are not equal""" + if not isinstance(other, {{classname}}): + return True + + return self.to_dict() != other.to_dict() +{{/model}} +{{/models}}