ruạṛ
a N��f:> � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ s e Zd ZdZdd� Zg i i fdd�Zg i i fdd�Zg i i fdd �Zg i i fd d �Zg i i fd d �Z g i i fdd�Z g i i fdd�Z g i i fdd�Z 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'g i i fdJdK�Z(g i i fdLdM�Z)g i i fdNdO�Z*g i i fdPdQ�Z+g i i fdRdS�Z,g i i fdTdU�Z-g i i fdVdW�Z.g i i fdXdY�Z/g i i fdZd[�Z0g i i fd\d]�Z1g i i fd^d_�Z2g i i fd`da�Z3g i i fdbdc�Z4g i i fddde�Z5g i i fdfdg�Z6g i i fdhdi�Z7g i i fdjdk�Z8g i i fdldm�Z9g i i fdndo�Z:g i i fdpdq�Z;g i i fdrds�Z<g i i fdtdu�Z=g i i fdvdw�Z>g i i fdxdy�Z?g i i fdzd{�Z@g i i fd|d}�ZAg i i fd~d�ZBg i i fd�d��ZCg i i fd�d��ZDg i i fd�d��ZEg i i fd�d��ZFg i i fd�d��ZGg i i fd�d��ZHg i i fd�d��ZIg i i fd�d��ZJg i i fd�d��ZKg i i fd�d��ZLg i i fd�d��ZMg i i fd�d��ZNg i i fd�d��ZOg i i fd�d��ZPg i i fd�d��ZQg i i fd�d��ZRg i i fd�d��ZSg i i fd�d��ZTg i i fd�d��ZUg i i fd�d��ZVg i i fd�d��ZWg i i fd�d��ZXg i i fd�d��ZYg i i fd�d��ZZg i i fd�d��Z[g i i fd�d��Z\g i i fd�d��Z]g i i fd�d��Z^g i i fd�d��Z_g i i fd�d��Z`g i i fd�d��Zag i i fd�d��Zbg i i fd�d��Zcd�S )��!DataSafeClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.data_safe.DataSafeClient` 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 DataSafeClientCompositeOperations object :param DataSafeClient 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/data_safe/data_safe_client_composite_operations.py�__init__ s z*DataSafeClientCompositeOperations.__init__c 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.data_safe.DataSafeClient.activate_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.ActivateTargetDatabaseDetails activate_target_database_details: (required) The details used to reactivate a target database in Data Safe. :param str target_database_id: (required) The OCID of the Data Safe target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.activate_target_database` :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 � zaDataSafeClientCompositeOperations.activate_target_database_and_wait_for_state.<locals>.<listcomp>�opc-work-request-id�evaluate_responsec s t | jd�o t | jd��� � v S �N�status��getattr�datar ��r��lowered_wait_for_statesr r �<lambda>: r z_DataSafeClientCompositeOperations.activate_target_database_and_wait_for_state.<locals>.<lambda>��partial_results�causeN) r �activate_target_database�headers�oci� wait_until�get_work_request� Exception� exceptions�CompositeOperationError) r � activate_target_database_details�target_database_id�wait_for_states�operation_kwargs� waiter_kwargs�operation_result�wait_for_resource_id� waiter_result�result_to_return�er r r �+activate_target_database_and_wait_for_state s$ � ��zMDataSafeClientCompositeOperations.activate_target_database_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.data_safe.DataSafeClient.add_masking_columns_from_sdm` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.add_masking_columns_from_sdm` :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 Y r zeDataSafeClientCompositeOperations.add_masking_columns_from_sdm_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ` r zcDataSafeClientCompositeOperations.add_masking_columns_from_sdm_and_wait_for_state.<locals>.<lambda>r N) r � add_masking_columns_from_sdmr! r" r# r$ r% r& r' ) r �masking_policy_idr* r+ r, r- r. r/ r0 r1 r r r �/add_masking_columns_from_sdm_and_wait_for_stateC s$ � ��zQDataSafeClientCompositeOperations.add_masking_columns_from_sdm_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.data_safe.DataSafeClient.alerts_update` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.AlertsUpdateDetails alerts_update_details: (required) Details to update alerts within a given compartment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.alerts_update` :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 zVDataSafeClientCompositeOperations.alerts_update_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zTDataSafeClientCompositeOperations.alerts_update_and_wait_for_state.<locals>.<lambda>r N) r � alerts_updater! r" r# r$ r% r& r' ) r �alerts_update_detailsr* r+ r, r- r. r/ r0 r1 r r r � alerts_update_and_wait_for_statei s$ � ��zBDataSafeClientCompositeOperations.alerts_update_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.data_safe.DataSafeClient.apply_discovery_job_results` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.ApplyDiscoveryJobResultsDetails apply_discovery_job_results_details: (required) Details to apply the discovery results to a sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.apply_discovery_job_results` :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 zdDataSafeClientCompositeOperations.apply_discovery_job_results_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.apply_discovery_job_results_and_wait_for_state.<locals>.<lambda>r N) r �apply_discovery_job_resultsr! r" r# r$ r% r& r' ) r �sensitive_data_model_id�#apply_discovery_job_results_detailsr* r+ r, r- r. r/ r0 r1 r r r �.apply_discovery_job_results_and_wait_for_state� s$ � ��zPDataSafeClientCompositeOperations.apply_discovery_job_results_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.data_safe.DataSafeClient.calculate_audit_volume_available` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.CalculateAuditVolumeAvailableDetails calculate_audit_volume_available_details: (required) Details for the calculation of audit volume available on target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.calculate_audit_volume_available` :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 ziDataSafeClientCompositeOperations.calculate_audit_volume_available_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zgDataSafeClientCompositeOperations.calculate_audit_volume_available_and_wait_for_state.<locals>.<lambda>r N) r � calculate_audit_volume_availabler! r" r# r$ r% r& r' ) r �audit_profile_id�(calculate_audit_volume_available_detailsr* r+ r, r- r. r/ r0 r1 r r r �3calculate_audit_volume_available_and_wait_for_state� s$ � ��zUDataSafeClientCompositeOperations.calculate_audit_volume_available_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.data_safe.DataSafeClient.calculate_audit_volume_collected` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.CalculateAuditVolumeCollectedDetails calculate_audit_volume_collected_details: (required) Details for the calculation of audit volume collected by data safe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.calculate_audit_volume_collected` :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 ziDataSafeClientCompositeOperations.calculate_audit_volume_collected_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zgDataSafeClientCompositeOperations.calculate_audit_volume_collected_and_wait_for_state.<locals>.<lambda>r N) r � calculate_audit_volume_collectedr! r" r# r$ r% r& r' ) r r> �(calculate_audit_volume_collected_detailsr* r+ r, r- r. r/ r0 r1 r r r �3calculate_audit_volume_collected_and_wait_for_state� s$ � ��zUDataSafeClientCompositeOperations.calculate_audit_volume_collected_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.data_safe.DataSafeClient.change_audit_archive_retrieval_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_archive_retrieval_id: (required) OCID of the archive retrieval. :param oci.data_safe.models.ChangeAuditArchiveRetrievalCompartmentDetails change_audit_archive_retrieval_compartment_details: (required) The details used to change the compartment of a archive retrieval. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_audit_archive_retrieval_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 zsDataSafeClientCompositeOperations.change_audit_archive_retrieval_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r * r zqDataSafeClientCompositeOperations.change_audit_archive_retrieval_compartment_and_wait_for_state.<locals>.<lambda>r N) r �*change_audit_archive_retrieval_compartmentr! r" r# r$ r% r& r' ) r �audit_archive_retrieval_id�2change_audit_archive_retrieval_compartment_detailsr* r+ r, r- r. r/ r0 r1 r r r �=change_audit_archive_retrieval_compartment_and_wait_for_state s$ � ��z_DataSafeClientCompositeOperations.change_audit_archive_retrieval_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.data_safe.DataSafeClient.change_audit_policy_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_policy_id: (required) Unique audit policy identifier. :param oci.data_safe.models.ChangeAuditPolicyCompartmentDetails change_audit_policy_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_audit_policy_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 L r zhDataSafeClientCompositeOperations.change_audit_policy_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r S r zfDataSafeClientCompositeOperations.change_audit_policy_compartment_and_wait_for_state.<locals>.<lambda>r N) r � change_audit_policy_compartmentr! r" r# r$ r% r& r' ) r �audit_policy_id�'change_audit_policy_compartment_detailsr* r+ r, r- r. r/ r0 r1 r r r �2change_audit_policy_compartment_and_wait_for_state3 s$ � ��zTDataSafeClientCompositeOperations.change_audit_policy_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.data_safe.DataSafeClient.change_audit_profile_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.ChangeAuditProfileCompartmentDetails change_audit_profile_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_audit_profile_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 u r ziDataSafeClientCompositeOperations.change_audit_profile_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r | r zgDataSafeClientCompositeOperations.change_audit_profile_compartment_and_wait_for_state.<locals>.<lambda>r N) r � change_audit_profile_compartmentr! r" r# r$ r% r& r' ) r r> �(change_audit_profile_compartment_detailsr* r+ r, r- r. r/ r0 r1 r r r �3change_audit_profile_compartment_and_wait_for_state\ s$ � ��zUDataSafeClientCompositeOperations.change_audit_profile_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.data_safe.DataSafeClient.change_data_safe_private_endpoint_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str data_safe_private_endpoint_id: (required) The OCID of the private endpoint. :param oci.data_safe.models.ChangeDataSafePrivateEndpointCompartmentDetails change_data_safe_private_endpoint_compartment_details: (required) The details used to change the compartment of a Data Safe private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_data_safe_private_endpoint_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zvDataSafeClientCompositeOperations.change_data_safe_private_endpoint_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r ztDataSafeClientCompositeOperations.change_data_safe_private_endpoint_compartment_and_wait_for_state.<locals>.<lambda>r N) r �-change_data_safe_private_endpoint_compartmentr! r" r# r$ r% r& r' ) r � data_safe_private_endpoint_id�5change_data_safe_private_endpoint_compartment_detailsr* r+ r, r- r. r/ r0 r1 r r r �@change_data_safe_private_endpoint_compartment_and_wait_for_state� s$ � ��zbDataSafeClientCompositeOperations.change_data_safe_private_endpoint_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.data_safe.DataSafeClient.change_report_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_id: (required) Unique report identifier :param oci.data_safe.models.ChangeReportCompartmentDetails change_report_compartment_details: (required) Details for the different Report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_report_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 zbDataSafeClientCompositeOperations.change_report_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z`DataSafeClientCompositeOperations.change_report_compartment_and_wait_for_state.<locals>.<lambda>r N) r �change_report_compartmentr! r" r# r$ r% r& r' ) r � report_id�!change_report_compartment_detailsr* r+ r, r- r. r/ r0 r1 r r r �,change_report_compartment_and_wait_for_state� s$ � ��zNDataSafeClientCompositeOperations.change_report_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.data_safe.DataSafeClient.change_report_definition_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.ChangeReportDefinitionCompartmentDetails change_report_definition_compartment_details: (required) Details for the different ReportDefinition. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_report_definition_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 zmDataSafeClientCompositeOperations.change_report_definition_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zkDataSafeClientCompositeOperations.change_report_definition_compartment_and_wait_for_state.<locals>.<lambda>r N) r �$change_report_definition_compartmentr! r" r# r$ r% r& r' ) r �report_definition_id�,change_report_definition_compartment_detailsr* r+ r, r- r. r/ r0 r1 r r r �7change_report_definition_compartment_and_wait_for_state� s$ � ��zYDataSafeClientCompositeOperations.change_report_definition_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 ) aU Calls :py:func:`~oci.data_safe.DataSafeClient.change_retention` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.ChangeRetentionDetails change_retention_details: (required) Details for the audit retention months to be modified. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_retention` :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 zYDataSafeClientCompositeOperations.change_retention_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zWDataSafeClientCompositeOperations.change_retention_and_wait_for_state.<locals>.<lambda>r N) r �change_retentionr! r" r# r$ r% r& r' ) r r> �change_retention_detailsr* r+ r, r- r. r/ r0 r1 r r r �#change_retention_and_wait_for_state s$ � ��zEDataSafeClientCompositeOperations.change_retention_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.data_safe.DataSafeClient.compare_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.CompareSecurityAssessmentDetails compare_security_assessment_details: (required) Details of the security assessment comparison. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.compare_security_assessment` :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 zdDataSafeClientCompositeOperations.compare_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r I r zbDataSafeClientCompositeOperations.compare_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r �compare_security_assessmentr! r" r# r$ r% r& r' ) r �security_assessment_id�#compare_security_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �.compare_security_assessment_and_wait_for_state) s$ � ��zPDataSafeClientCompositeOperations.compare_security_assessment_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 ) ap Calls :py:func:`~oci.data_safe.DataSafeClient.compare_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.CompareUserAssessmentDetails compare_user_assessment_details: (required) Details of the user assessment comparison. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.compare_user_assessment` :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 k r z`DataSafeClientCompositeOperations.compare_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r r z^DataSafeClientCompositeOperations.compare_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r �compare_user_assessmentr! r" r# r$ r% r& r' ) r �user_assessment_id� compare_user_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �*compare_user_assessment_and_wait_for_stateR s$ � ��zLDataSafeClientCompositeOperations.compare_user_assessment_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 ) a5 Calls :py:func:`~oci.data_safe.DataSafeClient.create_audit_archive_retrieval` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateAuditArchiveRetrievalDetails create_audit_archive_retrieval_details: (required) Details for creating retrieving archived audit data. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_audit_archive_retrieval` :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 zgDataSafeClientCompositeOperations.create_audit_archive_retrieval_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zeDataSafeClientCompositeOperations.create_audit_archive_retrieval_and_wait_for_state.<locals>.<lambda>r N) r � create_audit_archive_retrievalr! r" r# r$ r% r& r' ) r �&create_audit_archive_retrieval_detailsr* r+ r, r- r. r/ r0 r1 r r r �1create_audit_archive_retrieval_and_wait_for_state{ s$ � ��zSDataSafeClientCompositeOperations.create_audit_archive_retrieval_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 ) a5 Calls :py:func:`~oci.data_safe.DataSafeClient.create_data_safe_private_endpoint` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateDataSafePrivateEndpointDetails create_data_safe_private_endpoint_details: (required) Details to create a new private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_data_safe_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zjDataSafeClientCompositeOperations.create_data_safe_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zhDataSafeClientCompositeOperations.create_data_safe_private_endpoint_and_wait_for_state.<locals>.<lambda>r N) r �!create_data_safe_private_endpointr! r" r# r$ r% r& r' ) r �)create_data_safe_private_endpoint_detailsr* r+ r, r- r. r/ r0 r1 r r r �4create_data_safe_private_endpoint_and_wait_for_state� s$ � ��zVDataSafeClientCompositeOperations.create_data_safe_private_endpoint_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.data_safe.DataSafeClient.create_discovery_job` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateDiscoveryJobDetails create_discovery_job_details: (required) The details used to run an incremental data discovery job :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_discovery_job` :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]DataSafeClientCompositeOperations.create_discovery_job_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z[DataSafeClientCompositeOperations.create_discovery_job_and_wait_for_state.<locals>.<lambda>r N) r �create_discovery_jobr! r" r# r$ r% r& r' ) r � create_discovery_job_detailsr* r+ r, r- r. r/ r0 r1 r r r �'create_discovery_job_and_wait_for_state� s$ � ��zIDataSafeClientCompositeOperations.create_discovery_job_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.data_safe.DataSafeClient.create_library_masking_format` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateLibraryMaskingFormatDetails create_library_masking_format_details: (required) Details to create a new library masking format. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_library_masking_format` :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 zfDataSafeClientCompositeOperations.create_library_masking_format_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zdDataSafeClientCompositeOperations.create_library_masking_format_and_wait_for_state.<locals>.<lambda>r N) r � create_library_masking_formatr! r" r# r$ r% r& r' ) r �%create_library_masking_format_detailsr* r+ r, r- r. r/ r0 r1 r r r �0create_library_masking_format_and_wait_for_state� s$ � ��zRDataSafeClientCompositeOperations.create_library_masking_format_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 ) ac Calls :py:func:`~oci.data_safe.DataSafeClient.create_masking_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateMaskingColumnDetails create_masking_column_details: (required) Details to create a new masking column. :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_masking_column` :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^DataSafeClientCompositeOperations.create_masking_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 3 r z\DataSafeClientCompositeOperations.create_masking_column_and_wait_for_state.<locals>.<lambda>r N) r �create_masking_columnr! r" r# r$ r% r& r' ) r � create_masking_column_detailsr4 r* r+ r, r- r. r/ r0 r1 r r r �(create_masking_column_and_wait_for_state s$ � ��zJDataSafeClientCompositeOperations.create_masking_column_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.data_safe.DataSafeClient.create_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateMaskingPolicyDetails create_masking_policy_details: (required) Details to create a new masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_masking_policy` :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^DataSafeClientCompositeOperations.create_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r Y r z\DataSafeClientCompositeOperations.create_masking_policy_and_wait_for_state.<locals>.<lambda>r N) r �create_masking_policyr! r" r# r$ r% r& r' ) r � create_masking_policy_detailsr* r+ r, r- r. r/ r0 r1 r r r �(create_masking_policy_and_wait_for_state< s$ � ��zJDataSafeClientCompositeOperations.create_masking_policy_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.data_safe.DataSafeClient.create_on_prem_connector` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateOnPremConnectorDetails create_on_prem_connector_details: (required) The details used to create a new on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_on_prem_connector` :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 zaDataSafeClientCompositeOperations.create_on_prem_connector_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z_DataSafeClientCompositeOperations.create_on_prem_connector_and_wait_for_state.<locals>.<lambda>r N) r �create_on_prem_connectorr! r" r# r$ r% r& r' ) r � create_on_prem_connector_detailsr* r+ r, r- r. r/ r0 r1 r r r �+create_on_prem_connector_and_wait_for_stateb s$ � ��zMDataSafeClientCompositeOperations.create_on_prem_connector_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.data_safe.DataSafeClient.create_report_definition` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateReportDefinitionDetails create_report_definition_details: (required) Details for the new report definition. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_report_definition` :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 zaDataSafeClientCompositeOperations.create_report_definition_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z_DataSafeClientCompositeOperations.create_report_definition_and_wait_for_state.<locals>.<lambda>r N) r �create_report_definitionr! r" r# r$ r% r& r' ) r � create_report_definition_detailsr* r+ r, r- r. r/ r0 r1 r r r �+create_report_definition_and_wait_for_state� s$ � ��zMDataSafeClientCompositeOperations.create_report_definition_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.data_safe.DataSafeClient.create_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSecurityAssessmentDetails create_security_assessment_details: (required) The details used to create a new saved security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_security_assessment` :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 zcDataSafeClientCompositeOperations.create_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zaDataSafeClientCompositeOperations.create_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r �create_security_assessmentr! r" r# r$ r% r& r' ) r �"create_security_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �-create_security_assessment_and_wait_for_state� s$ � ��zODataSafeClientCompositeOperations.create_security_assessment_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 ) ay Calls :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.CreateSensitiveColumnDetails create_sensitive_column_details: (required) Details to create a new sensitive column. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_column` :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`DataSafeClientCompositeOperations.create_sensitive_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.create_sensitive_column_and_wait_for_state.<locals>.<lambda>r N) r �create_sensitive_columnr! r" r# r$ r% r& r' ) r r: � create_sensitive_column_detailsr* r+ r, r- r. r/ r0 r1 r r r �*create_sensitive_column_and_wait_for_state� s$ � ��zLDataSafeClientCompositeOperations.create_sensitive_column_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.data_safe.DataSafeClient.create_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSensitiveDataModelDetails create_sensitive_data_model_details: (required) Details to create a new sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_data_model` :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 zdDataSafeClientCompositeOperations.create_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zbDataSafeClientCompositeOperations.create_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r N) r �create_sensitive_data_modelr! r" r# r$ r% r& r' ) r �#create_sensitive_data_model_detailsr* r+ r, r- r. r/ r0 r1 r r r �.create_sensitive_data_model_and_wait_for_state� s$ � ��zPDataSafeClientCompositeOperations.create_sensitive_data_model_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.data_safe.DataSafeClient.create_sensitive_type` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSensitiveTypeDetails create_sensitive_type_details: (required) Details to create a new sensitive type. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_type` :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 9 r z^DataSafeClientCompositeOperations.create_sensitive_type_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r @ r z\DataSafeClientCompositeOperations.create_sensitive_type_and_wait_for_state.<locals>.<lambda>r N) r �create_sensitive_typer! r" r# r$ r% r& r' ) r � create_sensitive_type_detailsr* r+ r, r- r. r/ r0 r1 r r r �(create_sensitive_type_and_wait_for_state# s$ � ��zJDataSafeClientCompositeOperations.create_sensitive_type_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 ) aa Calls :py:func:`~oci.data_safe.DataSafeClient.create_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateTargetAlertPolicyAssociationDetails create_target_alert_policy_association_details: (required) The details used to create a new target-alert policy association. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_target_alert_policy_association` :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 zoDataSafeClientCompositeOperations.create_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r f r zmDataSafeClientCompositeOperations.create_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r N) r �&create_target_alert_policy_associationr! r" r# r$ r% r& r' ) r �.create_target_alert_policy_association_detailsr* r+ r, r- r. r/ r0 r1 r r r �9create_target_alert_policy_association_and_wait_for_stateI s$ � ��z[DataSafeClientCompositeOperations.create_target_alert_policy_association_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.data_safe.DataSafeClient.create_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateTargetDatabaseDetails create_target_database_details: (required) Details of the target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_target_database` :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_DataSafeClientCompositeOperations.create_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.create_target_database_and_wait_for_state.<locals>.<lambda>r N) r �create_target_databaser! r" r# r$ r% r& r' ) r � create_target_database_detailsr* r+ r, r- r. r/ r0 r1 r r r �)create_target_database_and_wait_for_stateo s$ � ��zKDataSafeClientCompositeOperations.create_target_database_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.data_safe.DataSafeClient.create_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateUserAssessmentDetails create_user_assessment_details: (required) The details used to create a new saved user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_user_assessment` :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_DataSafeClientCompositeOperations.create_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.create_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r �create_user_assessmentr! r" r# r$ r% r& r' ) r � create_user_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �)create_user_assessment_and_wait_for_state� s$ � ��zKDataSafeClientCompositeOperations.create_user_assessment_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.data_safe.DataSafeClient.deactivate_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.deactivate_target_database` :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 zcDataSafeClientCompositeOperations.deactivate_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zaDataSafeClientCompositeOperations.deactivate_target_database_and_wait_for_state.<locals>.<lambda>r N) r �deactivate_target_databaser! r" r# r$ r% r& r' ) r r) r* r+ r, r- r. r/ r0 r1 r r r �-deactivate_target_database_and_wait_for_state� s$ � ��zODataSafeClientCompositeOperations.deactivate_target_database_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.data_safe.DataSafeClient.delete_audit_archive_retrieval` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_archive_retrieval_id: (required) OCID of the archive retrieval. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_audit_archive_retrieval` :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 zgDataSafeClientCompositeOperations.delete_audit_archive_retrieval_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zeDataSafeClientCompositeOperations.delete_audit_archive_retrieval_and_wait_for_state.<locals>.<lambda>r ) r � delete_audit_archive_retrievalr" r& � ServiceErrorr r r! r# r$ r% r' ) r rE r* r+ r, r- r1 r. r/ r0 r r r �1delete_audit_archive_retrieval_and_wait_for_state� s0 � ��zSDataSafeClientCompositeOperations.delete_audit_archive_retrieval_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.data_safe.DataSafeClient.delete_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_audit_trail` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r - r z[DataSafeClientCompositeOperations.delete_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 4 r zYDataSafeClientCompositeOperations.delete_audit_trail_and_wait_for_state.<locals>.<lambda>r ) r �delete_audit_trailr" r& r� r r r! r# r$ r% r' ) r �audit_trail_idr* r+ r, r- r1 r. r/ r0 r r r �%delete_audit_trail_and_wait_for_state s0 � ��zGDataSafeClientCompositeOperations.delete_audit_trail_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.data_safe.DataSafeClient.delete_data_safe_private_endpoint` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str data_safe_private_endpoint_id: (required) The OCID of the private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_data_safe_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r [ r zjDataSafeClientCompositeOperations.delete_data_safe_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r b r zhDataSafeClientCompositeOperations.delete_data_safe_private_endpoint_and_wait_for_state.<locals>.<lambda>r ) r �!delete_data_safe_private_endpointr" r& r� r r r! r# r$ r% r' ) r rP r* r+ r, r- r1 r. r/ r0 r r r �4delete_data_safe_private_endpoint_and_wait_for_state= s0 � ��zVDataSafeClientCompositeOperations.delete_data_safe_private_endpoint_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.data_safe.DataSafeClient.delete_discovery_job` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str discovery_job_id: (required) The OCID of the discovery job. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_discovery_job` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r � r z]DataSafeClientCompositeOperations.delete_discovery_job_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z[DataSafeClientCompositeOperations.delete_discovery_job_and_wait_for_state.<locals>.<lambda>r ) r �delete_discovery_jobr" r& r� r r r! r# r$ r% r' ) r �discovery_job_idr* r+ r, r- r1 r. r/ r0 r r r �'delete_discovery_job_and_wait_for_statek s0 � ��zIDataSafeClientCompositeOperations.delete_discovery_job_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.data_safe.DataSafeClient.delete_library_masking_format` and waits for the :py:class:`~oci.data_safe.models.LibraryMaskingFormat` acted upon to enter the given state(s). :param str library_masking_format_id: (required) The OCID of the library masking format. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.LibraryMaskingFormat.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_library_masking_format` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r � r zfDataSafeClientCompositeOperations.delete_library_masking_format_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S �N�lifecycle_stater r r r r r � r zdDataSafeClientCompositeOperations.delete_library_masking_format_and_wait_for_state.<locals>.<lambda>T�r �succeed_on_not_found�� �a This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"r )r �get_library_masking_format� delete_library_masking_formatr" r& r� r r r# � NameError� TypeError�argsr' r% ) r �library_masking_format_idr* r+ r, �initial_get_resultr- r1 r/ r0 r r r �0delete_library_masking_format_and_wait_for_state� s< � �� &zRDataSafeClientCompositeOperations.delete_library_masking_format_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.data_safe.DataSafeClient.delete_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_masking_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r � r z^DataSafeClientCompositeOperations.delete_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z\DataSafeClientCompositeOperations.delete_masking_policy_and_wait_for_state.<locals>.<lambda>r ) r �delete_masking_policyr" r& r� r r r! r# r$ r% r' ) r r4 r* r+ r, r- r1 r. r/ r0 r r r �(delete_masking_policy_and_wait_for_state� s0 � ��zJDataSafeClientCompositeOperations.delete_masking_policy_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.data_safe.DataSafeClient.delete_on_prem_connector` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str on_prem_connector_id: (required) The OCID of the on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_on_prem_connector` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r r zaDataSafeClientCompositeOperations.delete_on_prem_connector_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z_DataSafeClientCompositeOperations.delete_on_prem_connector_and_wait_for_state.<locals>.<lambda>r ) r �delete_on_prem_connectorr" r& r� r r r! r# r$ r% r' ) r �on_prem_connector_idr* r+ r, r- r1 r. r/ r0 r r r �+delete_on_prem_connector_and_wait_for_state� s0 � ��zMDataSafeClientCompositeOperations.delete_on_prem_connector_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.data_safe.DataSafeClient.delete_report_definition` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_report_definition` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r G r zaDataSafeClientCompositeOperations.delete_report_definition_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r N r z_DataSafeClientCompositeOperations.delete_report_definition_and_wait_for_state.<locals>.<lambda>r ) r �delete_report_definitionr" r& r� r r r! r# r$ r% r' ) r rX r* r+ r, r- r1 r. r/ r0 r r r �+delete_report_definition_and_wait_for_state) s0 � ��zMDataSafeClientCompositeOperations.delete_report_definition_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.data_safe.DataSafeClient.delete_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_security_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r u r zcDataSafeClientCompositeOperations.delete_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r | r zaDataSafeClientCompositeOperations.delete_security_assessment_and_wait_for_state.<locals>.<lambda>r ) r �delete_security_assessmentr" r& r� r r r! r# r$ r% r' ) r r_ r* r+ r, r- r1 r. r/ r0 r r r �-delete_security_assessment_and_wait_for_stateW s0 � ��zODataSafeClientCompositeOperations.delete_security_assessment_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.data_safe.DataSafeClient.delete_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_sensitive_data_model` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.delete_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.delete_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r ) r �delete_sensitive_data_modelr" r& r� r r r! r# r$ r% r' ) r r: r* r+ r, r- r1 r. r/ r0 r r r �.delete_sensitive_data_model_and_wait_for_state� s0 � ��zPDataSafeClientCompositeOperations.delete_sensitive_data_model_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.data_safe.DataSafeClient.delete_sensitive_type` and waits for the :py:class:`~oci.data_safe.models.SensitiveType` acted upon to enter the given state(s). :param str sensitive_type_id: (required) The OCID of the sensitive type. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.SensitiveType.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_sensitive_type` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r � r z^DataSafeClientCompositeOperations.delete_sensitive_type_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r� r r r r r r � r z\DataSafeClientCompositeOperations.delete_sensitive_type_and_wait_for_state.<locals>.<lambda>Tr� r� r� r )r �get_sensitive_type�delete_sensitive_typer" r& r� r r r# r� r� r� r' r% ) r �sensitive_type_idr* r+ r, r� r- r1 r/ r0 r r r �(delete_sensitive_type_and_wait_for_state� s< � �� &zJDataSafeClientCompositeOperations.delete_sensitive_type_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.data_safe.DataSafeClient.delete_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_alert_policy_association_id: (required) The OCID of the target-alert policy association. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_target_alert_policy_association` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r r zoDataSafeClientCompositeOperations.delete_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zmDataSafeClientCompositeOperations.delete_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r ) r �&delete_target_alert_policy_associationr" r& r� r r r! r# r$ r% r' ) r �"target_alert_policy_association_idr* r+ r, r- r1 r. r/ r0 r r r �9delete_target_alert_policy_association_and_wait_for_state� s0 � ��z[DataSafeClientCompositeOperations.delete_target_alert_policy_association_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.data_safe.DataSafeClient.delete_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r 3 r z_DataSafeClientCompositeOperations.delete_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r : r z]DataSafeClientCompositeOperations.delete_target_database_and_wait_for_state.<locals>.<lambda>r ) r �delete_target_databaser" r& r� r r r! r# r$ r% r' ) r r) r* r+ r, r- r1 r. r/ r0 r r r �)delete_target_database_and_wait_for_state s0 � ��zKDataSafeClientCompositeOperations.delete_target_database_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.data_safe.DataSafeClient.delete_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_user_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nr� c S s g | ] }|� � �qS r r r r r r r a r z_DataSafeClientCompositeOperations.delete_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r h r z]DataSafeClientCompositeOperations.delete_user_assessment_and_wait_for_state.<locals>.<lambda>r ) r �delete_user_assessmentr" r& r� r r r! r# r$ r% r' ) r rc r* r+ r, r- r1 r. r/ r0 r r r �)delete_user_assessment_and_wait_for_stateC s0 � ��zKDataSafeClientCompositeOperations.delete_user_assessment_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.data_safe.DataSafeClient.discover_audit_trails` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.discover_audit_trails` :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^DataSafeClientCompositeOperations.discover_audit_trails_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z\DataSafeClientCompositeOperations.discover_audit_trails_and_wait_for_state.<locals>.<lambda>r N) r �discover_audit_trailsr! r" r# r$ r% r& r' ) r r> r* r+ r, r- r. r/ r0 r1 r r r �(discover_audit_trails_and_wait_for_stateq s$ � ��zJDataSafeClientCompositeOperations.discover_audit_trails_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.data_safe.DataSafeClient.enable_data_safe_configuration` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.EnableDataSafeConfigurationDetails enable_data_safe_configuration_details: (required) The details used to enable Data Safe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.enable_data_safe_configuration` :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 zgDataSafeClientCompositeOperations.enable_data_safe_configuration_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zeDataSafeClientCompositeOperations.enable_data_safe_configuration_and_wait_for_state.<locals>.<lambda>r N) r � enable_data_safe_configurationr! r" r# r$ r% r& r' ) r �&enable_data_safe_configuration_detailsr* r+ r, r- r. r/ r0 r1 r r r �1enable_data_safe_configuration_and_wait_for_state� s$ � ��zSDataSafeClientCompositeOperations.enable_data_safe_configuration_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.data_safe.DataSafeClient.generate_discovery_report_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.GenerateDiscoveryReportForDownloadDetails generate_discovery_report_for_download_details: (required) Details to generate a downloadable discovery report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_discovery_report_for_download` :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 zoDataSafeClientCompositeOperations.generate_discovery_report_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zmDataSafeClientCompositeOperations.generate_discovery_report_for_download_and_wait_for_state.<locals>.<lambda>r N) r �&generate_discovery_report_for_downloadr! r" r# r$ r% r& r' ) r r: �.generate_discovery_report_for_download_detailsr* r+ r, r- r. r/ r0 r1 r r r �9generate_discovery_report_for_download_and_wait_for_state� s$ � ��z[DataSafeClientCompositeOperations.generate_discovery_report_for_download_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.data_safe.DataSafeClient.generate_masking_policy_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.GenerateMaskingPolicyForDownloadDetails generate_masking_policy_for_download_details: (required) Details to generate a masking policy file. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_masking_policy_for_download` :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 zmDataSafeClientCompositeOperations.generate_masking_policy_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zkDataSafeClientCompositeOperations.generate_masking_policy_for_download_and_wait_for_state.<locals>.<lambda>r N) r �$generate_masking_policy_for_downloadr! r" r# r$ r% r& r' ) r r4 �,generate_masking_policy_for_download_detailsr* r+ r, r- r. r/ r0 r1 r r r �7generate_masking_policy_for_download_and_wait_for_state� s$ � ��zYDataSafeClientCompositeOperations.generate_masking_policy_for_download_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.data_safe.DataSafeClient.generate_masking_report_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.GenerateMaskingReportForDownloadDetails generate_masking_report_for_download_details: (required) Details to generate a downloadable masking report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_masking_report_for_download` :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 zmDataSafeClientCompositeOperations.generate_masking_report_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r / r zkDataSafeClientCompositeOperations.generate_masking_report_for_download_and_wait_for_state.<locals>.<lambda>r N) r �$generate_masking_report_for_downloadr! r" r# r$ r% r& r' ) r r4 �,generate_masking_report_for_download_detailsr* r+ r, r- r. r/ r0 r1 r r r �7generate_masking_report_for_download_and_wait_for_state s$ � ��zYDataSafeClientCompositeOperations.generate_masking_report_for_download_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.data_safe.DataSafeClient.generate_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.GenerateReportDetails generate_report_details: (required) Details for report generation. It contains details such as PDF/XLS and filter parameters like audit event time limits, number of rows and target databases etc :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r Q r zXDataSafeClientCompositeOperations.generate_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r X r zVDataSafeClientCompositeOperations.generate_report_and_wait_for_state.<locals>.<lambda>r N) r �generate_reportr! r" r# r$ r% r& r' ) r rX �generate_report_detailsr* r+ r, r- r. r/ r0 r1 r r r �"generate_report_and_wait_for_state8 s$ � ��zDDataSafeClientCompositeOperations.generate_report_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.data_safe.DataSafeClient.generate_security_assessment_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.GenerateSecurityAssessmentReportDetails generate_security_assessment_report_details: (required) Details of the report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_security_assessment_report` :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 z r zlDataSafeClientCompositeOperations.generate_security_assessment_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zjDataSafeClientCompositeOperations.generate_security_assessment_report_and_wait_for_state.<locals>.<lambda>r N) r �#generate_security_assessment_reportr! r" r# r$ r% r& r' ) r r_ �+generate_security_assessment_report_detailsr* r+ r, r- r. r/ r0 r1 r r r �6generate_security_assessment_report_and_wait_for_statea s$ � ��zXDataSafeClientCompositeOperations.generate_security_assessment_report_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.data_safe.DataSafeClient.generate_sensitive_data_model_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.GenerateSensitiveDataModelForDownloadDetails generate_sensitive_data_model_for_download_details: (required) Details to generate a sensitive data model file. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_sensitive_data_model_for_download` :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 zsDataSafeClientCompositeOperations.generate_sensitive_data_model_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zqDataSafeClientCompositeOperations.generate_sensitive_data_model_for_download_and_wait_for_state.<locals>.<lambda>r N) r �*generate_sensitive_data_model_for_downloadr! r" r# r$ r% r& r' ) r r: �2generate_sensitive_data_model_for_download_detailsr* r+ r, r- r. r/ r0 r1 r r r �=generate_sensitive_data_model_for_download_and_wait_for_state� s$ � ��z_DataSafeClientCompositeOperations.generate_sensitive_data_model_for_download_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.data_safe.DataSafeClient.generate_user_assessment_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.GenerateUserAssessmentReportDetails generate_user_assessment_report_details: (required) Details of the report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_user_assessment_report` :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 zhDataSafeClientCompositeOperations.generate_user_assessment_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zfDataSafeClientCompositeOperations.generate_user_assessment_report_and_wait_for_state.<locals>.<lambda>r N) r � generate_user_assessment_reportr! r" r# r$ r% r& r' ) r rc �'generate_user_assessment_report_detailsr* r+ r, r- r. r/ r0 r1 r r r �2generate_user_assessment_report_and_wait_for_state� s$ � ��zTDataSafeClientCompositeOperations.generate_user_assessment_report_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.data_safe.DataSafeClient.mask_data` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.MaskDataDetails mask_data_details: (required) Details to mask data. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.mask_data` :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 zRDataSafeClientCompositeOperations.mask_data_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zPDataSafeClientCompositeOperations.mask_data_and_wait_for_state.<locals>.<lambda>r N) r � mask_datar! r" r# r$ r% r& r' ) r r4 �mask_data_detailsr* r+ r, r- r. r/ r0 r1 r r r � mask_data_and_wait_for_state� s$ � ��z>DataSafeClientCompositeOperations.mask_data_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 ) ar Calls :py:func:`~oci.data_safe.DataSafeClient.modify_global_settings` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.ModifyGlobalSettingsDetails modify_global_settings_details: (required) The details used to update global settings in Data Safe. :param str compartment_id: (required) The OCID of the compartment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.modify_global_settings` :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_DataSafeClientCompositeOperations.modify_global_settings_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r % r z]DataSafeClientCompositeOperations.modify_global_settings_and_wait_for_state.<locals>.<lambda>r N) r �modify_global_settingsr! r" r# r$ r% r& r' ) r � modify_global_settings_details�compartment_idr* r+ r, r- r. r/ r0 r1 r r r �)modify_global_settings_and_wait_for_state s$ � ��zKDataSafeClientCompositeOperations.modify_global_settings_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.data_safe.DataSafeClient.patch_alerts` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.PatchAlertsDetails patch_alerts_details: (required) Details to patch alerts. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_alerts` :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 zUDataSafeClientCompositeOperations.patch_alerts_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r K r zSDataSafeClientCompositeOperations.patch_alerts_and_wait_for_state.<locals>.<lambda>r N) r � patch_alertsr! r" r# r$ r% r& r' ) r �patch_alerts_detailsr* r+ r, r- r. r/ r0 r1 r r r � patch_alerts_and_wait_for_state. s$ � ��zADataSafeClientCompositeOperations.patch_alerts_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 ) ar Calls :py:func:`~oci.data_safe.DataSafeClient.patch_discovery_job_results` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str discovery_job_id: (required) The OCID of the discovery job. :param oci.data_safe.models.PatchDiscoveryJobResultDetails patch_discovery_job_result_details: (required) Details to patch discovery results. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_discovery_job_results` :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 m r zdDataSafeClientCompositeOperations.patch_discovery_job_results_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r t r zbDataSafeClientCompositeOperations.patch_discovery_job_results_and_wait_for_state.<locals>.<lambda>r N) r �patch_discovery_job_resultsr! r" r# r$ r% r& r' ) r r� �"patch_discovery_job_result_detailsr* r+ r, r- r. r/ r0 r1 r r r �.patch_discovery_job_results_and_wait_for_stateT s$ � ��zPDataSafeClientCompositeOperations.patch_discovery_job_results_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.data_safe.DataSafeClient.patch_masking_columns` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.PatchMaskingColumnsDetails patch_masking_columns_details: (required) Details to patch masking columns. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_masking_columns` :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^DataSafeClientCompositeOperations.patch_masking_columns_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z\DataSafeClientCompositeOperations.patch_masking_columns_and_wait_for_state.<locals>.<lambda>r N) r �patch_masking_columnsr! r" r# r$ r% r& r' ) r r4 � patch_masking_columns_detailsr* r+ r, r- r. r/ r0 r1 r r r �(patch_masking_columns_and_wait_for_state} s$ � ��zJDataSafeClientCompositeOperations.patch_masking_columns_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 ) aq Calls :py:func:`~oci.data_safe.DataSafeClient.patch_sensitive_columns` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.PatchSensitiveColumnDetails patch_sensitive_column_details: (required) Details to patch sensitive columns. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_sensitive_columns` :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`DataSafeClientCompositeOperations.patch_sensitive_columns_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.patch_sensitive_columns_and_wait_for_state.<locals>.<lambda>r N) r �patch_sensitive_columnsr! r" r# r$ r% r& r' ) r r: � patch_sensitive_column_detailsr* r+ r, r- r. r/ r0 r1 r r r �*patch_sensitive_columns_and_wait_for_state� s$ � ��zLDataSafeClientCompositeOperations.patch_sensitive_columns_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 ) aW Calls :py:func:`~oci.data_safe.DataSafeClient.patch_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.PatchTargetAlertPolicyAssociationDetails patch_target_alert_policy_association_details: (required) The details used to patch target-alert policy associations. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_target_alert_policy_association` :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 znDataSafeClientCompositeOperations.patch_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zlDataSafeClientCompositeOperations.patch_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r N) r �%patch_target_alert_policy_associationr! r" r# r$ r% r& r' ) r �-patch_target_alert_policy_association_detailsr* r+ r, r- r. r/ r0 r1 r r r �8patch_target_alert_policy_association_and_wait_for_state� s$ � ��zZDataSafeClientCompositeOperations.patch_target_alert_policy_association_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.data_safe.DataSafeClient.provision_audit_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.ProvisionAuditPolicyDetails provision_audit_policy_details: (required) Details for provisioning the given policies on the source target database. :param str audit_policy_id: (required) Unique audit policy identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.provision_audit_policy` :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_DataSafeClientCompositeOperations.provision_audit_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z]DataSafeClientCompositeOperations.provision_audit_policy_and_wait_for_state.<locals>.<lambda>r N) r �provision_audit_policyr! r" r# r$ r% r& r' ) r � provision_audit_policy_detailsrI r* r+ r, r- r. r/ r0 r1 r r r �)provision_audit_policy_and_wait_for_state� s$ � ��zKDataSafeClientCompositeOperations.provision_audit_policy_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.data_safe.DataSafeClient.refresh_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.RunSecurityAssessmentDetails run_security_assessment_details: (required) Details to create an on-demand saved security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.refresh_security_assessment` :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 7 r zdDataSafeClientCompositeOperations.refresh_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r > r zbDataSafeClientCompositeOperations.refresh_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r �refresh_security_assessmentr! r" r# r$ r% r& r' ) r r_ � run_security_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �.refresh_security_assessment_and_wait_for_state s$ � ��zPDataSafeClientCompositeOperations.refresh_security_assessment_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.data_safe.DataSafeClient.refresh_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.RunUserAssessmentDetails run_user_assessment_details: (required) The details required to create an on-demand saved user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.refresh_user_assessment` :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`DataSafeClientCompositeOperations.refresh_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r g r z^DataSafeClientCompositeOperations.refresh_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r �refresh_user_assessmentr! r" r# r$ r% r& r' ) r rc �run_user_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �*refresh_user_assessment_and_wait_for_stateG s$ � ��zLDataSafeClientCompositeOperations.refresh_user_assessment_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.data_safe.DataSafeClient.remove_schedule_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.remove_schedule_report` :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_DataSafeClientCompositeOperations.remove_schedule_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.remove_schedule_report_and_wait_for_state.<locals>.<lambda>r N) r �remove_schedule_reportr! r" r# r$ r% r& r' ) r rX r* r+ r, r- r. r/ r0 r1 r r r �)remove_schedule_report_and_wait_for_statep s$ � ��zKDataSafeClientCompositeOperations.remove_schedule_report_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.data_safe.DataSafeClient.resume_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.resume_audit_trail` :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[DataSafeClientCompositeOperations.resume_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zYDataSafeClientCompositeOperations.resume_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r �resume_audit_trailr! r" r# r$ r% r& r' � r r� r* r+ r, r- r. r/ r0 r1 r r r �%resume_audit_trail_and_wait_for_state� s$ � ��zGDataSafeClientCompositeOperations.resume_audit_trail_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.data_safe.DataSafeClient.retrieve_audit_policies` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_policy_id: (required) Unique audit policy identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.retrieve_audit_policies` :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`DataSafeClientCompositeOperations.retrieve_audit_policies_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.retrieve_audit_policies_and_wait_for_state.<locals>.<lambda>r N) r �retrieve_audit_policiesr! r" r# r$ r% r& r' ) r rI r* r+ r, r- r. r/ r0 r1 r r r �*retrieve_audit_policies_and_wait_for_state� s$ � ��zLDataSafeClientCompositeOperations.retrieve_audit_policies_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.data_safe.DataSafeClient.schedule_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.ScheduleReportDetails schedule_report_details: (required) Details for report schedule. It contains details such as schedule, PDF/XLS and number of rows. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.schedule_report` :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 zXDataSafeClientCompositeOperations.schedule_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zVDataSafeClientCompositeOperations.schedule_report_and_wait_for_state.<locals>.<lambda>r N) r �schedule_reportr! r" r# r$ r% r& r' ) r rX �schedule_report_detailsr* r+ r, r- r. r/ r0 r1 r r r �"schedule_report_and_wait_for_state� s$ � ��zDDataSafeClientCompositeOperations.schedule_report_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.data_safe.DataSafeClient.set_security_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.set_security_assessment_baseline` :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 ziDataSafeClientCompositeOperations.set_security_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ( r zgDataSafeClientCompositeOperations.set_security_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r � set_security_assessment_baseliner! r" r# r$ r% r& r' � r r_ r* r+ r, r- r. r/ r0 r1 r r r �3set_security_assessment_baseline_and_wait_for_state s$ � ��zUDataSafeClientCompositeOperations.set_security_assessment_baseline_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.data_safe.DataSafeClient.set_user_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.set_user_assessment_baseline` :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 zeDataSafeClientCompositeOperations.set_user_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r N r zcDataSafeClientCompositeOperations.set_user_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r � set_user_assessment_baseliner! r" r# r$ r% r& r' � r rc r* r+ r, r- r. r/ r0 r1 r r r �/set_user_assessment_baseline_and_wait_for_state1 s$ � ��zQDataSafeClientCompositeOperations.set_user_assessment_baseline_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 ) aE Calls :py:func:`~oci.data_safe.DataSafeClient.start_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.StartAuditTrailDetails start_audit_trail_details: (required) Details for the starting audit. :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.start_audit_trail` :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 p r zZDataSafeClientCompositeOperations.start_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r w r zXDataSafeClientCompositeOperations.start_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r �start_audit_trailr! r" r# r$ r% r& r' ) r �start_audit_trail_detailsr� r* r+ r, r- r. r/ r0 r1 r r r �$start_audit_trail_and_wait_for_stateW s$ � ��zFDataSafeClientCompositeOperations.start_audit_trail_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.data_safe.DataSafeClient.stop_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.stop_audit_trail` :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 zYDataSafeClientCompositeOperations.stop_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zWDataSafeClientCompositeOperations.stop_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r �stop_audit_trailr! r" r# r$ r% r& r' r r r r �#stop_audit_trail_and_wait_for_state� s$ � ��zEDataSafeClientCompositeOperations.stop_audit_trail_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.data_safe.DataSafeClient.unset_security_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.unset_security_assessment_baseline` :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 zkDataSafeClientCompositeOperations.unset_security_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r ziDataSafeClientCompositeOperations.unset_security_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r �"unset_security_assessment_baseliner! r" r# r$ r% r& r' r r r r �5unset_security_assessment_baseline_and_wait_for_state� s$ � ��zWDataSafeClientCompositeOperations.unset_security_assessment_baseline_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.data_safe.DataSafeClient.unset_user_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.unset_user_assessment_baseline` :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 zgDataSafeClientCompositeOperations.unset_user_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zeDataSafeClientCompositeOperations.unset_user_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r � unset_user_assessment_baseliner! r" r# r$ r% r& r' r r r r �1unset_user_assessment_baseline_and_wait_for_state� s$ � ��zSDataSafeClientCompositeOperations.unset_user_assessment_baseline_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 ) a3 Calls :py:func:`~oci.data_safe.DataSafeClient.update_alert` and waits for the :py:class:`~oci.data_safe.models.Alert` acted upon to enter the given state(s). :param str alert_id: (required) The OCID of alert. :param oci.data_safe.models.UpdateAlertDetails update_alert_details: (required) The details used to update alert status. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.Alert.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_alert` :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 zUDataSafeClientCompositeOperations.update_alert_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r� r r r r r r r zSDataSafeClientCompositeOperations.update_alert_and_wait_for_state.<locals>.<lambda>r� r� r N) r � update_alertr �idr" r# � get_alertr� r� r� r& r' r% ) r �alert_id�update_alert_detailsr* r+ r, r- r/ r0 r1 r r r � update_alert_and_wait_for_state� s. � �� &zADataSafeClientCompositeOperations.update_alert_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.data_safe.DataSafeClient.update_audit_archive_retrieval` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_archive_retrieval_id: (required) OCID of the archive retrieval. :param oci.data_safe.models.UpdateAuditArchiveRetrievalDetails update_audit_archive_retrieval_details: (required) Details to update the audit archive retrieval. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_archive_retrieval` :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 9 r zgDataSafeClientCompositeOperations.update_audit_archive_retrieval_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r @ r zeDataSafeClientCompositeOperations.update_audit_archive_retrieval_and_wait_for_state.<locals>.<lambda>r N) r � update_audit_archive_retrievalr! r" r# r$ r% r& r' ) r rE �&update_audit_archive_retrieval_detailsr* r+ r, r- r. r/ r0 r1 r r r �1update_audit_archive_retrieval_and_wait_for_state s$ � ��zSDataSafeClientCompositeOperations.update_audit_archive_retrieval_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 ) aU Calls :py:func:`~oci.data_safe.DataSafeClient.update_audit_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_policy_id: (required) Unique audit policy identifier. :param oci.data_safe.models.UpdateAuditPolicyDetails update_audit_policy_details: (required) Details to update the audit policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_policy` :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 z\DataSafeClientCompositeOperations.update_audit_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r i r zZDataSafeClientCompositeOperations.update_audit_policy_and_wait_for_state.<locals>.<lambda>r N) r �update_audit_policyr! r" r# r$ r% r& r' ) r rI �update_audit_policy_detailsr* r+ r, r- r. r/ r0 r1 r r r �&update_audit_policy_and_wait_for_stateI s$ � ��zHDataSafeClientCompositeOperations.update_audit_policy_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 ) aL Calls :py:func:`~oci.data_safe.DataSafeClient.update_audit_profile` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.UpdateAuditProfileDetails update_audit_profile_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.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_profile` :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]DataSafeClientCompositeOperations.update_audit_profile_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z[DataSafeClientCompositeOperations.update_audit_profile_and_wait_for_state.<locals>.<lambda>r N) r �update_audit_profiler! r" r# r$ r% r& r' ) r r> � update_audit_profile_detailsr* r+ r, r- r. r/ r0 r1 r r r �'update_audit_profile_and_wait_for_stater s$ � ��zIDataSafeClientCompositeOperations.update_audit_profile_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 ) aH Calls :py:func:`~oci.data_safe.DataSafeClient.update_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param oci.data_safe.models.UpdateAuditTrailDetails update_audit_trail_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.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_trail` :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[DataSafeClientCompositeOperations.update_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zYDataSafeClientCompositeOperations.update_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r �update_audit_trailr! r" r# r$ r% r& r' ) r r� �update_audit_trail_detailsr* r+ r, r- r. r/ r0 r1 r r r �%update_audit_trail_and_wait_for_state� s$ � ��zGDataSafeClientCompositeOperations.update_audit_trail_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.data_safe.DataSafeClient.update_data_safe_private_endpoint` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str data_safe_private_endpoint_id: (required) The OCID of the private endpoint. :param oci.data_safe.models.UpdateDataSafePrivateEndpointDetails update_data_safe_private_endpoint_details: (required) The details used to update a Data Safe private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_data_safe_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zjDataSafeClientCompositeOperations.update_data_safe_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zhDataSafeClientCompositeOperations.update_data_safe_private_endpoint_and_wait_for_state.<locals>.<lambda>r N) r �!update_data_safe_private_endpointr! r" r# r$ r% r& r' ) r rP �)update_data_safe_private_endpoint_detailsr* r+ r, r- r. r/ r0 r1 r r r �4update_data_safe_private_endpoint_and_wait_for_state� s$ � ��zVDataSafeClientCompositeOperations.update_data_safe_private_endpoint_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.data_safe.DataSafeClient.update_library_masking_format` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str library_masking_format_id: (required) The OCID of the library masking format. :param oci.data_safe.models.UpdateLibraryMaskingFormatDetails update_library_masking_format_details: (required) Details to update a library masking format. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_library_masking_format` :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 zfDataSafeClientCompositeOperations.update_library_masking_format_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zdDataSafeClientCompositeOperations.update_library_masking_format_and_wait_for_state.<locals>.<lambda>r N) r � update_library_masking_formatr! r" r# r$ r% r& r' ) r r� �%update_library_masking_format_detailsr* r+ r, r- r. r/ r0 r1 r r r �0update_library_masking_format_and_wait_for_state� s$ � ��zRDataSafeClientCompositeOperations.update_library_masking_format_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.data_safe.DataSafeClient.update_masking_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_column_key: (required) The unique key that identifies the masking column. It's numeric and unique within a masking policy. :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.UpdateMaskingColumnDetails update_masking_column_details: (required) Details to update a masking column. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_masking_column` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 2 r z^DataSafeClientCompositeOperations.update_masking_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 9 r z\DataSafeClientCompositeOperations.update_masking_column_and_wait_for_state.<locals>.<lambda>r N) r �update_masking_columnr! r" r# r$ r% r& r' ) r �masking_column_keyr4 � update_masking_column_detailsr* r+ r, r- r. r/ r0 r1 r r r �(update_masking_column_and_wait_for_state s$ � ��zJDataSafeClientCompositeOperations.update_masking_column_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.data_safe.DataSafeClient.update_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.UpdateMaskingPolicyDetails update_masking_policy_details: (required) Details to update a masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_masking_policy` :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^DataSafeClientCompositeOperations.update_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r b r z\DataSafeClientCompositeOperations.update_masking_policy_and_wait_for_state.<locals>.<lambda>r N) r �update_masking_policyr! r" r# r$ r% r& r' ) r r4 � update_masking_policy_detailsr* r+ r, r- r. r/ r0 r1 r r r �(update_masking_policy_and_wait_for_stateB s$ � ��zJDataSafeClientCompositeOperations.update_masking_policy_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.data_safe.DataSafeClient.update_on_prem_connector` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str on_prem_connector_id: (required) The OCID of the on-premises connector. :param oci.data_safe.models.UpdateOnPremConnectorDetails update_on_prem_connector_details: (required) The details used to update a on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_on_prem_connector` :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 zaDataSafeClientCompositeOperations.update_on_prem_connector_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z_DataSafeClientCompositeOperations.update_on_prem_connector_and_wait_for_state.<locals>.<lambda>r N) r �update_on_prem_connectorr! r" r# r$ r% r& r' ) r r� � update_on_prem_connector_detailsr* r+ r, r- r. r/ r0 r1 r r r �+update_on_prem_connector_and_wait_for_statek s$ � ��zMDataSafeClientCompositeOperations.update_on_prem_connector_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.data_safe.DataSafeClient.update_on_prem_connector_wallet` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.UpdateOnPremConnectorWalletDetails update_on_prem_connector_wallet_details: (required) The details used to update an on-premises connector's wallet. :param str on_prem_connector_id: (required) The OCID of the on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_on_prem_connector_wallet` :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 zhDataSafeClientCompositeOperations.update_on_prem_connector_wallet_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zfDataSafeClientCompositeOperations.update_on_prem_connector_wallet_and_wait_for_state.<locals>.<lambda>r N) r � update_on_prem_connector_walletr! r" r# r$ r% r& r' ) r �'update_on_prem_connector_wallet_detailsr� r* r+ r, r- r. r/ r0 r1 r r r �2update_on_prem_connector_wallet_and_wait_for_state� s$ � ��zTDataSafeClientCompositeOperations.update_on_prem_connector_wallet_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 ) az Calls :py:func:`~oci.data_safe.DataSafeClient.update_report_definition` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.UpdateReportDefinitionDetails update_report_definition_details: (required) Details for the modified report definition. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_report_definition` :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 zaDataSafeClientCompositeOperations.update_report_definition_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z_DataSafeClientCompositeOperations.update_report_definition_and_wait_for_state.<locals>.<lambda>r N) r �update_report_definitionr! r" r# r$ r% r& r' ) r rX � update_report_definition_detailsr* r+ r, r- r. r/ r0 r1 r r r �+update_report_definition_and_wait_for_state� s$ � ��zMDataSafeClientCompositeOperations.update_report_definition_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 ) ax Calls :py:func:`~oci.data_safe.DataSafeClient.update_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.UpdateSecurityAssessmentDetails update_security_assessment_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.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_security_assessment` :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 zcDataSafeClientCompositeOperations.update_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zaDataSafeClientCompositeOperations.update_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r �update_security_assessmentr! r" r# r$ r% r& r' ) r r_ �"update_security_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �-update_security_assessment_and_wait_for_state� s$ � ��zODataSafeClientCompositeOperations.update_security_assessment_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.data_safe.DataSafeClient.update_sensitive_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param str sensitive_column_key: (required) The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model. :param oci.data_safe.models.UpdateSensitiveColumnDetails update_sensitive_column_details: (required) Details to update a sensitive column. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_column` :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`DataSafeClientCompositeOperations.update_sensitive_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 2 r z^DataSafeClientCompositeOperations.update_sensitive_column_and_wait_for_state.<locals>.<lambda>r N) r �update_sensitive_columnr! r" r# r$ r% r& r' ) r r: �sensitive_column_key� update_sensitive_column_detailsr* r+ r, r- r. r/ r0 r1 r r r �*update_sensitive_column_and_wait_for_state s$ � ��zLDataSafeClientCompositeOperations.update_sensitive_column_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.data_safe.DataSafeClient.update_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.UpdateSensitiveDataModelDetails update_sensitive_data_model_details: (required) Details to update a sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_data_model` :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 T r zdDataSafeClientCompositeOperations.update_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r [ r zbDataSafeClientCompositeOperations.update_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r N) r �update_sensitive_data_modelr! r" r# r$ r% r& r' ) r r: �#update_sensitive_data_model_detailsr* r+ r, r- r. r/ r0 r1 r r r �.update_sensitive_data_model_and_wait_for_state; s$ � ��zPDataSafeClientCompositeOperations.update_sensitive_data_model_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.data_safe.DataSafeClient.update_sensitive_type` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_type_id: (required) The OCID of the sensitive type. :param oci.data_safe.models.UpdateSensitiveTypeDetails update_sensitive_type_details: (required) Details to update a sensitive type. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_type` :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^DataSafeClientCompositeOperations.update_sensitive_type_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z\DataSafeClientCompositeOperations.update_sensitive_type_and_wait_for_state.<locals>.<lambda>r N) r �update_sensitive_typer! r" r# r$ r% r& r' ) r r� � update_sensitive_type_detailsr* r+ r, r- r. r/ r0 r1 r r r �(update_sensitive_type_and_wait_for_stated s$ � ��zJDataSafeClientCompositeOperations.update_sensitive_type_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.data_safe.DataSafeClient.update_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_alert_policy_association_id: (required) The OCID of the target-alert policy association. :param oci.data_safe.models.UpdateTargetAlertPolicyAssociationDetails update_target_alert_policy_association_details: (required) The details used to update the target-alert policy association. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_target_alert_policy_association` :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 zoDataSafeClientCompositeOperations.update_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zmDataSafeClientCompositeOperations.update_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r N) r �&update_target_alert_policy_associationr! r" r# r$ r% r& r' ) r r� �.update_target_alert_policy_association_detailsr* r+ r, r- r. r/ r0 r1 r r r �9update_target_alert_policy_association_and_wait_for_state� s$ � ��z[DataSafeClientCompositeOperations.update_target_alert_policy_association_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.data_safe.DataSafeClient.update_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param oci.data_safe.models.UpdateTargetDatabaseDetails update_target_database_details: (required) Details used to update the target database in Data Safe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_target_database` :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_DataSafeClientCompositeOperations.update_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.update_target_database_and_wait_for_state.<locals>.<lambda>r N) r �update_target_databaser! r" r# r$ r% r& r' ) r r) � update_target_database_detailsr* r+ r, r- r. r/ r0 r1 r r r �)update_target_database_and_wait_for_state� s$ � ��zKDataSafeClientCompositeOperations.update_target_database_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.data_safe.DataSafeClient.update_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.UpdateUserAssessmentDetails update_user_assessment_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.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_user_assessment` :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_DataSafeClientCompositeOperations.update_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.update_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r �update_user_assessmentr! r" r# r$ r% r& r' ) r rc � update_user_assessment_detailsr* r+ r, r- r. r/ r0 r1 r r r �)update_user_assessment_and_wait_for_state� s$ � ��zKDataSafeClientCompositeOperations.update_user_assessment_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.data_safe.DataSafeClient.upload_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param stream upload_masking_policy_details: (required) Details to upload a masking policy file. :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.upload_masking_policy` :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^DataSafeClientCompositeOperations.upload_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ( r z\DataSafeClientCompositeOperations.upload_masking_policy_and_wait_for_state.<locals>.<lambda>r N) r �upload_masking_policyr! r" r# r$ r% r& r' ) r � upload_masking_policy_detailsr4 r* r+ r, r- r. r/ r0 r1 r r r �(upload_masking_policy_and_wait_for_state s$ � ��zJDataSafeClientCompositeOperations.upload_masking_policy_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.data_safe.DataSafeClient.upload_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param stream upload_sensitive_data_model_details: (required) Details to upload a sensitive data model file. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.upload_sensitive_data_model` :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 J r zdDataSafeClientCompositeOperations.upload_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r Q r zbDataSafeClientCompositeOperations.upload_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r N) r �upload_sensitive_data_modelr! r" r# r$ r% r& r' ) r r: �#upload_sensitive_data_model_detailsr* r+ r, r- r. r/ r0 r1 r r r �.upload_sensitive_data_model_and_wait_for_state1 s$ � ��zPDataSafeClientCompositeOperations.upload_sensitive_data_model_and_wait_for_stateN)d�__name__� __module__� __qualname__�__doc__r r2 r5 r8 r< r@ rC rG rK rN rR rV rZ r] ra re rh rk rn rq rt rw rz 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� 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 r r r# r& r) r, r/ r3 r6 r9 r< r? rB rF rI rL rO rR rU rX r[ r r r r r s� )&&))))))))))))&&&&)&&&&)&&&&&&....4.....4...&&)))))))))&)))&)))&&&)&&)&&&.)))))),))))),))))))r )r" �oci.utilr �objectr r r r r �<module> s
cải xoăn