airflow_client/client/api/experimental_api.py - airflow-client-python - Git at Google

 # coding: utf-8

 """
     Airflow API

     Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead.

     The version of the OpenAPI document: 2
     Generated by OpenAPI Generator (https://openapi-generator.tech)

     Do not edit the class manually.
 """  # noqa: E501

 import warnings
 from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated

 from pydantic import Field, StrictFloat, StrictInt, StrictStr
 from typing import Any, List, Optional, Union
 from typing_extensions import Annotated

 from airflow_client.client.api_client import ApiClient, RequestSerialized
 from airflow_client.client.api_response import ApiResponse
 from airflow_client.client.rest import RESTResponseType


 class ExperimentalApi:
     """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) -> None:
         if api_client is None:
             api_client = ApiClient.get_default()
         self.api_client = api_client


     @validate_call
     def wait_dag_run_until_finished(
         self,
         dag_id: StrictStr,
         dag_run_id: StrictStr,
         interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Seconds to wait between dag run state checks")],
         result: Annotated[Optional[List[StrictStr]], Field(description="Collect result XCom from task. Can be set multiple times.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
             Tuple[
                 Annotated[StrictFloat, Field(gt=0)],
                 Annotated[StrictFloat, Field(gt=0)]
             ]
         ] = None,
         _request_auth: Optional[Dict[StrictStr, Any]] = None,
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> object:
         """Experimental: Wait for a dag run to complete, and return task results if requested.

         🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state.

         :param dag_id: (required)
         :type dag_id: str
         :param dag_run_id: (required)
         :type dag_run_id: str
         :param interval: Seconds to wait between dag run state checks (required)
         :type interval: float
         :param result: Collect result XCom from task. Can be set multiple times.
         :type result: List[str]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
         :type _request_timeout: int, tuple(int, int), optional
         :param _request_auth: set to override the auth_settings for an a single
                               request; this effectively ignores the
                               authentication in the spec for a single request.
         :type _request_auth: dict, optional
         :param _content_type: force content-type for the request.
         :type _content_type: str, Optional
         :param _headers: set to override the headers for a single
                          request; this effectively ignores the headers
                          in the spec for a single request.
         :type _headers: dict, optional
         :param _host_index: set to override the host_index for a single
                             request; this effectively ignores the host_index
                             in the spec for a single request.
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501

         _param = self._wait_dag_run_until_finished_serialize(
             dag_id=dag_id,
             dag_run_id=dag_run_id,
             interval=interval,
             result=result,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
             _host_index=_host_index
         )

         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
             '401': "HTTPExceptionResponse",
             '403': "HTTPExceptionResponse",
             '404': "HTTPExceptionResponse",
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
             *_param,
             _request_timeout=_request_timeout
         )
         response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data


     @validate_call
     def wait_dag_run_until_finished_with_http_info(
         self,
         dag_id: StrictStr,
         dag_run_id: StrictStr,
         interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Seconds to wait between dag run state checks")],
         result: Annotated[Optional[List[StrictStr]], Field(description="Collect result XCom from task. Can be set multiple times.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
             Tuple[
                 Annotated[StrictFloat, Field(gt=0)],
                 Annotated[StrictFloat, Field(gt=0)]
             ]
         ] = None,
         _request_auth: Optional[Dict[StrictStr, Any]] = None,
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[object]:
         """Experimental: Wait for a dag run to complete, and return task results if requested.

         🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state.

         :param dag_id: (required)
         :type dag_id: str
         :param dag_run_id: (required)
         :type dag_run_id: str
         :param interval: Seconds to wait between dag run state checks (required)
         :type interval: float
         :param result: Collect result XCom from task. Can be set multiple times.
         :type result: List[str]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
         :type _request_timeout: int, tuple(int, int), optional
         :param _request_auth: set to override the auth_settings for an a single
                               request; this effectively ignores the
                               authentication in the spec for a single request.
         :type _request_auth: dict, optional
         :param _content_type: force content-type for the request.
         :type _content_type: str, Optional
         :param _headers: set to override the headers for a single
                          request; this effectively ignores the headers
                          in the spec for a single request.
         :type _headers: dict, optional
         :param _host_index: set to override the host_index for a single
                             request; this effectively ignores the host_index
                             in the spec for a single request.
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501

         _param = self._wait_dag_run_until_finished_serialize(
             dag_id=dag_id,
             dag_run_id=dag_run_id,
             interval=interval,
             result=result,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
             _host_index=_host_index
         )

         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
             '401': "HTTPExceptionResponse",
             '403': "HTTPExceptionResponse",
             '404': "HTTPExceptionResponse",
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
             *_param,
             _request_timeout=_request_timeout
         )
         response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )


     @validate_call
     def wait_dag_run_until_finished_without_preload_content(
         self,
         dag_id: StrictStr,
         dag_run_id: StrictStr,
         interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Seconds to wait between dag run state checks")],
         result: Annotated[Optional[List[StrictStr]], Field(description="Collect result XCom from task. Can be set multiple times.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
             Tuple[
                 Annotated[StrictFloat, Field(gt=0)],
                 Annotated[StrictFloat, Field(gt=0)]
             ]
         ] = None,
         _request_auth: Optional[Dict[StrictStr, Any]] = None,
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
         """Experimental: Wait for a dag run to complete, and return task results if requested.

         🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state.

         :param dag_id: (required)
         :type dag_id: str
         :param dag_run_id: (required)
         :type dag_run_id: str
         :param interval: Seconds to wait between dag run state checks (required)
         :type interval: float
         :param result: Collect result XCom from task. Can be set multiple times.
         :type result: List[str]
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
         :type _request_timeout: int, tuple(int, int), optional
         :param _request_auth: set to override the auth_settings for an a single
                               request; this effectively ignores the
                               authentication in the spec for a single request.
         :type _request_auth: dict, optional
         :param _content_type: force content-type for the request.
         :type _content_type: str, Optional
         :param _headers: set to override the headers for a single
                          request; this effectively ignores the headers
                          in the spec for a single request.
         :type _headers: dict, optional
         :param _host_index: set to override the host_index for a single
                             request; this effectively ignores the host_index
                             in the spec for a single request.
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501

         _param = self._wait_dag_run_until_finished_serialize(
             dag_id=dag_id,
             dag_run_id=dag_run_id,
             interval=interval,
             result=result,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
             _host_index=_host_index
         )

         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
             '401': "HTTPExceptionResponse",
             '403': "HTTPExceptionResponse",
             '404': "HTTPExceptionResponse",
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
             *_param,
             _request_timeout=_request_timeout
         )
         return response_data.response


     def _wait_dag_run_until_finished_serialize(
         self,
         dag_id,
         dag_run_id,
         interval,
         result,
         _request_auth,
         _content_type,
         _headers,
         _host_index,
     ) -> RequestSerialized:

         _host = None

         _collection_formats: Dict[str, str] = {
             'result': 'multi',
         }

         _path_params: Dict[str, str] = {}
         _query_params: List[Tuple[str, str]] = []
         _header_params: Dict[str, Optional[str]] = _headers or {}
         _form_params: List[Tuple[str, str]] = []
         _files: Dict[
             str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
         ] = {}
         _body_params: Optional[bytes] = None

         # process the path parameters
         if dag_id is not None:
             _path_params['dag_id'] = dag_id
         if dag_run_id is not None:
             _path_params['dag_run_id'] = dag_run_id
         # process the query parameters
         if interval is not None:

             _query_params.append(('interval', interval))

         if result is not None:

             _query_params.append(('result', result))

         # process the header parameters
         # process the form parameters
         # process the body parameter


         # set the HTTP header `Accept`
         if 'Accept' not in _header_params:
             _header_params['Accept'] = self.api_client.select_header_accept(
                 [
                     'application/json',
                     'application/x-ndjson'
                 ]
             )


         # authentication setting
         _auth_settings: List[str] = [
             'OAuth2PasswordBearer',
             'HTTPBearer'
         ]

         return self.api_client.param_serialize(
             method='GET',
             resource_path='/api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/wait',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
             body=_body_params,
             post_params=_form_params,
             files=_files,
             auth_settings=_auth_settings,
             collection_formats=_collection_formats,
             _host=_host,
             _request_auth=_request_auth
         )
	# coding: utf-8

	"""
	Airflow API

	Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead.

	The version of the OpenAPI document: 2
	Generated by OpenAPI Generator (https://openapi-generator.tech)

	Do not edit the class manually.
	""" # noqa: E501

	import warnings
	from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
	from typing import Any, Dict, List, Optional, Tuple, Union
	from typing_extensions import Annotated

	from pydantic import Field, StrictFloat, StrictInt, StrictStr
	from typing import Any, List, Optional, Union
	from typing_extensions import Annotated

	from airflow_client.client.api_client import ApiClient, RequestSerialized
	from airflow_client.client.api_response import ApiResponse
	from airflow_client.client.rest import RESTResponseType


	class ExperimentalApi:
	"""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) -> None:
	if api_client is None:
	api_client = ApiClient.get_default()
	self.api_client = api_client


	@validate_call
	def wait_dag_run_until_finished(
	self,
	dag_id: StrictStr,
	dag_run_id: StrictStr,
	interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Seconds to wait between dag run state checks")],
	result: Annotated[Optional[List[StrictStr]], Field(description="Collect result XCom from task. Can be set multiple times.")] = None,
	_request_timeout: Union[
	None,
	Annotated[StrictFloat, Field(gt=0)],
	Tuple[
	Annotated[StrictFloat, Field(gt=0)],
	Annotated[StrictFloat, Field(gt=0)]
	]
	] = None,
	_request_auth: Optional[Dict[StrictStr, Any]] = None,
	_content_type: Optional[StrictStr] = None,
	_headers: Optional[Dict[StrictStr, Any]] = None,
	_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
	) -> object:
	"""Experimental: Wait for a dag run to complete, and return task results if requested.

	🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state.

	:param dag_id: (required)
	:type dag_id: str
	:param dag_run_id: (required)
	:type dag_run_id: str
	:param interval: Seconds to wait between dag run state checks (required)
	:type interval: float
	:param result: Collect result XCom from task. Can be set multiple times.
	:type result: List[str]
	:param _request_timeout: timeout setting for this request. If one
	number provided, it will be total request
	timeout. It can also be a pair (tuple) of
	(connection, read) timeouts.
	:type _request_timeout: int, tuple(int, int), optional
	:param _request_auth: set to override the auth_settings for an a single
	request; this effectively ignores the
	authentication in the spec for a single request.
	:type _request_auth: dict, optional
	:param _content_type: force content-type for the request.
	:type _content_type: str, Optional
	:param _headers: set to override the headers for a single
	request; this effectively ignores the headers
	in the spec for a single request.
	:type _headers: dict, optional
	:param _host_index: set to override the host_index for a single
	request; this effectively ignores the host_index
	in the spec for a single request.
	:type _host_index: int, optional
	:return: Returns the result object.
	""" # noqa: E501

	_param = self._wait_dag_run_until_finished_serialize(
	dag_id=dag_id,
	dag_run_id=dag_run_id,
	interval=interval,
	result=result,
	_request_auth=_request_auth,
	_content_type=_content_type,
	_headers=_headers,
	_host_index=_host_index
	)

	_response_types_map: Dict[str, Optional[str]] = {
	'200': "object",
	'401': "HTTPExceptionResponse",
	'403': "HTTPExceptionResponse",
	'404': "HTTPExceptionResponse",
	'422': "HTTPValidationError",
	}
	response_data = self.api_client.call_api(
	*_param,
	_request_timeout=_request_timeout
	)
	response_data.read()
	return self.api_client.response_deserialize(
	response_data=response_data,
	response_types_map=_response_types_map,
	).data


	@validate_call
	def wait_dag_run_until_finished_with_http_info(
	self,
	dag_id: StrictStr,
	dag_run_id: StrictStr,
	interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Seconds to wait between dag run state checks")],
	result: Annotated[Optional[List[StrictStr]], Field(description="Collect result XCom from task. Can be set multiple times.")] = None,
	_request_timeout: Union[
	None,
	Annotated[StrictFloat, Field(gt=0)],
	Tuple[
	Annotated[StrictFloat, Field(gt=0)],
	Annotated[StrictFloat, Field(gt=0)]
	]
	] = None,
	_request_auth: Optional[Dict[StrictStr, Any]] = None,
	_content_type: Optional[StrictStr] = None,
	_headers: Optional[Dict[StrictStr, Any]] = None,
	_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
	) -> ApiResponse[object]:
	"""Experimental: Wait for a dag run to complete, and return task results if requested.

	🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state.

	:param dag_id: (required)
	:type dag_id: str
	:param dag_run_id: (required)
	:type dag_run_id: str
	:param interval: Seconds to wait between dag run state checks (required)
	:type interval: float
	:param result: Collect result XCom from task. Can be set multiple times.
	:type result: List[str]
	:param _request_timeout: timeout setting for this request. If one
	number provided, it will be total request
	timeout. It can also be a pair (tuple) of
	(connection, read) timeouts.
	:type _request_timeout: int, tuple(int, int), optional
	:param _request_auth: set to override the auth_settings for an a single
	request; this effectively ignores the
	authentication in the spec for a single request.
	:type _request_auth: dict, optional
	:param _content_type: force content-type for the request.
	:type _content_type: str, Optional
	:param _headers: set to override the headers for a single
	request; this effectively ignores the headers
	in the spec for a single request.
	:type _headers: dict, optional
	:param _host_index: set to override the host_index for a single
	request; this effectively ignores the host_index
	in the spec for a single request.
	:type _host_index: int, optional
	:return: Returns the result object.
	""" # noqa: E501

	_param = self._wait_dag_run_until_finished_serialize(
	dag_id=dag_id,
	dag_run_id=dag_run_id,
	interval=interval,
	result=result,
	_request_auth=_request_auth,
	_content_type=_content_type,
	_headers=_headers,
	_host_index=_host_index
	)

	_response_types_map: Dict[str, Optional[str]] = {
	'200': "object",
	'401': "HTTPExceptionResponse",
	'403': "HTTPExceptionResponse",
	'404': "HTTPExceptionResponse",
	'422': "HTTPValidationError",
	}
	response_data = self.api_client.call_api(
	*_param,
	_request_timeout=_request_timeout
	)
	response_data.read()
	return self.api_client.response_deserialize(
	response_data=response_data,
	response_types_map=_response_types_map,
	)


	@validate_call
	def wait_dag_run_until_finished_without_preload_content(
	self,
	dag_id: StrictStr,
	dag_run_id: StrictStr,
	interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Seconds to wait between dag run state checks")],
	result: Annotated[Optional[List[StrictStr]], Field(description="Collect result XCom from task. Can be set multiple times.")] = None,
	_request_timeout: Union[
	None,
	Annotated[StrictFloat, Field(gt=0)],
	Tuple[
	Annotated[StrictFloat, Field(gt=0)],
	Annotated[StrictFloat, Field(gt=0)]
	]
	] = None,
	_request_auth: Optional[Dict[StrictStr, Any]] = None,
	_content_type: Optional[StrictStr] = None,
	_headers: Optional[Dict[StrictStr, Any]] = None,
	_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
	) -> RESTResponseType:
	"""Experimental: Wait for a dag run to complete, and return task results if requested.

	🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state.

	:param dag_id: (required)
	:type dag_id: str
	:param dag_run_id: (required)
	:type dag_run_id: str
	:param interval: Seconds to wait between dag run state checks (required)
	:type interval: float
	:param result: Collect result XCom from task. Can be set multiple times.
	:type result: List[str]
	:param _request_timeout: timeout setting for this request. If one
	number provided, it will be total request
	timeout. It can also be a pair (tuple) of
	(connection, read) timeouts.
	:type _request_timeout: int, tuple(int, int), optional
	:param _request_auth: set to override the auth_settings for an a single
	request; this effectively ignores the
	authentication in the spec for a single request.
	:type _request_auth: dict, optional
	:param _content_type: force content-type for the request.
	:type _content_type: str, Optional
	:param _headers: set to override the headers for a single
	request; this effectively ignores the headers
	in the spec for a single request.
	:type _headers: dict, optional
	:param _host_index: set to override the host_index for a single
	request; this effectively ignores the host_index
	in the spec for a single request.
	:type _host_index: int, optional
	:return: Returns the result object.
	""" # noqa: E501

	_param = self._wait_dag_run_until_finished_serialize(
	dag_id=dag_id,
	dag_run_id=dag_run_id,
	interval=interval,
	result=result,
	_request_auth=_request_auth,
	_content_type=_content_type,
	_headers=_headers,
	_host_index=_host_index
	)

	_response_types_map: Dict[str, Optional[str]] = {
	'200': "object",
	'401': "HTTPExceptionResponse",
	'403': "HTTPExceptionResponse",
	'404': "HTTPExceptionResponse",
	'422': "HTTPValidationError",
	}
	response_data = self.api_client.call_api(
	*_param,
	_request_timeout=_request_timeout
	)
	return response_data.response


	def _wait_dag_run_until_finished_serialize(
	self,
	dag_id,
	dag_run_id,
	interval,
	result,
	_request_auth,
	_content_type,
	_headers,
	_host_index,
	) -> RequestSerialized:

	_host = None

	_collection_formats: Dict[str, str] = {
	'result': 'multi',
	}

	_path_params: Dict[str, str] = {}
	_query_params: List[Tuple[str, str]] = []
	_header_params: Dict[str, Optional[str]] = _headers or {}
	_form_params: List[Tuple[str, str]] = []
	_files: Dict[
	str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
	] = {}
	_body_params: Optional[bytes] = None

	# process the path parameters
	if dag_id is not None:
	_path_params['dag_id'] = dag_id
	if dag_run_id is not None:
	_path_params['dag_run_id'] = dag_run_id
	# process the query parameters
	if interval is not None:

	_query_params.append(('interval', interval))

	if result is not None:

	_query_params.append(('result', result))

	# process the header parameters
	# process the form parameters
	# process the body parameter


	# set the HTTP header `Accept`
	if 'Accept' not in _header_params:
	_header_params['Accept'] = self.api_client.select_header_accept(
	[
	'application/json',
	'application/x-ndjson'
	]
	)


	# authentication setting
	_auth_settings: List[str] = [
	'OAuth2PasswordBearer',
	'HTTPBearer'
	]

	return self.api_client.param_serialize(
	method='GET',
	resource_path='/api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/wait',
	path_params=_path_params,
	query_params=_query_params,
	header_params=_header_params,
	body=_body_params,
	post_params=_form_params,
	files=_files,
	auth_settings=_auth_settings,
	collection_formats=_collection_formats,
	_host=_host,
	_request_auth=_request_auth
	)