ruạṛ
a ���fi[ � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ s� 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 dS )� LockboxClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.lockbox.LockboxClient` 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 LockboxClientCompositeOperations object :param LockboxClient client: The service client which will be wrapped by this object N)�client)�selfr �kwargs� r �S/usr/lib/python3.9/site-packages/oci/lockbox/lockbox_client_composite_operations.py�__init__ s z)LockboxClientCompositeOperations.__init__c 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.lockbox.LockboxClient.create_access_request` and waits for the :py:class:`~oci.lockbox.models.WorkRequest` to enter the given state(s). :param oci.lockbox.models.CreateAccessRequestDetails create_access_request_details: (required) Details for the new access request. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.create_access_request` :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>1 � z]LockboxClientCompositeOperations.create_access_request_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 z[LockboxClientCompositeOperations.create_access_request_and_wait_for_state.<locals>.<lambda>�Zpartial_results�causeN) r Zcreate_access_request�headers�oci� wait_until�get_work_request� Exception� exceptions�CompositeOperationError) r Z create_access_request_details�wait_for_states�operation_kwargs� waiter_kwargs�operation_result�wait_for_resource_id� waiter_result�result_to_return�er r r �(create_access_request_and_wait_for_state s( � ��zILockboxClientCompositeOperations.create_access_request_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.lockbox.LockboxClient.create_approval_template` and waits for the :py:class:`~oci.lockbox.models.ApprovalTemplate` acted upon to enter the given state(s). :param oci.lockbox.models.CreateApprovalTemplateDetails create_approval_template_details: (required) Details for the new approval template. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.ApprovalTemplate.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.create_approval_template` :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 X r z`LockboxClientCompositeOperations.create_approval_template_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S �NZlifecycle_stater r r r r r _ r z^LockboxClientCompositeOperations.create_approval_template_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_approval_templater �idr r �get_approval_template� NameError� TypeError�argsr# r$ r" ) r Z create_approval_template_detailsr% r& r' r( �approval_template_idr* r+ r, r r r �+create_approval_template_and_wait_for_stateC s. � �� &zLLockboxClientCompositeOperations.create_approval_template_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.lockbox.LockboxClient.create_lockbox` and waits for the :py:class:`~oci.lockbox.models.Lockbox` acted upon to enter the given state(s). :param oci.lockbox.models.CreateLockboxDetails create_lockbox_details: (required) Details for the new Lockbox. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.Lockbox.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.create_lockbox` :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 zVLockboxClientCompositeOperations.create_lockbox_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r. r r r r r r � r zTLockboxClientCompositeOperations.create_lockbox_and_wait_for_state.<locals>.<lambda>r/ r1 r N) r Zcreate_lockboxr r2 r r � get_lockboxr4 r5 r6 r# r$ r" ) r Zcreate_lockbox_detailsr% r& r' r( � lockbox_idr* r+ r, r r r �!create_lockbox_and_wait_for_statem s. � �� &zBLockboxClientCompositeOperations.create_lockbox_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.lockbox.LockboxClient.delete_approval_template` and waits for the :py:class:`~oci.lockbox.models.ApprovalTemplate` acted upon to enter the given state(s). :param str approval_template_id: (required) The unique identifier (OCID) of the approval template. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.ApprovalTemplate.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.delete_approval_template` :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`LockboxClientCompositeOperations.delete_approval_template_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_approval_template, 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 r. r r r r r r � r z^LockboxClientCompositeOperations.delete_approval_template_and_wait_for_state.<locals>.<lambda>r/ r1 r )r r3 Zdelete_approval_templater r# � ServiceErrorr r � base_client�logger�warningr r4 r5 r6 r$ r" ) r r7 r% r& r' �initial_get_resultr( r, r* r+ r r r �+delete_approval_template_and_wait_for_state� s@ � �� &zLLockboxClientCompositeOperations.delete_approval_template_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.lockbox.LockboxClient.delete_lockbox` and waits for the :py:class:`~oci.lockbox.models.Lockbox` acted upon to enter the given state(s). :param str lockbox_id: (required) unique Lockbox identifier :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.Lockbox.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.delete_lockbox` :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 Nr< c S s g | ] }|� � �qS r r r r r r r � r zVLockboxClientCompositeOperations.delete_lockbox_and_wait_for_state.<locals>.<listcomp>r= Fz�The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_lockbox, 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 r. r r r r r r � r zTLockboxClientCompositeOperations.delete_lockbox_and_wait_for_state.<locals>.<lambda>r/ r1 r )r r9 Zdelete_lockboxr r# r> r r r? r@ rA r r4 r5 r6 r$ r" ) r r: r% r& r' rB r( r, r* r+ r r r �!delete_lockbox_and_wait_for_state� s@ � �� &zBLockboxClientCompositeOperations.delete_lockbox_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 ) aj Calls :py:func:`~oci.lockbox.LockboxClient.handle_access_request` and waits for the :py:class:`~oci.lockbox.models.WorkRequest` to enter the given state(s). :param str access_request_id: (required) The unique identifier (OCID) of the access request. :param oci.lockbox.models.HandleAccessRequestDetails handle_access_request_details: (required) The details of handling access request :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.handle_access_request` :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]LockboxClientCompositeOperations.handle_access_request_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[LockboxClientCompositeOperations.handle_access_request_and_wait_for_state.<locals>.<lambda>r N) r Zhandle_access_requestr r r r! r" r# r$ ) r Zaccess_request_idZ handle_access_request_detailsr% r& r' r( r) r* r+ r, r r r �(handle_access_request_and_wait_for_state s( � ��zILockboxClientCompositeOperations.handle_access_request_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.lockbox.LockboxClient.update_approval_template` and waits for the :py:class:`~oci.lockbox.models.ApprovalTemplate` acted upon to enter the given state(s). :param str approval_template_id: (required) The unique identifier (OCID) of the approval template. :param oci.lockbox.models.UpdateApprovalTemplateDetails update_approval_template_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.ApprovalTemplate.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.update_approval_template` :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 O r z`LockboxClientCompositeOperations.update_approval_template_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r. r r r r r r V r z^LockboxClientCompositeOperations.update_approval_template_and_wait_for_state.<locals>.<lambda>r/ r1 r N) r Zupdate_approval_templater r2 r r r3 r4 r5 r6 r# r$ r" ) r r7 Z update_approval_template_detailsr% r& r' r( r* r+ r, r r r �+update_approval_template_and_wait_for_state7 s. � �� &zLLockboxClientCompositeOperations.update_approval_template_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 ) a2 Calls :py:func:`~oci.lockbox.LockboxClient.update_lockbox` and waits for the :py:class:`~oci.lockbox.models.Lockbox` acted upon to enter the given state(s). :param str lockbox_id: (required) unique Lockbox identifier :param oci.lockbox.models.UpdateLockboxDetails update_lockbox_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.lockbox.models.Lockbox.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.lockbox.LockboxClient.update_lockbox` :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 zVLockboxClientCompositeOperations.update_lockbox_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r. r r r r r r � r zTLockboxClientCompositeOperations.update_lockbox_and_wait_for_state.<locals>.<lambda>r/ r1 r N) r Zupdate_lockboxr r2 r r r9 r4 r5 r6 r# r$ r" ) r r: Zupdate_lockbox_detailsr% r& r' r( r* r+ r, r r r �!update_lockbox_and_wait_for_stated s. � �� &zBLockboxClientCompositeOperations.update_lockbox_and_wait_for_stateN) �__name__� __module__� __qualname__�__doc__r r- r8 r; rC rD rE rF rG r r r r r s '**;;*-r )r Zoci.utilr �objectr r r r r �<module> s
cải xoăn