/
lib
/
python3.9
/
site-packages
/
oci
/
log_analytics
/
__pycache__
/
Upload File
HOME
a ���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 d<S )=�%LogAnalyticsClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.log_analytics.LogAnalyticsClient` 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 LogAnalyticsClientCompositeOperations object :param LogAnalyticsClient client: The service client which will be wrapped by this object N)�client)�selfr �kwargs� r �_/usr/lib/python3.9/site-packages/oci/log_analytics/log_analytics_client_composite_operations.py�__init__ s z.LogAnalyticsClientCompositeOperations.__init__c s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.append_lookup_data` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str lookup_name: (required) The name of the lookup to operate on. :param stream append_lookup_file_body: (required) The file to append. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.append_lookup_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 ��lower��.0�wr r r � <listcomp>7 � z_LogAnalyticsClientCompositeOperations.append_lookup_data_and_wait_for_state.<locals>.<listcomp>�opc-work-request-id�evaluate_responsec s t | jd�o t | jd��� � v S �N�status��getattr�datar ��r�Zlowered_wait_for_statesr r �<lambda>@ r z]LogAnalyticsClientCompositeOperations.append_lookup_data_and_wait_for_state.<locals>.<lambda>�Zpartial_results�causeN) r Zappend_lookup_data�headers�oci� wait_until�get_work_request� Exception� exceptions�CompositeOperationError) r �namespace_name� lookup_nameZappend_lookup_file_body�wait_for_states�operation_kwargs� waiter_kwargs�operation_result�wait_for_resource_id� waiter_result�result_to_return�er r r �%append_lookup_data_and_wait_for_state s( � ��zKLogAnalyticsClientCompositeOperations.append_lookup_data_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.assign_encryption_key` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.AssignEncryptionKeyDetails assign_encryption_key_details: (required) This is the input to assign customer encryption key. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.assign_encryption_key` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r a r zbLogAnalyticsClientCompositeOperations.assign_encryption_key_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r j r z`LogAnalyticsClientCompositeOperations.assign_encryption_key_and_wait_for_state.<locals>.<lambda>r N) r Zassign_encryption_keyr r r r! r" r# r$ ) r r% Z assign_encryption_key_detailsr' r( r) r* r+ r, r- r. r r r �(assign_encryption_key_and_wait_for_stateI s( � ��zNLogAnalyticsClientCompositeOperations.assign_encryption_key_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.create_ingest_time_rule` and waits for the :py:class:`~oci.log_analytics.models.IngestTimeRule` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.CreateIngestTimeRuleDetails create_ingest_time_rule_details: (required) Details of the new ingest time rule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.IngestTimeRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.create_ingest_time_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zdLogAnalyticsClientCompositeOperations.create_ingest_time_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S �NZlifecycle_stater r r r r r � r zbLogAnalyticsClientCompositeOperations.create_ingest_time_rule_and_wait_for_state.<locals>.<lambda>�� �a This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"r N) r Zcreate_ingest_time_ruler �idr r �get_ingest_time_rule� NameError� TypeError�argsr# r$ r" ) r r% Z create_ingest_time_rule_detailsr' r( r) r* �ingest_time_rule_idr, r- r. r r r �*create_ingest_time_rule_and_wait_for_states s. � �� &zPLogAnalyticsClientCompositeOperations.create_ingest_time_rule_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.create_log_analytics_em_bridge` and waits for the :py:class:`~oci.log_analytics.models.LogAnalyticsEmBridge` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.CreateLogAnalyticsEmBridgeDetails create_log_analytics_em_bridge_details: (required) Details for the enterprise manager bridge. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.LogAnalyticsEmBridge.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.create_log_analytics_em_bridge` :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 zkLogAnalyticsClientCompositeOperations.create_log_analytics_em_bridge_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r � r ziLogAnalyticsClientCompositeOperations.create_log_analytics_em_bridge_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Z create_log_analytics_em_bridger r5 r r �get_log_analytics_em_bridger7 r8 r9 r# r$ r" ) r r% Z&create_log_analytics_em_bridge_detailsr' r( r) r* �log_analytics_em_bridge_idr, r- r. r r r �1create_log_analytics_em_bridge_and_wait_for_state� s. � �� &zWLogAnalyticsClientCompositeOperations.create_log_analytics_em_bridge_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.create_log_analytics_entity` and waits for the :py:class:`~oci.log_analytics.models.LogAnalyticsEntity` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.CreateLogAnalyticsEntityDetails create_log_analytics_entity_details: (required) Details for the new log analytics entity. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.LogAnalyticsEntity.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.create_log_analytics_entity` :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 zhLogAnalyticsClientCompositeOperations.create_log_analytics_entity_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r � r zfLogAnalyticsClientCompositeOperations.create_log_analytics_entity_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zcreate_log_analytics_entityr r5 r r �get_log_analytics_entityr7 r8 r9 r# r$ r" ) r r% Z#create_log_analytics_entity_detailsr' r( r) r* �log_analytics_entity_idr, r- r. r r r �.create_log_analytics_entity_and_wait_for_state� s. � �� &zTLogAnalyticsClientCompositeOperations.create_log_analytics_entity_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.create_log_analytics_object_collection_rule` and waits for the :py:class:`~oci.log_analytics.models.LogAnalyticsObjectCollectionRule` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.CreateLogAnalyticsObjectCollectionRuleDetails create_log_analytics_object_collection_rule_details: (required) Details of the rule to be created. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.LogAnalyticsObjectCollectionRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.create_log_analytics_object_collection_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zxLogAnalyticsClientCompositeOperations.create_log_analytics_object_collection_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r r zvLogAnalyticsClientCompositeOperations.create_log_analytics_object_collection_rule_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Z+create_log_analytics_object_collection_ruler r5 r r �(get_log_analytics_object_collection_ruler7 r8 r9 r# r$ r" ) r r% Z3create_log_analytics_object_collection_rule_detailsr' r( r) r* �'log_analytics_object_collection_rule_idr, r- r. r r r �>create_log_analytics_object_collection_rule_and_wait_for_state� s. � �� &zdLogAnalyticsClientCompositeOperations.create_log_analytics_object_collection_rule_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.create_scheduled_task` and waits for the :py:class:`~oci.log_analytics.models.ScheduledTask` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.CreateScheduledTaskDetails create_scheduled_task_details: (required) Scheduled task to be created. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.ScheduledTask.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.create_scheduled_task` :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 zbLogAnalyticsClientCompositeOperations.create_scheduled_task_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r F r z`LogAnalyticsClientCompositeOperations.create_scheduled_task_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zcreate_scheduled_taskr r5 r r �get_scheduled_taskr7 r8 r9 r# r$ r" ) r r% Z create_scheduled_task_detailsr' r( r) r* �scheduled_task_idr, r- r. r r r �(create_scheduled_task_and_wait_for_state' s. � �� &zNLogAnalyticsClientCompositeOperations.create_scheduled_task_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.delete_associations` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.DeleteLogAnalyticsAssociationDetails delete_log_analytics_association_details: (required) details for association :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.delete_associations` :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 z`LogAnalyticsClientCompositeOperations.delete_associations_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r u r z^LogAnalyticsClientCompositeOperations.delete_associations_and_wait_for_state.<locals>.<lambda>r N) r Zdelete_associationsr r r r! r" r# r$ ) r r% Z(delete_log_analytics_association_detailsr' r( r) r* r+ r, r- r. r r r �&delete_associations_and_wait_for_stateT s( � ��zLLogAnalyticsClientCompositeOperations.delete_associations_and_wait_for_statec s d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� d|jvr�|S |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.log_analytics.LogAnalyticsClient.delete_lookup` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str lookup_name: (required) The name of the lookup to operate on. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.delete_lookup` :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 Ni� c S s g | ] }|� � �qS r r r r r r r � r zZLogAnalyticsClientCompositeOperations.delete_lookup_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 zXLogAnalyticsClientCompositeOperations.delete_lookup_and_wait_for_state.<locals>.<lambda>r ) r Z delete_lookupr r# Z ServiceErrorr r r r r! r" r$ ) r r% r& r' r( r) r* r. r+ r, r- r r r � delete_lookup_and_wait_for_state~ s4 � ��zFLogAnalyticsClientCompositeOperations.delete_lookup_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.disable_auto_association` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str source_name: (required) The source name. :param oci.log_analytics.models.DisableAutoAssociationDetails disable_auto_association_details: (required) Details required to disable auto association for the log source. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.disable_auto_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 zeLogAnalyticsClientCompositeOperations.disable_auto_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 zcLogAnalyticsClientCompositeOperations.disable_auto_association_and_wait_for_state.<locals>.<lambda>r N) r Zdisable_auto_associationr r r r! r" r# r$ ) r r% � source_nameZ disable_auto_association_detailsr' r( r) r* r+ r, r- r. r r r �+disable_auto_association_and_wait_for_state� s( � ��zQLogAnalyticsClientCompositeOperations.disable_auto_association_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a[ Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.disable_ingest_time_rule` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str ingest_time_rule_id: (required) Unique ocid of the ingest time rule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.disable_ingest_time_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zeLogAnalyticsClientCompositeOperations.disable_ingest_time_rule_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 zcLogAnalyticsClientCompositeOperations.disable_ingest_time_rule_and_wait_for_state.<locals>.<lambda>r N) r Zdisable_ingest_time_ruler r r r! r" r# r$ � r r% r: r' r( r) r* r+ r, r- r. r r r �+disable_ingest_time_rule_and_wait_for_state� s( � ��zQLogAnalyticsClientCompositeOperations.disable_ingest_time_rule_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.enable_auto_association` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str source_name: (required) The source name. :param oci.log_analytics.models.EnableAutoAssociationDetails enable_auto_association_details: (required) Details required to enable auto association for the log source. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.enable_auto_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 zdLogAnalyticsClientCompositeOperations.enable_auto_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 zbLogAnalyticsClientCompositeOperations.enable_auto_association_and_wait_for_state.<locals>.<lambda>r N) r Zenable_auto_associationr r r r! r" r# r$ ) r r% rJ Z enable_auto_association_detailsr' r( r) r* r+ r, r- r. r r r �*enable_auto_association_and_wait_for_state s( � ��zPLogAnalyticsClientCompositeOperations.enable_auto_association_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aY Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.enable_ingest_time_rule` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str ingest_time_rule_id: (required) Unique ocid of the ingest time rule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.enable_ingest_time_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r L r zdLogAnalyticsClientCompositeOperations.enable_ingest_time_rule_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r U r zbLogAnalyticsClientCompositeOperations.enable_ingest_time_rule_and_wait_for_state.<locals>.<lambda>r N) r Zenable_ingest_time_ruler r r r! r" r# r$ rL r r r �*enable_ingest_time_rule_and_wait_for_state4 s( � ��zPLogAnalyticsClientCompositeOperations.enable_ingest_time_rule_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.offboard_namespace` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.offboard_namespace` :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 s r z_LogAnalyticsClientCompositeOperations.offboard_namespace_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]LogAnalyticsClientCompositeOperations.offboard_namespace_and_wait_for_state.<locals>.<lambda>r N) r Zoffboard_namespacer r r r! r" r# r$ � r r% r' r( r) r* r+ r, r- r. r r r �%offboard_namespace_and_wait_for_state^ s( � ��zKLogAnalyticsClientCompositeOperations.offboard_namespace_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.onboard_namespace` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.onboard_namespace` :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^LogAnalyticsClientCompositeOperations.onboard_namespace_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\LogAnalyticsClientCompositeOperations.onboard_namespace_and_wait_for_state.<locals>.<lambda>r N) r Zonboard_namespacer r r r! r" r# r$ rP r r r �$onboard_namespace_and_wait_for_state� s( � ��zJLogAnalyticsClientCompositeOperations.onboard_namespace_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.pause_scheduled_task` and waits for the :py:class:`~oci.log_analytics.models.ScheduledTask` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str scheduled_task_id: (required) Unique scheduledTask id returned from task create. If invalid will lead to a 404 not found. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.ScheduledTask.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.pause_scheduled_task` :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 zaLogAnalyticsClientCompositeOperations.pause_scheduled_task_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r � r z_LogAnalyticsClientCompositeOperations.pause_scheduled_task_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zpause_scheduled_taskr r5 r r rE r7 r8 r9 r# r$ r" � r r% rF r' r( r) r* r, r- r. r r r �'pause_scheduled_task_and_wait_for_state� s. � �� &zMLogAnalyticsClientCompositeOperations.pause_scheduled_task_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.purge_storage_data` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.PurgeStorageDataDetails purge_storage_data_details: (required) This is the input to purge old data. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.purge_storage_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 z_LogAnalyticsClientCompositeOperations.purge_storage_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 z]LogAnalyticsClientCompositeOperations.purge_storage_data_and_wait_for_state.<locals>.<lambda>r N) r Zpurge_storage_datar r r r! r" r# r$ ) r r% Zpurge_storage_data_detailsr' r( r) r* r+ r, r- r. r r r �%purge_storage_data_and_wait_for_state� s( � ��zKLogAnalyticsClientCompositeOperations.purge_storage_data_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aB Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.query` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.QueryDetails query_details: (required) Query to be executed. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.query` :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 zRLogAnalyticsClientCompositeOperations.query_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 zPLogAnalyticsClientCompositeOperations.query_and_wait_for_state.<locals>.<lambda>r N) r �queryr r r r! r" r# r$ ) r r% Z query_detailsr' r( r) r* r+ r, r- r. r r r �query_and_wait_for_state s( � ��z>LogAnalyticsClientCompositeOperations.query_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.recall_archived_data` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.RecallArchivedDataDetails recall_archived_data_details: (required) This is the input to recall archived data. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.recall_archived_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 F r zaLogAnalyticsClientCompositeOperations.recall_archived_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 O r z_LogAnalyticsClientCompositeOperations.recall_archived_data_and_wait_for_state.<locals>.<lambda>r N) r Zrecall_archived_datar r r r! r" r# r$ ) r r% Z recall_archived_data_detailsr' r( r) r* r+ r, r- r. r r r �'recall_archived_data_and_wait_for_state. s( � ��zMLogAnalyticsClientCompositeOperations.recall_archived_data_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.release_recalled_data` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.ReleaseRecalledDataDetails release_recalled_data_details: (required) This is the input to release recalled data :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.release_recalled_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 p r zbLogAnalyticsClientCompositeOperations.release_recalled_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 y r z`LogAnalyticsClientCompositeOperations.release_recalled_data_and_wait_for_state.<locals>.<lambda>r N) r Zrelease_recalled_datar r r r! r" r# r$ ) r r% Z release_recalled_data_detailsr' r( r) r* r+ r, r- r. r r r �(release_recalled_data_and_wait_for_stateX s( � ��zNLogAnalyticsClientCompositeOperations.release_recalled_data_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.resume_scheduled_task` and waits for the :py:class:`~oci.log_analytics.models.ScheduledTask` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str scheduled_task_id: (required) Unique scheduledTask id returned from task create. If invalid will lead to a 404 not found. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.ScheduledTask.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.resume_scheduled_task` :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 zbLogAnalyticsClientCompositeOperations.resume_scheduled_task_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r � r z`LogAnalyticsClientCompositeOperations.resume_scheduled_task_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zresume_scheduled_taskr r5 r r rE r7 r8 r9 r# r$ r" rS r r r �(resume_scheduled_task_and_wait_for_state� s. � �� &zNLogAnalyticsClientCompositeOperations.resume_scheduled_task_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.update_ingest_time_rule` and waits for the :py:class:`~oci.log_analytics.models.IngestTimeRule` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str ingest_time_rule_id: (required) Unique ocid of the ingest time rule. :param oci.log_analytics.models.IngestTimeRule update_ingest_time_rule_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.IngestTimeRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.update_ingest_time_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zdLogAnalyticsClientCompositeOperations.update_ingest_time_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r � r zbLogAnalyticsClientCompositeOperations.update_ingest_time_rule_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zupdate_ingest_time_ruler r5 r r r6 r7 r8 r9 r# r$ r" ) r r% r: Z update_ingest_time_rule_detailsr' r( r) r* r, r- r. r r r �*update_ingest_time_rule_and_wait_for_state� s. � �� &zPLogAnalyticsClientCompositeOperations.update_ingest_time_rule_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) ag Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.update_log_analytics_em_bridge` and waits for the :py:class:`~oci.log_analytics.models.LogAnalyticsEmBridge` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str log_analytics_em_bridge_id: (required) The log analytics enterprise manager bridge OCID. :param oci.log_analytics.models.UpdateLogAnalyticsEmBridgeDetails update_log_analytics_em_bridge_details: (required) Log analytics enterprise manager 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.log_analytics.models.LogAnalyticsEmBridge.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.update_log_analytics_em_bridge` :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 zkLogAnalyticsClientCompositeOperations.update_log_analytics_em_bridge_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r r ziLogAnalyticsClientCompositeOperations.update_log_analytics_em_bridge_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Z update_log_analytics_em_bridger r5 r r r< r7 r8 r9 r# r$ r" ) r r% r= Z&update_log_analytics_em_bridge_detailsr' r( r) r* r, r- r. r r r �1update_log_analytics_em_bridge_and_wait_for_state� s. � �� &zWLogAnalyticsClientCompositeOperations.update_log_analytics_em_bridge_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a6 Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.update_log_analytics_entity` and waits for the :py:class:`~oci.log_analytics.models.LogAnalyticsEntity` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str log_analytics_entity_id: (required) The log analytics entity OCID. :param oci.log_analytics.models.UpdateLogAnalyticsEntityDetails update_log_analytics_entity_details: (required) Log analytics entity 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.log_analytics.models.LogAnalyticsEntity.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.update_log_analytics_entity` :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 zhLogAnalyticsClientCompositeOperations.update_log_analytics_entity_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r 2 r zfLogAnalyticsClientCompositeOperations.update_log_analytics_entity_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zupdate_log_analytics_entityr r5 r r r? r7 r8 r9 r# r$ r" ) r r% r@ Z#update_log_analytics_entity_detailsr' r( r) r* r, r- r. r r r �.update_log_analytics_entity_and_wait_for_state s. � �� &zTLogAnalyticsClientCompositeOperations.update_log_analytics_entity_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.update_log_analytics_object_collection_rule` and waits for the :py:class:`~oci.log_analytics.models.LogAnalyticsObjectCollectionRule` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str log_analytics_object_collection_rule_id: (required) The Logging Analytics Object Collection Rule `OCID`__. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.log_analytics.models.UpdateLogAnalyticsObjectCollectionRuleDetails update_log_analytics_object_collection_rule_details: (required) The rule config 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.log_analytics.models.LogAnalyticsObjectCollectionRule.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.update_log_analytics_object_collection_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ] r zxLogAnalyticsClientCompositeOperations.update_log_analytics_object_collection_rule_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r d r zvLogAnalyticsClientCompositeOperations.update_log_analytics_object_collection_rule_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Z+update_log_analytics_object_collection_ruler r5 r r rB r7 r8 r9 r# r$ r" ) r r% rC Z3update_log_analytics_object_collection_rule_detailsr' r( r) r* r, r- r. r r r �>update_log_analytics_object_collection_rule_and_wait_for_state@ s. � �� &zdLogAnalyticsClientCompositeOperations.update_log_analytics_object_collection_rule_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.update_lookup_data` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str lookup_name: (required) The name of the lookup to operate on. :param stream update_lookup_file_body: (required) The file to use for the lookup update. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.update_lookup_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 z_LogAnalyticsClientCompositeOperations.update_lookup_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 z]LogAnalyticsClientCompositeOperations.update_lookup_data_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_lookup_datar r r r! r" r# r$ ) r r% r& Zupdate_lookup_file_bodyr' r( r) r* r+ r, r- r. r r r �%update_lookup_data_and_wait_for_stater s( � ��zKLogAnalyticsClientCompositeOperations.update_lookup_data_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jj}z6tj| j | j �||�fd� fdd�i|��}|} | W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.update_scheduled_task` and waits for the :py:class:`~oci.log_analytics.models.ScheduledTask` acted upon to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param str scheduled_task_id: (required) Unique scheduledTask id returned from task create. If invalid will lead to a 404 not found. :param oci.log_analytics.models.UpdateScheduledTaskDetails update_scheduled_task_details: (required) Update details. Schedules may be updated only for taskType SAVED_SEARCH and PURGE. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.ScheduledTask.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.update_scheduled_task` :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 zbLogAnalyticsClientCompositeOperations.update_scheduled_task_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r1 r r r r r r � r z`LogAnalyticsClientCompositeOperations.update_scheduled_task_and_wait_for_state.<locals>.<lambda>r2 r4 r N) r Zupdate_scheduled_taskr r5 r r rE r7 r8 r9 r# r$ r" ) r r% rF Z update_scheduled_task_detailsr' r( r) r* r, r- r. r r r �(update_scheduled_task_and_wait_for_state� s. � �� &zNLogAnalyticsClientCompositeOperations.update_scheduled_task_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.log_analytics.LogAnalyticsClient.upsert_associations` and waits for the :py:class:`~oci.log_analytics.models.WorkRequest` to enter the given state(s). :param str namespace_name: (required) The Logging Analytics namespace used for the request. :param oci.log_analytics.models.UpsertLogAnalyticsAssociationDetails upsert_log_analytics_association_details: (required) list of association details :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.log_analytics.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.log_analytics.LogAnalyticsClient.upsert_associations` :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`LogAnalyticsClientCompositeOperations.upsert_associations_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^LogAnalyticsClientCompositeOperations.upsert_associations_and_wait_for_state.<locals>.<lambda>r N) r Zupsert_associationsr r r r! r" r# r$ ) r r% Z(upsert_log_analytics_association_detailsr' r( r) r* r+ r, r- r. r r r �&upsert_associations_and_wait_for_state� s( � ��zLLogAnalyticsClientCompositeOperations.upsert_associations_and_wait_for_stateN)!�__name__� __module__� __qualname__�__doc__r r/ r0 r; r> rA rD rG rH rI rK rM rN rO rQ rR rT rU rW rX rY rZ r[ r\ r] r^ r_ r` ra r r r r r s< -*-----*2-*-*''.****.0002-2r )r Zoci.utilr �objectr r r r r �<module> s