ruạṛ
a N��f@r � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ sZ e Zd ZdZdMdd�Zg i i fdd�Zg i i fdd�Zg i i fd d �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,�Zg i i fd-d.�Zg i i fd/d0�Zg i i fd1d2�Zg i i fd3d4�Z g i i fd5d6�Z g i i fd7d8�Z g i i fd9d:�Z g i i fd;d<�Z g i i fd=d>�Z!g i i fd?d@�Z"g i i fdAdB�Z#g i i fdCdD�Z$g i i fdEdF�Z%g i i fdGdH�Z&g i i fdIdJ�Z'g i i fdKdL�Z(dS )N� ComputeClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.core.ComputeClient` 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 Nc K s0 || _ |r|ntjj| j jfi | j j��| _dS )av Creates a new ComputeClientCompositeOperations object :param ComputeClient client: The service client which will be wrapped by this object :param oci.work_requests.WorkRequestClient work_request_client: (optional) The work request service client which will be used to wait for work request states. Default is None. N)�client�oci� work_requests�WorkRequestClient�_config�_kwargs�_work_request_client)�selfr �work_request_client�kwargs� r ��/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/oci/core/compute_client_composite_operations.py�__init__ s z)ComputeClientCompositeOperations.__init__c 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.core.ComputeClient.attach_boot_volume` and waits for the :py:class:`~oci.core.models.BootVolumeAttachment` acted upon to enter the given state(s). :param oci.core.models.AttachBootVolumeDetails attach_boot_volume_details: (required) Attach boot volume request :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolumeAttachment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.attach_boot_volume` :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 � zZComputeClientCompositeOperations.attach_boot_volume_and_wait_for_state.<locals>.<listcomp>�evaluate_responsec s t | jd�o t | jd��� � v S �N�lifecycle_state��getattr�datar ��r��lowered_wait_for_statesr r �<lambda>; r zXComputeClientCompositeOperations.attach_boot_volume_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"��partial_results�causeN) r �attach_boot_volumer �idr � wait_until�get_boot_volume_attachment� NameError� TypeError�args� exceptions�CompositeOperationError� Exception) r �attach_boot_volume_details�wait_for_states�operation_kwargs� waiter_kwargs�operation_result�boot_volume_attachment_id� waiter_result�result_to_return�er r r �%attach_boot_volume_and_wait_for_state s. � �� &zFComputeClientCompositeOperations.attach_boot_volume_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.core.ComputeClient.attach_vnic` and waits for the :py:class:`~oci.core.models.VnicAttachment` acted upon to enter the given state(s). :param oci.core.models.AttachVnicDetails attach_vnic_details: (required) Attach VNIC details. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VnicAttachment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.attach_vnic` :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 zSComputeClientCompositeOperations.attach_vnic_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" f r zQComputeClientCompositeOperations.attach_vnic_and_wait_for_state.<locals>.<lambda>r# r% r& N) r � attach_vnicr r* r r+ �get_vnic_attachmentr- r. r/ r0 r1 r2 ) r �attach_vnic_detailsr4 r5 r6 r7 �vnic_attachment_idr9 r: r; r r r � attach_vnic_and_wait_for_stateI s. � �� &z?ComputeClientCompositeOperations.attach_vnic_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.core.ComputeClient.attach_volume` and waits for the :py:class:`~oci.core.models.VolumeAttachment` acted upon to enter the given state(s). :param oci.core.models.AttachVolumeDetails attach_volume_details: (required) Attach volume request :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeAttachment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.attach_volume` :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 zUComputeClientCompositeOperations.attach_volume_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" � r zSComputeClientCompositeOperations.attach_volume_and_wait_for_state.<locals>.<lambda>r# r% r& N) r � attach_volumer r* r r+ �get_volume_attachmentr- r. r/ r0 r1 r2 ) r �attach_volume_detailsr4 r5 r6 r7 �volume_attachment_idr9 r: r; r r r � attach_volume_and_wait_for_statet s. � �� &zAComputeClientCompositeOperations.attach_volume_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.core.ComputeClient.capture_console_history` and waits for the :py:class:`~oci.core.models.ConsoleHistory` acted upon to enter the given state(s). :param oci.core.models.CaptureConsoleHistoryDetails capture_console_history_details: (required) Console history details :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.ConsoleHistory.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.capture_console_history` :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_ComputeClientCompositeOperations.capture_console_history_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" � r z]ComputeClientCompositeOperations.capture_console_history_and_wait_for_state.<locals>.<lambda>r# r% r& N) r �capture_console_historyr r* r r+ �get_console_historyr- r. r/ r0 r1 r2 ) r � capture_console_history_detailsr4 r5 r6 r7 �instance_console_history_idr9 r: r; r r r �*capture_console_history_and_wait_for_state� s. � �� &zKComputeClientCompositeOperations.capture_console_history_and_wait_for_statec s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) aT Calls :py:func:`~oci.core.ComputeClient.change_compute_capacity_reservation_compartment` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str capacity_reservation_id: (required) The OCID of the compute capacity reservation. :param oci.core.models.ChangeComputeCapacityReservationCompartmentDetails change_compute_capacity_reservation_compartment_details: (required) The configuration details for the move operation. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.change_compute_capacity_reservation_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 z~ComputeClientCompositeOperations.change_compute_capacity_reservation_compartment_and_wait_for_work_request.<locals>.<listcomp>�opc-work-request-idr c s t | jd�o t | jd��� � v S �N�statusr r ��lowered_work_request_statesr r r" � r z|ComputeClientCompositeOperations.change_compute_capacity_reservation_compartment_and_wait_for_work_request.<locals>.<lambda>r& N) r �/change_compute_capacity_reservation_compartmentr �waiter� _WORK_REQUEST_TERMINATION_STATES�headersr+ r �get_work_requestr2 r0 r1 ) r �capacity_reservation_id�7change_compute_capacity_reservation_compartment_details�work_request_statesr5 r6 r7 �work_request_idr9 r; r rO r �Ichange_compute_capacity_reservation_compartment_and_wait_for_work_request� s � ��zjComputeClientCompositeOperations.change_compute_capacity_reservation_compartment_and_wait_for_work_requestc s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a; Calls :py:func:`~oci.core.ComputeClient.change_dedicated_vm_host_compartment` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str dedicated_vm_host_id: (required) The OCID of the dedicated VM host. :param oci.core.models.ChangeDedicatedVmHostCompartmentDetails change_dedicated_vm_host_compartment_details: (required) The request to move the dedicated virtual machine host to a different compartment. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.change_dedicated_vm_host_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 zsComputeClientCompositeOperations.change_dedicated_vm_host_compartment_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" r zqComputeClientCompositeOperations.change_dedicated_vm_host_compartment_and_wait_for_work_request.<locals>.<lambda>r& N) r �$change_dedicated_vm_host_compartmentr rR rS rT r+ r rU r2 r0 r1 ) r �dedicated_vm_host_id�,change_dedicated_vm_host_compartment_detailsrX r5 r6 r7 rY r9 r; r rO r �>change_dedicated_vm_host_compartment_and_wait_for_work_request� s � ��z_ComputeClientCompositeOperations.change_dedicated_vm_host_compartment_and_wait_for_work_requestc s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) aK Calls :py:func:`~oci.core.ComputeClient.change_instance_compartment` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str instance_id: (required) The `OCID`__ of the instance. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.core.models.ChangeInstanceCompartmentDetails change_instance_compartment_details: (required) Request to change the compartment of a given instance. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.change_instance_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 0 r zjComputeClientCompositeOperations.change_instance_compartment_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" 7 r zhComputeClientCompositeOperations.change_instance_compartment_and_wait_for_work_request.<locals>.<lambda>r& N) r �change_instance_compartmentr rR rS rT r+ r rU r2 r0 r1 ) r � instance_id�#change_instance_compartment_detailsrX r5 r6 r7 rY r9 r; r rO r �5change_instance_compartment_and_wait_for_work_request s � ��zVComputeClientCompositeOperations.change_instance_compartment_and_wait_for_work_requestc s� | j j|fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g|d��W Y d}~n d}~0 0 dS ) a+ Calls :py:func:`~oci.core.ComputeClient.create_compute_capacity_reservation` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param oci.core.models.CreateComputeCapacityReservationDetails create_compute_capacity_reservation_details: (required) Details for creating a new compute capacity reservation. **Caution:** Avoid using any confidential information when you use the API to supply string values. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.create_compute_capacity_reservation` :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 U r zrComputeClientCompositeOperations.create_compute_capacity_reservation_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" \ r zpComputeClientCompositeOperations.create_compute_capacity_reservation_and_wait_for_work_request.<locals>.<lambda>r& N) r �#create_compute_capacity_reservationr rR rS rT r+ r rU r2 r0 r1 ) r �+create_compute_capacity_reservation_detailsrX r5 r6 r7 rY r9 r; r rO r �=create_compute_capacity_reservation_and_wait_for_work_request> s � ��z^ComputeClientCompositeOperations.create_compute_capacity_reservation_and_wait_for_work_requestc 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.core.ComputeClient.create_compute_capacity_reservation` and waits for the :py:class:`~oci.core.models.ComputeCapacityReservation` acted upon to enter the given state(s). :param oci.core.models.CreateComputeCapacityReservationDetails create_compute_capacity_reservation_details: (required) Details for creating a new compute capacity reservation. **Caution:** Avoid using any confidential information when you use the API to supply string values. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.ComputeCapacityReservation.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.create_compute_capacity_reservation` :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 zkComputeClientCompositeOperations.create_compute_capacity_reservation_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" � r ziComputeClientCompositeOperations.create_compute_capacity_reservation_and_wait_for_state.<locals>.<lambda>r# r% r& N) r rc r r* r r+ � get_compute_capacity_reservationr- r. r/ r0 r1 r2 ) r rd r4 r5 r6 r7 rV r9 r: r; r r r �6create_compute_capacity_reservation_and_wait_for_statec s. � �� &zWComputeClientCompositeOperations.create_compute_capacity_reservation_and_wait_for_statec s� | j j|fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g|d��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.create_dedicated_vm_host` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param oci.core.models.CreateDedicatedVmHostDetails create_dedicated_vm_host_details: (required) The details for creating a new dedicated virtual machine host. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.create_dedicated_vm_host` :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 zgComputeClientCompositeOperations.create_dedicated_vm_host_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" � r zeComputeClientCompositeOperations.create_dedicated_vm_host_and_wait_for_work_request.<locals>.<lambda>r& N) r �create_dedicated_vm_hostr rR rS rT r+ r rU r2 r0 r1 ) r � create_dedicated_vm_host_detailsrX r5 r6 r7 rY r9 r; r rO r �2create_dedicated_vm_host_and_wait_for_work_request� s � ��zSComputeClientCompositeOperations.create_dedicated_vm_host_and_wait_for_work_requestc 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.core.ComputeClient.create_dedicated_vm_host` and waits for the :py:class:`~oci.core.models.DedicatedVmHost` acted upon to enter the given state(s). :param oci.core.models.CreateDedicatedVmHostDetails create_dedicated_vm_host_details: (required) The details for creating a new dedicated virtual machine host. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.DedicatedVmHost.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.create_dedicated_vm_host` :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`ComputeClientCompositeOperations.create_dedicated_vm_host_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" � r z^ComputeClientCompositeOperations.create_dedicated_vm_host_and_wait_for_state.<locals>.<lambda>r# r% r& N) r rh r r* r r+ �get_dedicated_vm_hostr- r. r/ r0 r1 r2 ) r ri r4 r5 r6 r7 r\ r9 r: r; r r r �+create_dedicated_vm_host_and_wait_for_state� s. � �� &zLComputeClientCompositeOperations.create_dedicated_vm_host_and_wait_for_statec s� | j j|fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g|d��W Y d}~n d}~0 0 dS ) a> Calls :py:func:`~oci.core.ComputeClient.create_image` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param oci.core.models.CreateImageDetails create_image_details: (required) Image creation details :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.create_image` :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[ComputeClientCompositeOperations.create_image_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" � r zYComputeClientCompositeOperations.create_image_and_wait_for_work_request.<locals>.<lambda>r& N) r � create_imager rR rS rT r+ r rU r2 r0 r1 ) r �create_image_detailsrX r5 r6 r7 rY r9 r; r rO r �&create_image_and_wait_for_work_request� s � ��zGComputeClientCompositeOperations.create_image_and_wait_for_work_requestc 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.core.ComputeClient.create_image` and waits for the :py:class:`~oci.core.models.Image` acted upon to enter the given state(s). :param oci.core.models.CreateImageDetails create_image_details: (required) Image creation details :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Image.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.create_image` :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 zTComputeClientCompositeOperations.create_image_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" r zRComputeClientCompositeOperations.create_image_and_wait_for_state.<locals>.<lambda>r# r% r& N) r rm r r* r r+ � get_imager- r. r/ r0 r1 r2 ) r rn r4 r5 r6 r7 �image_idr9 r: r; r r r � create_image_and_wait_for_state s. � �� &z@ComputeClientCompositeOperations.create_image_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.core.ComputeClient.create_instance_console_connection` and waits for the :py:class:`~oci.core.models.InstanceConsoleConnection` acted upon to enter the given state(s). :param oci.core.models.CreateInstanceConsoleConnectionDetails create_instance_console_connection_details: (required) Request object for creating an InstanceConsoleConnection :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.InstanceConsoleConnection.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.create_instance_console_connection` :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 B r zjComputeClientCompositeOperations.create_instance_console_connection_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" I r zhComputeClientCompositeOperations.create_instance_console_connection_and_wait_for_state.<locals>.<lambda>r# r% r& N) r �"create_instance_console_connectionr r* r r+ � get_instance_console_connectionr- r. r/ r0 r1 r2 ) r �*create_instance_console_connection_detailsr4 r5 r6 r7 � instance_console_connection_idr9 r: r; r r r �5create_instance_console_connection_and_wait_for_state, s. � �� &zVComputeClientCompositeOperations.create_instance_console_connection_and_wait_for_statec s� | j j|fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g|d��W Y d}~n d}~0 0 dS ) ag Calls :py:func:`~oci.core.ComputeClient.delete_compute_capacity_reservation` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str capacity_reservation_id: (required) The OCID of the compute capacity reservation. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.delete_compute_capacity_reservation` :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 l r zrComputeClientCompositeOperations.delete_compute_capacity_reservation_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" s r zpComputeClientCompositeOperations.delete_compute_capacity_reservation_and_wait_for_work_request.<locals>.<lambda>r& N) r �#delete_compute_capacity_reservationr rR rS rT r+ r rU r2 r0 r1 ) r rV rX r5 r6 r7 rY r9 r; r rO r �=delete_compute_capacity_reservation_and_wait_for_work_requestW s � ��z^ComputeClientCompositeOperations.delete_compute_capacity_reservation_and_wait_for_work_requestc sD | 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 �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.delete_console_history` and waits for the :py:class:`~oci.core.models.ConsoleHistory` acted upon to enter the given state(s). :param str instance_console_history_id: (required) The OCID of the console history. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.ConsoleHistory.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.delete_console_history` :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^ComputeClientCompositeOperations.delete_console_history_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r" � r z\ComputeClientCompositeOperations.delete_console_history_and_wait_for_state.<locals>.<lambda>T�r �succeed_on_not_foundr# r% r& )r rH �delete_console_historyr r0 � ServiceErrorrN r r+ r- r. r/ r1 r2 ) r rJ r4 r5 r6 �initial_get_resultr7 r; r9 r: r r r �)delete_console_history_and_wait_for_statez s< � �� &zJComputeClientCompositeOperations.delete_console_history_and_wait_for_statec s� | j j|fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g|d��W Y d}~n d}~0 0 dS ) aC Calls :py:func:`~oci.core.ComputeClient.delete_dedicated_vm_host` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str dedicated_vm_host_id: (required) The OCID of the dedicated VM host. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.delete_dedicated_vm_host` :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 zgComputeClientCompositeOperations.delete_dedicated_vm_host_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" � r zeComputeClientCompositeOperations.delete_dedicated_vm_host_and_wait_for_work_request.<locals>.<lambda>r& N) r �delete_dedicated_vm_hostr rR rS rT r+ r rU r2 r0 r1 ) r r\ rX r5 r6 r7 rY r9 r; r rO r �2delete_dedicated_vm_host_and_wait_for_work_request� s � ��zSComputeClientCompositeOperations.delete_dedicated_vm_host_and_wait_for_work_requestc sD | 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 �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.delete_image` and waits for the :py:class:`~oci.core.models.Image` acted upon to enter the given state(s). :param str image_id: (required) The `OCID`__ of the image. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Image.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.delete_image` :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 Nrz c S s g | ] }|� � �qS r r r r r r r � r zTComputeClientCompositeOperations.delete_image_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r" � r zRComputeClientCompositeOperations.delete_image_and_wait_for_state.<locals>.<lambda>Tr{ r# r% r& )r rp � delete_imager r0 r~ rN r r+ r- r. r/ r1 r2 ) r rq r4 r5 r6 r r7 r; r9 r: r r r � delete_image_and_wait_for_state� s< � �� &z@ComputeClientCompositeOperations.delete_image_and_wait_for_statec sD | 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 �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.core.ComputeClient.delete_instance_console_connection` and waits for the :py:class:`~oci.core.models.InstanceConsoleConnection` acted upon to enter the given state(s). :param str instance_console_connection_id: (required) The OCID of the instance console connection. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.InstanceConsoleConnection.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.delete_instance_console_connection` :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 Nrz c S s g | ] }|� � �qS r r r r r r r & r zjComputeClientCompositeOperations.delete_instance_console_connection_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r" , r zhComputeClientCompositeOperations.delete_instance_console_connection_and_wait_for_state.<locals>.<lambda>Tr{ r# r% r& )r rt �"delete_instance_console_connectionr r0 r~ rN r r+ r- r. r/ r1 r2 ) r rv r4 r5 r6 r r7 r; r9 r: r r r �5delete_instance_console_connection_and_wait_for_state s< � �� &zVComputeClientCompositeOperations.delete_instance_console_connection_and_wait_for_statec sD | 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 �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.detach_boot_volume` and waits for the :py:class:`~oci.core.models.BootVolumeAttachment` acted upon to enter the given state(s). :param str boot_volume_attachment_id: (required) The OCID of the boot volume attachment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolumeAttachment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.detach_boot_volume` :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 Nrz c S s g | ] }|� � �qS r r r r r r r Z r zZComputeClientCompositeOperations.detach_boot_volume_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r" ` r zXComputeClientCompositeOperations.detach_boot_volume_and_wait_for_state.<locals>.<lambda>Tr{ r# r% r& )r r, �detach_boot_volumer r0 r~ rN r r+ r- r. r/ r1 r2 ) r r8 r4 r5 r6 r r7 r; r9 r: r r r �%detach_boot_volume_and_wait_for_state; s< � �� &zFComputeClientCompositeOperations.detach_boot_volume_and_wait_for_statec sD | 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 �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.detach_vnic` and waits for the :py:class:`~oci.core.models.VnicAttachment` acted upon to enter the given state(s). :param str vnic_attachment_id: (required) The OCID of the VNIC attachment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VnicAttachment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.detach_vnic` :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 Nrz c S s g | ] }|� � �qS r r r r r r r � r zSComputeClientCompositeOperations.detach_vnic_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r" � r zQComputeClientCompositeOperations.detach_vnic_and_wait_for_state.<locals>.<lambda>Tr{ r# r% r& )r r> � detach_vnicr r0 r~ rN r r+ r- r. r/ r1 r2 ) r r@ r4 r5 r6 r r7 r; r9 r: r r r � detach_vnic_and_wait_for_stateo s< � �� &z?ComputeClientCompositeOperations.detach_vnic_and_wait_for_statec sD | 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 �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.detach_volume` and waits for the :py:class:`~oci.core.models.VolumeAttachment` acted upon to enter the given state(s). :param str volume_attachment_id: (required) The OCID of the volume attachment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeAttachment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.detach_volume` :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 Nrz c S s g | ] }|� � �qS r r r r r r r � r zUComputeClientCompositeOperations.detach_volume_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r" � r zSComputeClientCompositeOperations.detach_volume_and_wait_for_state.<locals>.<lambda>Tr{ r# r% r& )r rC � detach_volumer r0 r~ rN r r+ r- r. r/ r1 r2 ) r rE r4 r5 r6 r r7 r; r9 r: r r r � detach_volume_and_wait_for_state� s< � �� &zAComputeClientCompositeOperations.detach_volume_and_wait_for_statec s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.export_image` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str image_id: (required) The `OCID`__ of the image. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.core.models.ExportImageDetails export_image_details: (required) Details for the image export. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.export_image` :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[ComputeClientCompositeOperations.export_image_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" � r zYComputeClientCompositeOperations.export_image_and_wait_for_work_request.<locals>.<lambda>r& N) r � export_imager rR rS rT r+ r rU r2 r0 r1 ) r rq �export_image_detailsrX r5 r6 r7 rY r9 r; r rO r �&export_image_and_wait_for_work_request� s � ��zGComputeClientCompositeOperations.export_image_and_wait_for_work_requestc 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 ) aq Calls :py:func:`~oci.core.ComputeClient.export_image` and waits for the :py:class:`~oci.core.models.Image` acted upon to enter the given state(s). :param str image_id: (required) The `OCID`__ of the image. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.core.models.ExportImageDetails export_image_details: (required) Details for the image export. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Image.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.export_image` :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 zTComputeClientCompositeOperations.export_image_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" ! r zRComputeClientCompositeOperations.export_image_and_wait_for_state.<locals>.<lambda>r# r% r& N) r r� r r* r r+ rp r- r. r/ r0 r1 r2 ) r rq r� r4 r5 r6 r7 r9 r: r; r r r � export_image_and_wait_for_state� s. � �� &z@ComputeClientCompositeOperations.export_image_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.core.ComputeClient.instance_action` and waits for the :py:class:`~oci.core.models.Instance` acted upon to enter the given state(s). :param str instance_id: (required) The `OCID`__ of the instance. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param str action: (required) The action to perform on the instance. Allowed values are: "STOP", "START", "SOFTRESET", "RESET", "SOFTSTOP", "SENDDIAGNOSTICINTERRUPT", "DIAGNOSTICREBOOT", "REBOOTMIGRATE" :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Instance.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.instance_action` :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 L r zWComputeClientCompositeOperations.instance_action_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" S r zUComputeClientCompositeOperations.instance_action_and_wait_for_state.<locals>.<lambda>r# r% r& N) r �instance_actionr r* r r+ � get_instancer- r. r/ r0 r1 r2 ) r r` �actionr4 r5 r6 r7 r9 r: r; r r r �"instance_action_and_wait_for_state/ s. � �� &zCComputeClientCompositeOperations.instance_action_and_wait_for_statec s� | j j|fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g|d��W Y d}~n d}~0 0 dS ) aD Calls :py:func:`~oci.core.ComputeClient.launch_instance` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param oci.core.models.LaunchInstanceDetails launch_instance_details: (required) Instance details :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.launch_instance` :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 v r z^ComputeClientCompositeOperations.launch_instance_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" } r z\ComputeClientCompositeOperations.launch_instance_and_wait_for_work_request.<locals>.<lambda>r& N) r �launch_instancer rR rS rT r+ r rU r2 r0 r1 ) r �launch_instance_detailsrX r5 r6 r7 rY r9 r; r rO r �)launch_instance_and_wait_for_work_requesta s � ��zJComputeClientCompositeOperations.launch_instance_and_wait_for_work_requestc 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.core.ComputeClient.launch_instance` and waits for the :py:class:`~oci.core.models.Instance` acted upon to enter the given state(s). :param oci.core.models.LaunchInstanceDetails launch_instance_details: (required) Instance details :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Instance.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.launch_instance` :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 zWComputeClientCompositeOperations.launch_instance_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" � r zUComputeClientCompositeOperations.launch_instance_and_wait_for_state.<locals>.<lambda>r# r% r& N) r r� r r* r r+ r� r- r. r/ r0 r1 r2 ) r r� r4 r5 r6 r7 r` r9 r: r; r r r �"launch_instance_and_wait_for_state� s. � �� &zCComputeClientCompositeOperations.launch_instance_and_wait_for_statec sD | 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 �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.core.ComputeClient.terminate_instance` and waits for the :py:class:`~oci.core.models.Instance` acted upon to enter the given state(s). :param str instance_id: (required) The `OCID`__ of the instance. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Instance.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.terminate_instance` :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 Nrz c S s g | ] }|� � �qS r r r r r r r � r zZComputeClientCompositeOperations.terminate_instance_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r" � r zXComputeClientCompositeOperations.terminate_instance_and_wait_for_state.<locals>.<lambda>Tr{ r# r% r& )r r� �terminate_instancer r0 r~ rN r r+ r- r. r/ r1 r2 ) r r` r4 r5 r6 r r7 r; r9 r: r r r �%terminate_instance_and_wait_for_state� s< � �� &zFComputeClientCompositeOperations.terminate_instance_and_wait_for_statec s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.core.ComputeClient.update_compute_capacity_reservation` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str capacity_reservation_id: (required) The OCID of the compute capacity reservation. :param oci.core.models.UpdateComputeCapacityReservationDetails update_compute_capacity_reservation_details: (required) Update compute capacity reservation details. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_compute_capacity_reservation` :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 zrComputeClientCompositeOperations.update_compute_capacity_reservation_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" r zpComputeClientCompositeOperations.update_compute_capacity_reservation_and_wait_for_work_request.<locals>.<lambda>r& N) r �#update_compute_capacity_reservationr rR rS rT r+ r rU r2 r0 r1 ) r rV �+update_compute_capacity_reservation_detailsrX r5 r6 r7 rY r9 r; r rO r �=update_compute_capacity_reservation_and_wait_for_work_request� s � ��z^ComputeClientCompositeOperations.update_compute_capacity_reservation_and_wait_for_work_requestc 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.core.ComputeClient.update_console_history` and waits for the :py:class:`~oci.core.models.ConsoleHistory` acted upon to enter the given state(s). :param str instance_console_history_id: (required) The OCID of the console history. :param oci.core.models.UpdateConsoleHistoryDetails update_console_history_details: (required) Update instance fields :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.ConsoleHistory.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_console_history` :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^ComputeClientCompositeOperations.update_console_history_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" + r z\ComputeClientCompositeOperations.update_console_history_and_wait_for_state.<locals>.<lambda>r# r% r& N) r �update_console_historyr r* r r+ rH r- r. r/ r0 r1 r2 ) r rJ � update_console_history_detailsr4 r5 r6 r7 r9 r: r; r r r �)update_console_history_and_wait_for_state s. � �� &zJComputeClientCompositeOperations.update_console_history_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 ) an Calls :py:func:`~oci.core.ComputeClient.update_dedicated_vm_host` and waits for the :py:class:`~oci.core.models.DedicatedVmHost` acted upon to enter the given state(s). :param str dedicated_vm_host_id: (required) The OCID of the dedicated VM host. :param oci.core.models.UpdateDedicatedVmHostDetails update_dedicated_vm_host_details: (required) Update dedicated VM host details :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.DedicatedVmHost.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_dedicated_vm_host` :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 r z`ComputeClientCompositeOperations.update_dedicated_vm_host_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" Y r z^ComputeClientCompositeOperations.update_dedicated_vm_host_and_wait_for_state.<locals>.<lambda>r# r% r& N) r �update_dedicated_vm_hostr r* r r+ rk r- r. r/ r0 r1 r2 ) r r\ � update_dedicated_vm_host_detailsr4 r5 r6 r7 r9 r: r; r r r �+update_dedicated_vm_host_and_wait_for_state9 s. � �� &zLComputeClientCompositeOperations.update_dedicated_vm_host_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.core.ComputeClient.update_image` and waits for the :py:class:`~oci.core.models.Image` acted upon to enter the given state(s). :param str image_id: (required) The `OCID`__ of the image. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.core.models.UpdateImageDetails update_image_details: (required) Updates the image display name field. Avoid entering confidential information. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Image.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_image` :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 zTComputeClientCompositeOperations.update_image_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" � r zRComputeClientCompositeOperations.update_image_and_wait_for_state.<locals>.<lambda>r# r% r& N) r � update_imager r* r r+ rp r- r. r/ r0 r1 r2 ) r rq �update_image_detailsr4 r5 r6 r7 r9 r: r; r r r � update_image_and_wait_for_stateg s. � �� &z@ComputeClientCompositeOperations.update_image_and_wait_for_statec s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.core.ComputeClient.update_instance` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str instance_id: (required) The `OCID`__ of the instance. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.core.models.UpdateInstanceDetails update_instance_details: (required) Update instance fields :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_instance` :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^ComputeClientCompositeOperations.update_instance_and_wait_for_work_request.<locals>.<listcomp>rL r c s t | jd�o t | jd��� � v S rM r r rO r r r" � r z\ComputeClientCompositeOperations.update_instance_and_wait_for_work_request.<locals>.<lambda>r& N) r �update_instancer rR rS rT r+ r rU r2 r0 r1 ) r r` �update_instance_detailsrX r5 r6 r7 rY r9 r; r rO r �)update_instance_and_wait_for_work_request� s � ��zJComputeClientCompositeOperations.update_instance_and_wait_for_work_requestc 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.core.ComputeClient.update_instance` and waits for the :py:class:`~oci.core.models.Instance` acted upon to enter the given state(s). :param str instance_id: (required) The `OCID`__ of the instance. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.core.models.UpdateInstanceDetails update_instance_details: (required) Update instance fields :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Instance.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_instance` :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 zWComputeClientCompositeOperations.update_instance_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" � r zUComputeClientCompositeOperations.update_instance_and_wait_for_state.<locals>.<lambda>r# r% r& N) r r� r r* r r+ r� r- r. r/ r0 r1 r2 ) r r` r� r4 r5 r6 r7 r9 r: r; r r r �"update_instance_and_wait_for_state� s. � �� &zCComputeClientCompositeOperations.update_instance_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.core.ComputeClient.update_instance_console_connection` and waits for the :py:class:`~oci.core.models.InstanceConsoleConnection` acted upon to enter the given state(s). :param str instance_console_connection_id: (required) The OCID of the instance console connection. :param oci.core.models.UpdateInstanceConsoleConnectionDetails update_instance_console_connection_details: (required) Update instanceConsoleConnection tags :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.InstanceConsoleConnection.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_instance_console_connection` :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 zjComputeClientCompositeOperations.update_instance_console_connection_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" r zhComputeClientCompositeOperations.update_instance_console_connection_and_wait_for_state.<locals>.<lambda>r# r% r& N) r �"update_instance_console_connectionr r* r r+ rt r- r. r/ r0 r1 r2 ) r rv �*update_instance_console_connection_detailsr4 r5 r6 r7 r9 r: r; r r r �5update_instance_console_connection_and_wait_for_state� s. � �� &zVComputeClientCompositeOperations.update_instance_console_connection_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.core.ComputeClient.update_volume_attachment` and waits for the :py:class:`~oci.core.models.VolumeAttachment` acted upon to enter the given state(s). :param str volume_attachment_id: (required) The OCID of the volume attachment. :param oci.core.models.UpdateVolumeAttachmentDetails update_volume_attachment_details: (required) Update information about the specified volume attachment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeAttachment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_volume_attachment` :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 6 r z`ComputeClientCompositeOperations.update_volume_attachment_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r" = r z^ComputeClientCompositeOperations.update_volume_attachment_and_wait_for_state.<locals>.<lambda>r# r% r& N) r �update_volume_attachmentr r* r r+ rC r- r. r/ r0 r1 r2 ) r rE � update_volume_attachment_detailsr4 r5 r6 r7 r9 r: r; r r r �+update_volume_attachment_and_wait_for_state s. � �� &zLComputeClientCompositeOperations.update_volume_attachment_and_wait_for_state)N))�__name__� __module__� __qualname__�__doc__r r< rA rF rK rZ r^ rb re rg rj rl ro rr rw ry r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r sL ++++&&(%-#+#++#4#64444(02#+6&..0(0.r )r �oci.utilr �objectr r r r r �<module> s
cải xoăn