ruạṛ
a N��f x � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ sH e Zd ZdZdd� Zg i i fdd�Zg i i fdd�Zg i i fdd �Zg i i fd d �Zg i i fd d �Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Zg i i fdd�Zg i i fdd�Zg i i fd d �Zg i i fd d �Zg i i fd d!�Zg i i fd"d#�Zg i i fd$d%�Zg i i fd&d'�Zg i i fd(d)�Zg i i fd*d+�Zg i i fd,d-�Zg i i fd.d/�Zg i i fd0d1�Zg i i fd2d3�Z g i i fd4d5�Z g i i fd6d7�Z g i i fd8d9�Z g i i fd:d;�Z g i i fd<d=�Z!g i i fd>d?�Z"g i i fd@dA�Z#g i i fdBdC�Z$g i i fdDdE�Z%g i i fdFdG�Z&g i i fdHdI�Z'dJS )K�#CloudGuardClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.cloud_guard.CloudGuardClient` 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 CloudGuardClientCompositeOperations object :param CloudGuardClient client: The service client which will be wrapped by this object N)�client)�selfr �kwargs� r ��/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/oci/cloud_guard/cloud_guard_client_composite_operations.py�__init__ s z,CloudGuardClientCompositeOperations.__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.cloud_guard.CloudGuardClient.add_compartment` and waits for the :py:class:`~oci.cloud_guard.models.SecurityZone` acted upon to enter the given state(s). :param str security_zone_id: (required) The unique identifier of the security zone (`SecurityZone`) :param oci.cloud_guard.models.AddCompartmentDetails add_compartment_details: (required) The compartment to add to the security zone. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.SecurityZone.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.add_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r ��lower��.0�wr r r � <listcomp>3 � zZCloudGuardClientCompositeOperations.add_compartment_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 zXCloudGuardClientCompositeOperations.add_compartment_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 �add_compartmentr �id�oci� wait_until�get_security_zone� NameError� TypeError�args� exceptions�CompositeOperationError� Exception) r �security_zone_id�add_compartment_details�wait_for_states�operation_kwargs� waiter_kwargs�operation_result� waiter_result�result_to_return�er r r �"add_compartment_and_wait_for_state s. � �� &zFCloudGuardClientCompositeOperations.add_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |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.cloud_guard.CloudGuardClient.change_data_source_compartment` and waits for the :py:class:`~oci.cloud_guard.models.WorkRequest` to enter the given state(s). :param str data_source_id: (required) DataSource OCID :param oci.cloud_guard.models.ChangeDataSourceCompartmentDetails change_data_source_compartment_details: (required) The compartment id of the DataSource :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.change_data_source_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 a r ziCloudGuardClientCompositeOperations.change_data_source_compartment_and_wait_for_state.<locals>.<listcomp>�opc-work-request-idr c s t | jd�o t | jd��� � v S �N�statusr r r r r r h r zgCloudGuardClientCompositeOperations.change_data_source_compartment_and_wait_for_state.<locals>.<lambda>r N) r � change_data_source_compartment�headersr$ r% �get_work_requestr, r* r+ ) r �data_source_id�&change_data_source_compartment_detailsr/ r0 r1 r2 �wait_for_resource_idr3 r4 r5 r r r �1change_data_source_compartment_and_wait_for_stateH s$ � ��zUCloudGuardClientCompositeOperations.change_data_source_compartment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a' Calls :py:func:`~oci.cloud_guard.CloudGuardClient.create_data_mask_rule` and waits for the :py:class:`~oci.cloud_guard.models.DataMaskRule` acted upon to enter the given state(s). :param oci.cloud_guard.models.CreateDataMaskRuleDetails create_data_mask_rule_details: (required) Definition for the new Data Mask Rule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.DataMaskRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_data_mask_rule` :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`CloudGuardClientCompositeOperations.create_data_mask_rule_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^CloudGuardClientCompositeOperations.create_data_mask_rule_and_wait_for_state.<locals>.<lambda>r r r N) r �create_data_mask_ruler r# r$ r% �get_data_mask_ruler' r( r) r* r+ r, ) r � create_data_mask_rule_detailsr/ r0 r1 r2 �data_mask_rule_idr3 r4 r5 r r r �(create_data_mask_rule_and_wait_for_stateq s. � �� &zLCloudGuardClientCompositeOperations.create_data_mask_rule_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |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.cloud_guard.CloudGuardClient.create_data_source` and waits for the :py:class:`~oci.cloud_guard.models.WorkRequest` to enter the given state(s). :param oci.cloud_guard.models.CreateDataSourceDetails create_data_source_details: (required) Details for the new DataSource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_data_source` :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]CloudGuardClientCompositeOperations.create_data_source_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r � r z[CloudGuardClientCompositeOperations.create_data_source_and_wait_for_state.<locals>.<lambda>r N) r �create_data_sourcer; r$ r% r< r, r* r+ ) r �create_data_source_detailsr/ r0 r1 r2 r? r3 r4 r5 r r r �%create_data_source_and_wait_for_state� s$ � ��zICloudGuardClientCompositeOperations.create_data_source_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.cloud_guard.CloudGuardClient.create_detector_recipe` and waits for the :py:class:`~oci.cloud_guard.models.DetectorRecipe` acted upon to enter the given state(s). :param oci.cloud_guard.models.CreateDetectorRecipeDetails create_detector_recipe_details: (required) Details for the new DetectorRecipe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.DetectorRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_detector_recipe` :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 zaCloudGuardClientCompositeOperations.create_detector_recipe_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_CloudGuardClientCompositeOperations.create_detector_recipe_and_wait_for_state.<locals>.<lambda>r r r N) r �create_detector_reciper r# r$ r% �get_detector_reciper' r( r) r* r+ r, ) r � create_detector_recipe_detailsr/ r0 r1 r2 �detector_recipe_idr3 r4 r5 r r r �)create_detector_recipe_and_wait_for_state� s. � �� &zMCloudGuardClientCompositeOperations.create_detector_recipe_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �|t�fd� fdd�i|��}|}|W S tt fy� } 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.cloud_guard.CloudGuardClient.create_detector_recipe_detector_rule` and waits for the :py:class:`~oci.cloud_guard.models.DetectorRecipeDetectorRule` acted upon to enter the given state(s). :param str detector_recipe_id: (required) DetectorRecipe OCID :param oci.cloud_guard.models.CreateDetectorRecipeDetectorRuleDetails create_detector_recipe_detector_rule_details: (required) The details with which detector rule has to be created. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.DetectorRecipeDetectorRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_detector_recipe_detector_rule` :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 zoCloudGuardClientCompositeOperations.create_detector_recipe_detector_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r r zmCloudGuardClientCompositeOperations.create_detector_recipe_detector_rule_and_wait_for_state.<locals>.<lambda>r r r N)r �$create_detector_recipe_detector_ruler r# r$ r% �!get_detector_recipe_detector_rule�detector_rule_idr' r( r) r* r+ r, ) r rL �,create_detector_recipe_detector_rule_detailsr/ r0 r1 r2 r3 r4 r5 r r r �7create_detector_recipe_detector_rule_and_wait_for_state� s. � �� &z[CloudGuardClientCompositeOperations.create_detector_recipe_detector_rule_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.cloud_guard.CloudGuardClient.create_managed_list` and waits for the :py:class:`~oci.cloud_guard.models.ManagedList` acted upon to enter the given state(s). :param oci.cloud_guard.models.CreateManagedListDetails create_managed_list_details: (required) Details for the new ManagedList. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.ManagedList.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_managed_list` :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 1 r z^CloudGuardClientCompositeOperations.create_managed_list_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r 8 r z\CloudGuardClientCompositeOperations.create_managed_list_and_wait_for_state.<locals>.<lambda>r r r N) r �create_managed_listr r# r$ r% �get_managed_listr' r( r) r* r+ r, ) r �create_managed_list_detailsr/ r0 r1 r2 �managed_list_idr3 r4 r5 r r r �&create_managed_list_and_wait_for_state s. � �� &zJCloudGuardClientCompositeOperations.create_managed_list_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.cloud_guard.CloudGuardClient.create_responder_recipe` and waits for the :py:class:`~oci.cloud_guard.models.ResponderRecipe` acted upon to enter the given state(s). :param oci.cloud_guard.models.CreateResponderRecipeDetails create_responder_recipe_details: (required) Details for ResponderRecipe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.ResponderRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_responder_recipe` :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 zbCloudGuardClientCompositeOperations.create_responder_recipe_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r c r z`CloudGuardClientCompositeOperations.create_responder_recipe_and_wait_for_state.<locals>.<lambda>r r r N) r �create_responder_reciper r# r$ r% �get_responder_reciper' r( r) r* r+ r, ) r � create_responder_recipe_detailsr/ r0 r1 r2 �responder_recipe_idr3 r4 r5 r r r �*create_responder_recipe_and_wait_for_stateF s. � �� &zNCloudGuardClientCompositeOperations.create_responder_recipe_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.cloud_guard.CloudGuardClient.create_security_recipe` and waits for the :py:class:`~oci.cloud_guard.models.SecurityRecipe` acted upon to enter the given state(s). :param oci.cloud_guard.models.CreateSecurityRecipeDetails create_security_recipe_details: (required) Details for the new `SecurityRecipe`. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.SecurityRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_security_recipe` :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 zaCloudGuardClientCompositeOperations.create_security_recipe_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_CloudGuardClientCompositeOperations.create_security_recipe_and_wait_for_state.<locals>.<lambda>r r r N) r �create_security_reciper r# r$ r% �get_security_reciper' r( r) r* r+ r, ) r � create_security_recipe_detailsr/ r0 r1 r2 �security_recipe_idr3 r4 r5 r r r �)create_security_recipe_and_wait_for_stateq s. � �� &zMCloudGuardClientCompositeOperations.create_security_recipe_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.cloud_guard.CloudGuardClient.create_security_zone` and waits for the :py:class:`~oci.cloud_guard.models.SecurityZone` acted upon to enter the given state(s). :param oci.cloud_guard.models.CreateSecurityZoneDetails create_security_zone_details: (required) Details for the new `SecurityZone`. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.SecurityZone.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_security_zone` :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_CloudGuardClientCompositeOperations.create_security_zone_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]CloudGuardClientCompositeOperations.create_security_zone_and_wait_for_state.<locals>.<lambda>r r r N) r �create_security_zoner r# r$ r% r& r' r( r) r* r+ r, ) r � create_security_zone_detailsr/ r0 r1 r2 r- r3 r4 r5 r r r �'create_security_zone_and_wait_for_state� s. � �� &zKCloudGuardClientCompositeOperations.create_security_zone_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.cloud_guard.CloudGuardClient.create_target` and waits for the :py:class:`~oci.cloud_guard.models.Target` acted upon to enter the given state(s). :param oci.cloud_guard.models.CreateTargetDetails create_target_details: (required) Details for the new Target. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.Target.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_target` :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 zXCloudGuardClientCompositeOperations.create_target_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zVCloudGuardClientCompositeOperations.create_target_and_wait_for_state.<locals>.<lambda>r r r N) r � create_targetr r# r$ r% � get_targetr' r( r) r* r+ r, ) r �create_target_detailsr/ r0 r1 r2 � target_idr3 r4 r5 r r r � create_target_and_wait_for_state� s. � �� &zDCloudGuardClientCompositeOperations.create_target_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �|t�fd� fdd�i|��}|}|W S tt fy� } 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.cloud_guard.CloudGuardClient.create_target_detector_recipe` and waits for the :py:class:`~oci.cloud_guard.models.TargetDetectorRecipe` acted upon to enter the given state(s). :param str target_id: (required) OCID of target :param oci.cloud_guard.models.AttachTargetDetectorRecipeDetails attach_target_detector_recipe_details: (required) Details for associating DetectorRecipe to Target :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.TargetDetectorRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.create_target_detector_recipe` :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 zhCloudGuardClientCompositeOperations.create_target_detector_recipe_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r r zfCloudGuardClientCompositeOperations.create_target_detector_recipe_and_wait_for_state.<locals>.<lambda>r r r N)r � create_target_detector_reciper r# r$ r% �get_target_detector_recipe�target_detector_recipe_idr' r( r) r* r+ r, ) r rh �%attach_target_detector_recipe_detailsr/ r0 r1 r2 r3 r4 r5 r r r �0create_target_detector_recipe_and_wait_for_state� s. � �� &zTCloudGuardClientCompositeOperations.create_target_detector_recipe_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.cloud_guard.CloudGuardClient.delete_data_mask_rule` and waits for the :py:class:`~oci.cloud_guard.models.DataMaskRule` acted upon to enter the given state(s). :param str data_mask_rule_id: (required) OCID of dataMaskRule :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.DataMaskRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_data_mask_rule` :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`CloudGuardClientCompositeOperations.delete_data_mask_rule_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r E r z^CloudGuardClientCompositeOperations.delete_data_mask_rule_and_wait_for_state.<locals>.<lambda>T�r �succeed_on_not_foundr r r )r rB �delete_data_mask_ruler$ r* � ServiceErrorr9 r r% r' r( r) r+ r, ) r rD r/ r0 r1 �initial_get_resultr2 r5 r3 r4 r r r �(delete_data_mask_rule_and_wait_for_state s< � �� &zLCloudGuardClientCompositeOperations.delete_data_mask_rule_and_wait_for_statec s� d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.cloud_guard.CloudGuardClient.delete_data_source` and waits for the :py:class:`~oci.cloud_guard.models.WorkRequest` to enter the given state(s). :param str data_source_id: (required) DataSource OCID :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_data_source` :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 Nro c S s g | ] }|� � �qS r r r r r r r r r z]CloudGuardClientCompositeOperations.delete_data_source_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r y r z[CloudGuardClientCompositeOperations.delete_data_source_and_wait_for_state.<locals>.<lambda>r ) r �delete_data_sourcer$ r* rs r9 r r; r% r< r, r+ ) r r= r/ r0 r1 r2 r5 r? r3 r4 r r r �%delete_data_source_and_wait_for_stateT s0 � ��zICloudGuardClientCompositeOperations.delete_data_source_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.cloud_guard.CloudGuardClient.delete_detector_recipe` and waits for the :py:class:`~oci.cloud_guard.models.DetectorRecipe` acted upon to enter the given state(s). :param str detector_recipe_id: (required) DetectorRecipe OCID :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.DetectorRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_detector_recipe` :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 Nro c S s g | ] }|� � �qS r r r r r r r � r zaCloudGuardClientCompositeOperations.delete_detector_recipe_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r � r z_CloudGuardClientCompositeOperations.delete_detector_recipe_and_wait_for_state.<locals>.<lambda>Trp r r r )r rJ �delete_detector_reciper$ r* rs r9 r r% r' r( r) r+ r, ) r rL r/ r0 r1 rt r2 r5 r3 r4 r r r �)delete_detector_recipe_and_wait_for_state� s< � �� &zMCloudGuardClientCompositeOperations.delete_detector_recipe_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.cloud_guard.CloudGuardClient.delete_managed_list` and waits for the :py:class:`~oci.cloud_guard.models.ManagedList` acted upon to enter the given state(s). :param str managed_list_id: (required) The cloudguard list OCID to be passed in the request. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.ManagedList.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_managed_list` :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 Nro c S s g | ] }|� � �qS r r r r r r r � r z^CloudGuardClientCompositeOperations.delete_managed_list_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r � r z\CloudGuardClientCompositeOperations.delete_managed_list_and_wait_for_state.<locals>.<lambda>Trp r r r )r rT �delete_managed_listr$ r* rs r9 r r% r' r( r) r+ r, ) r rV r/ r0 r1 rt r2 r5 r3 r4 r r r �&delete_managed_list_and_wait_for_state� s< � �� &zJCloudGuardClientCompositeOperations.delete_managed_list_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.cloud_guard.CloudGuardClient.delete_responder_recipe` and waits for the :py:class:`~oci.cloud_guard.models.ResponderRecipe` acted upon to enter the given state(s). :param str responder_recipe_id: (required) OCID of ResponderRecipe :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.ResponderRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_responder_recipe` :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 Nro c S s g | ] }|� � �qS r r r r r r r r zbCloudGuardClientCompositeOperations.delete_responder_recipe_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r r z`CloudGuardClientCompositeOperations.delete_responder_recipe_and_wait_for_state.<locals>.<lambda>Trp r r r )r rY �delete_responder_reciper$ r* rs r9 r r% r' r( r) r+ r, ) r r[ r/ r0 r1 rt r2 r5 r3 r4 r r r �*delete_responder_recipe_and_wait_for_state� s< � �� &zNCloudGuardClientCompositeOperations.delete_responder_recipe_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.cloud_guard.CloudGuardClient.delete_security_recipe` and waits for the :py:class:`~oci.cloud_guard.models.SecurityRecipe` acted upon to enter the given state(s). :param str security_recipe_id: (required) The unique identifier of the security zone recipe (`SecurityRecipe`) :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.SecurityRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_security_recipe` :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 Nro c S s g | ] }|� � �qS r r r r r r r = r zaCloudGuardClientCompositeOperations.delete_security_recipe_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r C r z_CloudGuardClientCompositeOperations.delete_security_recipe_and_wait_for_state.<locals>.<lambda>Trp r r r )r r^ �delete_security_reciper$ r* rs r9 r r% r' r( r) r+ r, ) r r` r/ r0 r1 rt r2 r5 r3 r4 r r r �)delete_security_recipe_and_wait_for_state s< � �� &zMCloudGuardClientCompositeOperations.delete_security_recipe_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.cloud_guard.CloudGuardClient.delete_security_zone` and waits for the :py:class:`~oci.cloud_guard.models.SecurityZone` acted upon to enter the given state(s). :param str security_zone_id: (required) The unique identifier of the security zone (`SecurityZone`) :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.SecurityZone.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_security_zone` :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 Nro c S s g | ] }|� � �qS r r r r r r r q r z_CloudGuardClientCompositeOperations.delete_security_zone_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r w r z]CloudGuardClientCompositeOperations.delete_security_zone_and_wait_for_state.<locals>.<lambda>Trp r r r )r r& �delete_security_zoner$ r* rs r9 r r% r' r( r) r+ r, ) r r- r/ r0 r1 rt r2 r5 r3 r4 r r r �'delete_security_zone_and_wait_for_stateR s< � �� &zKCloudGuardClientCompositeOperations.delete_security_zone_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.cloud_guard.CloudGuardClient.delete_target` and waits for the :py:class:`~oci.cloud_guard.models.Target` acted upon to enter the given state(s). :param str target_id: (required) OCID of target :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.Target.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.delete_target` :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 Nro c S s g | ] }|� � �qS r r r r r r r � r zXCloudGuardClientCompositeOperations.delete_target_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r � r zVCloudGuardClientCompositeOperations.delete_target_and_wait_for_state.<locals>.<lambda>Trp r r r )r rf � delete_targetr$ r* rs r9 r r% r' r( r) r+ r, ) r rh r/ r0 r1 rt r2 r5 r3 r4 r r r � delete_target_and_wait_for_state� s< � �� &zDCloudGuardClientCompositeOperations.delete_target_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.cloud_guard.CloudGuardClient.remove_compartment` and waits for the :py:class:`~oci.cloud_guard.models.SecurityZone` acted upon to enter the given state(s). :param str security_zone_id: (required) The unique identifier of the security zone (`SecurityZone`) :param oci.cloud_guard.models.RemoveCompartmentDetails remove_compartment_details: (required) The compartment to remove from the security zone. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.SecurityZone.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.remove_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]CloudGuardClientCompositeOperations.remove_compartment_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[CloudGuardClientCompositeOperations.remove_compartment_and_wait_for_state.<locals>.<lambda>r r r N) r �remove_compartmentr r# r$ r% r& r' r( r) r* r+ r, ) r r- �remove_compartment_detailsr/ r0 r1 r2 r3 r4 r5 r r r �%remove_compartment_and_wait_for_state� s. � �� &zICloudGuardClientCompositeOperations.remove_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) ar Calls :py:func:`~oci.cloud_guard.CloudGuardClient.update_data_mask_rule` and waits for the :py:class:`~oci.cloud_guard.models.DataMaskRule` acted upon to enter the given state(s). :param str data_mask_rule_id: (required) OCID of dataMaskRule :param oci.cloud_guard.models.UpdateDataMaskRuleDetails update_data_mask_rule_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.cloud_guard.models.DataMaskRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_data_mask_rule` :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`CloudGuardClientCompositeOperations.update_data_mask_rule_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^CloudGuardClientCompositeOperations.update_data_mask_rule_and_wait_for_state.<locals>.<lambda>r r r N) r �update_data_mask_ruler r# r$ r% rB r' r( r) r* r+ r, ) r rD � update_data_mask_rule_detailsr/ r0 r1 r2 r3 r4 r5 r r r �(update_data_mask_rule_and_wait_for_state� s. � �� &zLCloudGuardClientCompositeOperations.update_data_mask_rule_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aS Calls :py:func:`~oci.cloud_guard.CloudGuardClient.update_data_source` and waits for the :py:class:`~oci.cloud_guard.models.WorkRequest` to enter the given state(s). :param str data_source_id: (required) DataSource OCID :param oci.cloud_guard.models.UpdateDataSourceDetails update_data_source_details: (required) Details for the DataSource 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.cloud_guard.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_data_source` :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]CloudGuardClientCompositeOperations.update_data_source_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r 6 r z[CloudGuardClientCompositeOperations.update_data_source_and_wait_for_state.<locals>.<lambda>r N) r �update_data_sourcer; r$ r% r< r, r* r+ ) r r= �update_data_source_detailsr/ r0 r1 r2 r? r3 r4 r5 r r r �%update_data_source_and_wait_for_state s$ � ��zICloudGuardClientCompositeOperations.update_data_source_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.cloud_guard.CloudGuardClient.update_detector_recipe` and waits for the :py:class:`~oci.cloud_guard.models.DetectorRecipe` acted upon to enter the given state(s). :param str detector_recipe_id: (required) DetectorRecipe OCID :param oci.cloud_guard.models.UpdateDetectorRecipeDetails update_detector_recipe_details: (required) Details for the DetectorRecipe 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.cloud_guard.models.DetectorRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_detector_recipe` :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 zaCloudGuardClientCompositeOperations.update_detector_recipe_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_CloudGuardClientCompositeOperations.update_detector_recipe_and_wait_for_state.<locals>.<lambda>r r r N) r �update_detector_reciper r# r$ r% rJ r' r( r) r* r+ r, ) r rL � update_detector_recipe_detailsr/ r0 r1 r2 r3 r4 r5 r r r �)update_detector_recipe_and_wait_for_state? s. � �� &zMCloudGuardClientCompositeOperations.update_detector_recipe_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a- Calls :py:func:`~oci.cloud_guard.CloudGuardClient.update_detector_recipe_detector_rule` and waits for the :py:class:`~oci.cloud_guard.models.DetectorRecipeDetectorRule` acted upon to enter the given state(s). :param str detector_recipe_id: (required) DetectorRecipe OCID :param str detector_rule_id: (required) The key of Detector Rule. :param oci.cloud_guard.models.UpdateDetectorRecipeDetectorRuleDetails update_detector_recipe_detector_rule_details: (required) The details to be updated for DetectorRule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.DetectorRecipeDetectorRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_detector_recipe_detector_rule` :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 zoCloudGuardClientCompositeOperations.update_detector_recipe_detector_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zmCloudGuardClientCompositeOperations.update_detector_recipe_detector_rule_and_wait_for_state.<locals>.<lambda>r r r N) r �$update_detector_recipe_detector_ruler r# r$ r% rO r' r( r) r* r+ r, ) r rL rP �,update_detector_recipe_detector_rule_detailsr/ r0 r1 r2 r3 r4 r5 r r r �7update_detector_recipe_detector_rule_and_wait_for_statem s. � �� &z[CloudGuardClientCompositeOperations.update_detector_recipe_detector_rule_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.cloud_guard.CloudGuardClient.update_managed_list` and waits for the :py:class:`~oci.cloud_guard.models.ManagedList` acted upon to enter the given state(s). :param str managed_list_id: (required) The cloudguard list OCID to be passed in the request. :param oci.cloud_guard.models.UpdateManagedListDetails update_managed_list_details: (required) Details for the ManagedList 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.cloud_guard.models.ManagedList.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_managed_list` :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^CloudGuardClientCompositeOperations.update_managed_list_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\CloudGuardClientCompositeOperations.update_managed_list_and_wait_for_state.<locals>.<lambda>r r r N) r �update_managed_listr r# r$ r% rT r' r( r) r* r+ r, ) r rV �update_managed_list_detailsr/ r0 r1 r2 r3 r4 r5 r r r �&update_managed_list_and_wait_for_state� s. � �� &zJCloudGuardClientCompositeOperations.update_managed_list_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 ) ak Calls :py:func:`~oci.cloud_guard.CloudGuardClient.update_problem_status` and waits for the :py:class:`~oci.cloud_guard.models.Problem` acted upon to enter the given state(s). :param str problem_id: (required) OCId of the problem. :param oci.cloud_guard.models.UpdateProblemStatusDetails update_problem_status_details: (required) The additional details for the problem. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.Problem.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_problem_status` :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`CloudGuardClientCompositeOperations.update_problem_status_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^CloudGuardClientCompositeOperations.update_problem_status_and_wait_for_state.<locals>.<lambda>r r r N) r �update_problem_statusr r# r$ r% � get_problemr' r( r) r* r+ r, ) r � problem_id� update_problem_status_detailsr/ r0 r1 r2 r3 r4 r5 r r r �(update_problem_status_and_wait_for_state� s. � �� &zLCloudGuardClientCompositeOperations.update_problem_status_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.cloud_guard.CloudGuardClient.update_responder_recipe` and waits for the :py:class:`~oci.cloud_guard.models.ResponderRecipe` acted upon to enter the given state(s). :param str responder_recipe_id: (required) OCID of ResponderRecipe :param oci.cloud_guard.models.UpdateResponderRecipeDetails update_responder_recipe_details: (required) The details 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.cloud_guard.models.ResponderRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_responder_recipe` :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 zbCloudGuardClientCompositeOperations.update_responder_recipe_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`CloudGuardClientCompositeOperations.update_responder_recipe_and_wait_for_state.<locals>.<lambda>r r r N) r �update_responder_reciper r# r$ r% rY r' r( r) r* r+ r, ) r r[ � update_responder_recipe_detailsr/ r0 r1 r2 r3 r4 r5 r r r �*update_responder_recipe_and_wait_for_state� s. � �� &zNCloudGuardClientCompositeOperations.update_responder_recipe_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a> Calls :py:func:`~oci.cloud_guard.CloudGuardClient.update_responder_recipe_responder_rule` and waits for the :py:class:`~oci.cloud_guard.models.ResponderRecipeResponderRule` acted upon to enter the given state(s). :param str responder_recipe_id: (required) OCID of ResponderRecipe :param str responder_rule_id: (required) The id of ResponderRule :param oci.cloud_guard.models.UpdateResponderRecipeResponderRuleDetails update_responder_recipe_responder_rule_details: (required) The details to be updated for ResponderRule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.ResponderRecipeResponderRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_responder_recipe_responder_rule` :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 D r zqCloudGuardClientCompositeOperations.update_responder_recipe_responder_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r K r zoCloudGuardClientCompositeOperations.update_responder_recipe_responder_rule_and_wait_for_state.<locals>.<lambda>r r r N) r �&update_responder_recipe_responder_ruler r# r$ r% �#get_responder_recipe_responder_ruler' r( r) r* r+ r, ) r r[ �responder_rule_id�.update_responder_recipe_responder_rule_detailsr/ r0 r1 r2 r3 r4 r5 r r r �9update_responder_recipe_responder_rule_and_wait_for_state( s. � �� &z]CloudGuardClientCompositeOperations.update_responder_recipe_responder_rule_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.cloud_guard.CloudGuardClient.update_security_recipe` and waits for the :py:class:`~oci.cloud_guard.models.SecurityRecipe` acted upon to enter the given state(s). :param str security_recipe_id: (required) The unique identifier of the security zone recipe (`SecurityRecipe`) :param oci.cloud_guard.models.UpdateSecurityRecipeDetails update_security_recipe_details: (required) The information to be updated in the security zone recipe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.SecurityRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_security_recipe` :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 zaCloudGuardClientCompositeOperations.update_security_recipe_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_CloudGuardClientCompositeOperations.update_security_recipe_and_wait_for_state.<locals>.<lambda>r r r N) r �update_security_reciper r# r$ r% r^ r' r( r) r* r+ r, ) r r` � update_security_recipe_detailsr/ r0 r1 r2 r3 r4 r5 r r r �)update_security_recipe_and_wait_for_stateY s. � �� &zMCloudGuardClientCompositeOperations.update_security_recipe_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.cloud_guard.CloudGuardClient.update_security_zone` and waits for the :py:class:`~oci.cloud_guard.models.SecurityZone` acted upon to enter the given state(s). :param str security_zone_id: (required) The unique identifier of the security zone (`SecurityZone`) :param oci.cloud_guard.models.UpdateSecurityZoneDetails update_security_zone_details: (required) The security zone 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.cloud_guard.models.SecurityZone.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_security_zone` :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_CloudGuardClientCompositeOperations.update_security_zone_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]CloudGuardClientCompositeOperations.update_security_zone_and_wait_for_state.<locals>.<lambda>r r r N) r �update_security_zoner r# r$ r% r& r' r( r) r* r+ r, ) r r- � update_security_zone_detailsr/ r0 r1 r2 r3 r4 r5 r r r �'update_security_zone_and_wait_for_state� s. � �� &zKCloudGuardClientCompositeOperations.update_security_zone_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.cloud_guard.CloudGuardClient.update_target` and waits for the :py:class:`~oci.cloud_guard.models.Target` acted upon to enter the given state(s). :param str target_id: (required) OCID of target :param oci.cloud_guard.models.UpdateTargetDetails update_target_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.cloud_guard.models.Target.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_target` :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 zXCloudGuardClientCompositeOperations.update_target_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zVCloudGuardClientCompositeOperations.update_target_and_wait_for_state.<locals>.<lambda>r r r N) r � update_targetr r# r$ r% rf r' r( r) r* r+ r, ) r rh �update_target_detailsr/ r0 r1 r2 r3 r4 r5 r r r � update_target_and_wait_for_state� s. � �� &zDCloudGuardClientCompositeOperations.update_target_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.cloud_guard.CloudGuardClient.update_target_detector_recipe` and waits for the :py:class:`~oci.cloud_guard.models.TargetDetectorRecipe` acted upon to enter the given state(s). :param str target_id: (required) OCID of target :param str target_detector_recipe_id: (required) OCID of TargetDetectorRecipe :param oci.cloud_guard.models.UpdateTargetDetectorRecipeDetails update_target_detector_recipe_details: (required) The details 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.cloud_guard.models.TargetDetectorRecipe.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_target_detector_recipe` :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 zhCloudGuardClientCompositeOperations.update_target_detector_recipe_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r r zfCloudGuardClientCompositeOperations.update_target_detector_recipe_and_wait_for_state.<locals>.<lambda>r r r N) r � update_target_detector_reciper r# r$ r% rk r' r( r) r* r+ r, ) r rh rl �%update_target_detector_recipe_detailsr/ r0 r1 r2 r3 r4 r5 r r r �0update_target_detector_recipe_and_wait_for_state� s. � �� &zTCloudGuardClientCompositeOperations.update_target_detector_recipe_and_wait_for_statec s� | j j||||fi |��}|s"|S dd� |D �� |jj}z8tj| 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.cloud_guard.CloudGuardClient.update_target_detector_recipe_detector_rule` and waits for the :py:class:`~oci.cloud_guard.models.TargetDetectorRecipeDetectorRule` acted upon to enter the given state(s). :param str target_id: (required) OCID of target :param str target_detector_recipe_id: (required) OCID of TargetDetectorRecipe :param str detector_rule_id: (required) The id of DetectorRule :param oci.cloud_guard.models.UpdateTargetDetectorRecipeDetectorRuleDetails update_target_detector_recipe_detector_rule_details: (required) The details to be updated for DetectorRule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.TargetDetectorRecipeDetectorRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_target_detector_recipe_detector_rule` :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 3 r zvCloudGuardClientCompositeOperations.update_target_detector_recipe_detector_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r : r ztCloudGuardClientCompositeOperations.update_target_detector_recipe_detector_rule_and_wait_for_state.<locals>.<lambda>r r r N) r �+update_target_detector_recipe_detector_ruler r# r$ r% �(get_target_detector_recipe_detector_ruler' r( r) r* r+ r, ) r rh rl rP �3update_target_detector_recipe_detector_rule_detailsr/ r0 r1 r2 r3 r4 r5 r r r �>update_target_detector_recipe_detector_rule_and_wait_for_state s. � �� &zbCloudGuardClientCompositeOperations.update_target_detector_recipe_detector_rule_and_wait_for_statec s� | j j||||fi |��}|s"|S dd� |D �� |jj}z8tj| 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.cloud_guard.CloudGuardClient.update_target_responder_recipe_responder_rule` and waits for the :py:class:`~oci.cloud_guard.models.TargetResponderRecipeResponderRule` acted upon to enter the given state(s). :param str target_id: (required) OCID of target :param str target_responder_recipe_id: (required) OCID of TargetResponderRecipe :param str responder_rule_id: (required) The id of ResponderRule :param oci.cloud_guard.models.UpdateTargetResponderRecipeResponderRuleDetails update_target_responder_recipe_responder_rule_details: (required) The details to be updated for ResponderRule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.cloud_guard.models.TargetResponderRecipeResponderRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.cloud_guard.CloudGuardClient.update_target_responder_recipe_responder_rule` :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 g r zxCloudGuardClientCompositeOperations.update_target_responder_recipe_responder_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r n r zvCloudGuardClientCompositeOperations.update_target_responder_recipe_responder_rule_and_wait_for_state.<locals>.<lambda>r r r N) r �-update_target_responder_recipe_responder_ruler r# r$ r% �*get_target_responder_recipe_responder_ruler' r( r) r* r+ r, ) r rh �target_responder_recipe_idr� �5update_target_responder_recipe_responder_rule_detailsr/ r0 r1 r2 r3 r4 r5 r r r �@update_target_responder_recipe_responder_rule_and_wait_for_stateH s. � �� &zdCloudGuardClientCompositeOperations.update_target_responder_recipe_responder_rule_and_wait_for_stateN)(�__name__� __module__� __qualname__�__doc__r r6 r@ rE rH rM rR rW r\ ra rd ri rn ru 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 sJ .)+&+.+++++.4.444444..).1...1...14r )r$ �oci.utilr �objectr r r r r �<module> s
cải xoăn