Aurora
Adminer
Auto Root
WP Admin
cPanel Reset
Anti Backdoor
Root
lib
python3.9
site-packages
oci
data_flow
__pycache__
Upload
New Folder
New File
Name
Size
Permissions
Actions
..
-
-
-
Upload File
Select File
New Folder
Folder Name
New File
File Name
Add WordPress Admin
Database Host
Database Name
Database User
Database Password
Admin Username
Admin Password
cPanel Password Reset
Email Address
Edit: data_flow_client_composite_operations.cpython-39.pyc
a ���f�� � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ sX e Zd ZdZdd� Zg i i fdd�Zg i i fdd�Zg i i fdd �Zg i i fd d �Zg i i fd d �Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Zg i i fdd�Zg i i fdd�Zg i i fd d �Zg i i fd d �Zg i i fd d!�Zg i i fd"d#�Zg i i fd$d%�Zg i i fd&d'�Zg i i fd(d)�Zg i i fd*d+�Zd,S )-�!DataFlowClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.data_flow.DataFlowClient` and offers convenience methods for operations that would otherwise need to be chained together. For example, instead of performing an action on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource to enter a given state, you can call a single method in this class to accomplish the same functionality c K s || _ dS )z� Creates a new DataFlowClientCompositeOperations object :param DataFlowClient client: The service client which will be wrapped by this object N)�client)�selfr �kwargs� r �W/usr/lib/python3.9/site-packages/oci/data_flow/data_flow_client_composite_operations.py�__init__ s z*DataFlowClientCompositeOperations.__init__c s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.change_private_endpoint_compartment` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param str private_endpoint_id: (required) The unique ID for a private endpoint. :param oci.data_flow.models.ChangePrivateEndpointCompartmentDetails change_private_endpoint_compartment_details: (required) Details for changing a private endpoint's compartment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.change_private_endpoint_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r ��lower��.0�wr r r � <listcomp>4 � zlDataFlowClientCompositeOperations.change_private_endpoint_compartment_and_wait_for_state.<locals>.<listcomp>�opc-work-request-id�evaluate_responsec s t | jd�o t | jd��� � v S �N�status��getattr�datar ��r�Zlowered_wait_for_statesr r �<lambda>= r zjDataFlowClientCompositeOperations.change_private_endpoint_compartment_and_wait_for_state.<locals>.<lambda>�Zpartial_results�causeN) r Z#change_private_endpoint_compartment�headers�oci� wait_until�get_work_request� Exception� exceptions�CompositeOperationError) r �private_endpoint_idZ+change_private_endpoint_compartment_details�wait_for_states�operation_kwargs� waiter_kwargs�operation_result�wait_for_resource_id� waiter_result�result_to_return�er r r �6change_private_endpoint_compartment_and_wait_for_state s( � ��zXDataFlowClientCompositeOperations.change_private_endpoint_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.change_sql_endpoint_compartment` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param str sql_endpoint_id: (required) The unique id of the SQL Endpoint. :param oci.data_flow.models.ChangeSqlEndpointCompartmentDetails change_sql_endpoint_compartment_details: (required) The details to change the compartment of the Sql Endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.change_sql_endpoint_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ^ r zhDataFlowClientCompositeOperations.change_sql_endpoint_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r g r zfDataFlowClientCompositeOperations.change_sql_endpoint_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z change_sql_endpoint_compartmentr r r r! r" r# r$ ) r �sql_endpoint_idZ'change_sql_endpoint_compartment_detailsr& r' r( r) r* r+ r, r- r r r �2change_sql_endpoint_compartment_and_wait_for_stateF s( � ��zTDataFlowClientCompositeOperations.change_sql_endpoint_compartment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.data_flow.DataFlowClient.create_application` and waits for the :py:class:`~oci.data_flow.models.Application` acted upon to enter the given state(s). :param oci.data_flow.models.CreateApplicationDetails create_application_details: (required) Details to create an application. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Application.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.create_application` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z[DataFlowClientCompositeOperations.create_application_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S �NZlifecycle_stater r r r r r � r zYDataFlowClientCompositeOperations.create_application_and_wait_for_state.<locals>.<lambda>�� �a This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"r N) r Zcreate_applicationr �idr r �get_application� NameError� TypeError�argsr# r$ r" ) r Zcreate_application_detailsr& r' r( r) �application_idr+ r, r- r r r �%create_application_and_wait_for_statep s. � �� &zGDataFlowClientCompositeOperations.create_application_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.create_pool` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param oci.data_flow.models.CreatePoolDetails create_pool_details: (required) The parameter required to create a pool. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.create_pool` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zTDataFlowClientCompositeOperations.create_pool_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zRDataFlowClientCompositeOperations.create_pool_and_wait_for_state.<locals>.<lambda>r N) r Z create_poolr r r r! r" r# r$ ) r Zcreate_pool_detailsr& r' r( r) r* r+ r, r- r r r � create_pool_and_wait_for_state� s( � ��z@DataFlowClientCompositeOperations.create_pool_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_flow.DataFlowClient.create_private_endpoint` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param oci.data_flow.models.CreatePrivateEndpointDetails create_private_endpoint_details: (required) The parameters required to create a private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.create_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z`DataFlowClientCompositeOperations.create_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataFlowClientCompositeOperations.create_private_endpoint_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_private_endpointr r r r! r" r# r$ ) r Z create_private_endpoint_detailsr& r' r( r) r* r+ r, r- r r r �*create_private_endpoint_and_wait_for_state� s( � ��zLDataFlowClientCompositeOperations.create_private_endpoint_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.create_run` and waits for the :py:class:`~oci.data_flow.models.Run` acted upon to enter the given state(s). :param oci.data_flow.models.CreateRunDetails create_run_details: (required) Details for creating a run of an application. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Run.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.create_run` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zSDataFlowClientCompositeOperations.create_run_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r r zQDataFlowClientCompositeOperations.create_run_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Z create_runr r5 r r �get_runr7 r8 r9 r# r$ r" ) r Zcreate_run_detailsr& r' r( r) �run_idr+ r, r- r r r � create_run_and_wait_for_state� s. � �� &z?DataFlowClientCompositeOperations.create_run_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.create_sql_endpoint` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param oci.data_flow.models.CreateSqlEndpointDetails create_sql_endpoint_details: (required) Details of the new Sql Endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.create_sql_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ' r z\DataFlowClientCompositeOperations.create_sql_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 0 r zZDataFlowClientCompositeOperations.create_sql_endpoint_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_sql_endpointr r r r! r" r# r$ ) r Zcreate_sql_endpoint_detailsr& r' r( r) r* r+ r, r- r r r �&create_sql_endpoint_and_wait_for_state s( � ��zHDataFlowClientCompositeOperations.create_sql_endpoint_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) aI Calls :py:func:`~oci.data_flow.DataFlowClient.create_statement` and waits for the :py:class:`~oci.data_flow.models.Statement` acted upon to enter the given state(s). :param oci.data_flow.models.CreateStatementDetails create_statement_details: (required) Details for creating a statement. :param str run_id: (required) The unique ID for the run :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Statement.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.create_statement` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r Q r zYDataFlowClientCompositeOperations.create_statement_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r X r zWDataFlowClientCompositeOperations.create_statement_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zcreate_statementr r5 r r Z get_statementr7 r8 r9 r# r$ r" ) r Zcreate_statement_detailsr? r& r' r( r) Z statement_idr+ r, r- r r r �#create_statement_and_wait_for_state9 s. � �� &zEDataFlowClientCompositeOperations.create_statement_and_wait_for_statec sr | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� zZd|v r�|d du r�| j jj � d� nd|d< tj | j |fd � fd d �i|��}|} | W S t t f�y6 } z8|j�sd |_|jd |_tjj|g|d��W Y d}~n@d}~0 t�yl } z tjj|g|d��W Y d}~n d}~0 0 dS )a� Calls :py:func:`~oci.data_flow.DataFlowClient.delete_application` and waits for the :py:class:`~oci.data_flow.models.Application` acted upon to enter the given state(s). :param str application_id: (required) The unique ID for an application. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Application.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.delete_application` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait N� c S s g | ] }|� � �qS r r r r r r r � r z[DataFlowClientCompositeOperations.delete_application_and_wait_for_state.<locals>.<listcomp>�succeed_on_not_foundFz�The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_application, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intendedTr c s t | jd�o t | jd��� � v S r1 r r r r r r � r zYDataFlowClientCompositeOperations.delete_application_and_wait_for_state.<locals>.<lambda>r2 r4 r )r r6 Zdelete_applicationr r# � ServiceErrorr r � base_client�logger�warningr r7 r8 r9 r$ r" ) r r: r& r' r( �initial_get_resultr) r- r+ r, r r r �%delete_application_and_wait_for_statef s@ � �� &zGDataFlowClientCompositeOperations.delete_application_and_wait_for_statec sr | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� zZd|v r�|d du r�| j jj � d� nd|d< tj | j |fd � fd d �i|��}|} | W S t t f�y6 } z8|j�sd |_|jd |_tjj|g|d��W Y d}~n@d}~0 t�yl } z tjj|g|d��W Y d}~n d}~0 0 dS )a� Calls :py:func:`~oci.data_flow.DataFlowClient.delete_pool` and waits for the :py:class:`~oci.data_flow.models.Pool` acted upon to enter the given state(s). :param str pool_id: (required) The unique ID for a pool. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Pool.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.delete_pool` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrC c S s g | ] }|� � �qS r r r r r r r � r zTDataFlowClientCompositeOperations.delete_pool_and_wait_for_state.<locals>.<listcomp>rD Fz�The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_pool, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intendedTr c s t | jd�o t | jd��� � v S r1 r r r r r r � r zRDataFlowClientCompositeOperations.delete_pool_and_wait_for_state.<locals>.<lambda>r2 r4 r )r Zget_poolZ delete_poolr r# rE r r rF rG rH r r7 r8 r9 r$ r" ) r �pool_idr& r' r( rI r) r- r+ r, r r r � delete_pool_and_wait_for_state� s@ � �� &z@DataFlowClientCompositeOperations.delete_pool_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.delete_private_endpoint` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param str private_endpoint_id: (required) The unique ID for a private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.delete_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrC c S s g | ] }|� � �qS r r r r r r r � r z`DataFlowClientCompositeOperations.delete_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z^DataFlowClientCompositeOperations.delete_private_endpoint_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_private_endpointr r# rE r r r r r! r" r$ ) r r% r& r' r( r) r- r* r+ r, r r r �*delete_private_endpoint_and_wait_for_state� s4 � ��zLDataFlowClientCompositeOperations.delete_private_endpoint_and_wait_for_statec sr | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� zZd|v r�|d du r�| j jj � d� nd|d< tj | j |fd � fd d �i|��}|} | W S t t f�y6 } z8|j�sd |_|jd |_tjj|g|d��W Y d}~n@d}~0 t�yl } z tjj|g|d��W Y d}~n d}~0 0 dS )a� Calls :py:func:`~oci.data_flow.DataFlowClient.delete_run` and waits for the :py:class:`~oci.data_flow.models.Run` acted upon to enter the given state(s). :param str run_id: (required) The unique ID for the run :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Run.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.delete_run` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrC c S s g | ] }|� � �qS r r r r r r r ) r zSDataFlowClientCompositeOperations.delete_run_and_wait_for_state.<locals>.<listcomp>rD Fz�The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_run, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intendedTr c s t | jd�o t | jd��� � v S r1 r r r r r r 8 r zQDataFlowClientCompositeOperations.delete_run_and_wait_for_state.<locals>.<lambda>r2 r4 r )r r> Z delete_runr r# rE r r rF rG rH r r7 r8 r9 r$ r" ) r r? r& r' r( rI r) r- r+ r, r r r � delete_run_and_wait_for_state s@ � �� &z?DataFlowClientCompositeOperations.delete_run_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.delete_sql_endpoint` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param str sql_endpoint_id: (required) The unique id of the SQL Endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.delete_sql_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrC c S s g | ] }|� � �qS r r r r r r r c r z\DataFlowClientCompositeOperations.delete_sql_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r l r zZDataFlowClientCompositeOperations.delete_sql_endpoint_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_sql_endpointr r# rE r r r r r! r" r$ ) r r/ r& r' r( r) r- r* r+ r, r r r �&delete_sql_endpoint_and_wait_for_stateF s4 � ��zHDataFlowClientCompositeOperations.delete_sql_endpoint_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.start_pool` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param str pool_id: (required) The unique ID for a pool. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.start_pool` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zSDataFlowClientCompositeOperations.start_pool_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zQDataFlowClientCompositeOperations.start_pool_and_wait_for_state.<locals>.<lambda>r N) r Z start_poolr r r r! r" r# r$ � r rK r& r' r( r) r* r+ r, r- r r r � start_pool_and_wait_for_stateu s( � ��z?DataFlowClientCompositeOperations.start_pool_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_flow.DataFlowClient.stop_pool` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param str pool_id: (required) The unique ID for a pool. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.stop_pool` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zRDataFlowClientCompositeOperations.stop_pool_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zPDataFlowClientCompositeOperations.stop_pool_and_wait_for_state.<locals>.<lambda>r N) r Z stop_poolr r r r! r" r# r$ rP r r r � stop_pool_and_wait_for_state� s( � ��z>DataFlowClientCompositeOperations.stop_pool_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) ah Calls :py:func:`~oci.data_flow.DataFlowClient.update_application` and waits for the :py:class:`~oci.data_flow.models.Application` acted upon to enter the given state(s). :param oci.data_flow.models.UpdateApplicationDetails update_application_details: (required) Details for updating an application. :param str application_id: (required) The unique ID for an application. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Application.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.update_application` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z[DataFlowClientCompositeOperations.update_application_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r � r zYDataFlowClientCompositeOperations.update_application_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zupdate_applicationr r5 r r r6 r7 r8 r9 r# r$ r" ) r Zupdate_application_detailsr: r& r' r( r) r+ r, r- r r r �%update_application_and_wait_for_state� s. � �� &zGDataFlowClientCompositeOperations.update_application_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a! Calls :py:func:`~oci.data_flow.DataFlowClient.update_pool` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param oci.data_flow.models.UpdatePoolDetails update_pool_details: (required) Details for updating a pool. :param str pool_id: (required) The unique ID for a pool. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.update_pool` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zTDataFlowClientCompositeOperations.update_pool_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zRDataFlowClientCompositeOperations.update_pool_and_wait_for_state.<locals>.<lambda>r N) r Z update_poolr r r r! r" r# r$ ) r Zupdate_pool_detailsrK r& r' r( r) r* r+ r, r- r r r � update_pool_and_wait_for_state� s( � ��z@DataFlowClientCompositeOperations.update_pool_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) at Calls :py:func:`~oci.data_flow.DataFlowClient.update_private_endpoint` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param oci.data_flow.models.UpdatePrivateEndpointDetails update_private_endpoint_details: (required) Details for updating a private endpoint. :param str private_endpoint_id: (required) The unique ID for a private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.update_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 2 r z`DataFlowClientCompositeOperations.update_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ; r z^DataFlowClientCompositeOperations.update_private_endpoint_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_private_endpointr r r r! r" r# r$ ) r Z update_private_endpoint_detailsr% r& r' r( r) r* r+ r, r- r r r �*update_private_endpoint_and_wait_for_state s( � ��zLDataFlowClientCompositeOperations.update_private_endpoint_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.data_flow.DataFlowClient.update_run` and waits for the :py:class:`~oci.data_flow.models.Run` acted upon to enter the given state(s). :param oci.data_flow.models.UpdateRunDetails update_run_details: (required) Details for updating a run. :param str run_id: (required) The unique ID for the run :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.Run.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.update_run` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r \ r zSDataFlowClientCompositeOperations.update_run_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r c r zQDataFlowClientCompositeOperations.update_run_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Z update_runr r5 r r r> r7 r8 r9 r# r$ r" ) r Zupdate_run_detailsr? r& r' r( r) r+ r, r- r r r � update_run_and_wait_for_stateD s. � �� &z?DataFlowClientCompositeOperations.update_run_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a_ Calls :py:func:`~oci.data_flow.DataFlowClient.update_sql_endpoint` and waits for the :py:class:`~oci.data_flow.models.WorkRequest` to enter the given state(s). :param oci.data_flow.models.UpdateSqlEndpointDetails update_sql_endpoint_details: (required) Details of the Sql Endpoint to be updated. :param str sql_endpoint_id: (required) The unique id of the SQL Endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_flow.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_flow.DataFlowClient.update_sql_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z\DataFlowClientCompositeOperations.update_sql_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZDataFlowClientCompositeOperations.update_sql_endpoint_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_sql_endpointr r r r! r" r# r$ ) r Zupdate_sql_endpoint_detailsr/ r& r' r( r) r* r+ r, r- r r r �&update_sql_endpoint_and_wait_for_stateq s( � ��zHDataFlowClientCompositeOperations.update_sql_endpoint_and_wait_for_stateN)�__name__� __module__� __qualname__�__doc__r r. r0 r; r< r= r@ rA rB rJ rL rM rN rO rQ rR rS rT rU rV rW r r r r r s, ***''*'-;;/;/''-**-r )r Zoci.utilr �objectr r r r r �<module> s