Aurora
Adminer
Auto Root
WP Admin
cPanel Reset
Anti Backdoor
Root
lib
python3.9
site-packages
oci
lockbox
__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: lockbox_client_composite_operations.cpython-39.pyc
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