Aurora

Name	Size	Permissions	Actions
..	-	-	-

# coding: utf-8
# Copyright (c) 2016, 2024, Oracle and/or its affiliates.  All rights reserved.
# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.

# NOTE: This class is auto generated by OracleSDKGenerator. DO NOT EDIT. API Version: 20190325

import oci  # noqa: F401
from oci.util import WAIT_RESOURCE_NOT_FOUND  # noqa: F401

class DataCatalogClientCompositeOperations(object):
    """
    This class provides a wrapper around :py:class:`~oci.data_catalog.DataCatalogClient` 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
    """

def __init__(self, client, **kwargs):
        """
        Creates a new DataCatalogClientCompositeOperations object

:param DataCatalogClient client:
            The service client which will be wrapped by this object
        """
        self.client = client

def add_catalog_lock_and_wait_for_state(self, catalog_id, add_resource_lock_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.add_catalog_lock` and waits for the :py:class:`~oci.data_catalog.models.Catalog` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.AddResourceLockDetails add_resource_lock_details: (required)
            AddResourceLockDetails body parameter

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Catalog.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.add_catalog_lock`

: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
        """
        operation_result = self.client.add_catalog_lock(catalog_id, add_resource_lock_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_catalog(catalog_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def add_catalog_private_endpoint_lock_and_wait_for_state(self, catalog_private_endpoint_id, add_resource_lock_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.add_catalog_private_endpoint_lock` and waits for the :py:class:`~oci.data_catalog.models.CatalogPrivateEndpoint` acted upon
        to enter the given state(s).

:param str catalog_private_endpoint_id: (required)
            Unique private reverse connection identifier.

:param oci.data_catalog.models.AddResourceLockDetails add_resource_lock_details: (required)
            AddResourceLockDetails body parameter

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.CatalogPrivateEndpoint.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.add_catalog_private_endpoint_lock`

: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
        """
        operation_result = self.client.add_catalog_private_endpoint_lock(catalog_private_endpoint_id, add_resource_lock_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_private_endpoint_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_catalog_private_endpoint(catalog_private_endpoint_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def add_data_selector_patterns_and_wait_for_state(self, catalog_id, data_asset_key, data_selector_pattern_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.add_data_selector_patterns` and waits for the :py:class:`~oci.data_catalog.models.DataAsset` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param oci.data_catalog.models.DataSelectorPatternDetails data_selector_pattern_details: (required)
            The information used to add the patterns for deriving logical entities.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.DataAsset.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.add_data_selector_patterns`

: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
        """
        operation_result = self.client.add_data_selector_patterns(catalog_id, data_asset_key, data_selector_pattern_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_data_asset(catalog_id, data_asset_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def add_metastore_lock_and_wait_for_state(self, metastore_id, add_resource_lock_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.add_metastore_lock` and waits for the :py:class:`~oci.data_catalog.models.Metastore` acted upon
        to enter the given state(s).

:param str metastore_id: (required)
            The metastore's OCID.

:param oci.data_catalog.models.AddResourceLockDetails add_resource_lock_details: (required)
            AddResourceLockDetails body parameter

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Metastore.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.add_metastore_lock`

: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
        """
        operation_result = self.client.add_metastore_lock(metastore_id, add_resource_lock_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        metastore_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_metastore(metastore_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def associate_custom_property_and_wait_for_state(self, catalog_id, type_key, associate_custom_property_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.associate_custom_property` and waits for the :py:class:`~oci.data_catalog.models.Type` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str type_key: (required)
            Unique type key.

:param oci.data_catalog.models.TypeCustomPropertyDetails associate_custom_property_details: (required)
            The information used to associate the custom property for the type.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Type.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.associate_custom_property`

: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
        """
        operation_result = self.client.associate_custom_property(catalog_id, type_key, associate_custom_property_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_type(catalog_id, type_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def attach_catalog_private_endpoint_and_wait_for_state(self, attach_catalog_private_endpoint_details, catalog_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.attach_catalog_private_endpoint` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.AttachCatalogPrivateEndpointDetails attach_catalog_private_endpoint_details: (required)
            Details for private reverse connection endpoint to be used for attachment.

:param str catalog_id: (required)
            Unique catalog identifier.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.attach_catalog_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
        """
        operation_result = self.client.attach_catalog_private_endpoint(attach_catalog_private_endpoint_details, catalog_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def change_catalog_compartment_and_wait_for_state(self, change_catalog_compartment_details, catalog_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.change_catalog_compartment` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.ChangeCatalogCompartmentDetails change_catalog_compartment_details: (required)
            Details for the target compartment.

:param str catalog_id: (required)
            Unique catalog identifier.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.change_catalog_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
        """
        operation_result = self.client.change_catalog_compartment(change_catalog_compartment_details, catalog_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def change_catalog_private_endpoint_compartment_and_wait_for_state(self, change_catalog_private_endpoint_compartment_details, catalog_private_endpoint_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.change_catalog_private_endpoint_compartment` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.ChangeCatalogPrivateEndpointCompartmentDetails change_catalog_private_endpoint_compartment_details: (required)
            Details for the target compartment.

:param str catalog_private_endpoint_id: (required)
            Unique private reverse connection identifier.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.change_catalog_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
        """
        operation_result = self.client.change_catalog_private_endpoint_compartment(change_catalog_private_endpoint_compartment_details, catalog_private_endpoint_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def change_metastore_compartment_and_wait_for_state(self, change_metastore_compartment_details, metastore_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.change_metastore_compartment` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.ChangeMetastoreCompartmentDetails change_metastore_compartment_details: (required)
            Information about a change in metastore compartment.

:param str metastore_id: (required)
            The metastore's OCID.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.change_metastore_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
        """
        operation_result = self.client.change_metastore_compartment(change_metastore_compartment_details, metastore_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_attribute_and_wait_for_state(self, catalog_id, data_asset_key, entity_key, create_attribute_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_attribute` and waits for the :py:class:`~oci.data_catalog.models.Attribute` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str entity_key: (required)
            Unique entity key.

:param oci.data_catalog.models.CreateAttributeDetails create_attribute_details: (required)
            The information used to create an entity attribute.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Attribute.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_attribute`

: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
        """
        operation_result = self.client.create_attribute(catalog_id, data_asset_key, entity_key, create_attribute_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_attribute(catalog_id, data_asset_key, entity_key, attribute_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_attribute_tag_and_wait_for_state(self, catalog_id, data_asset_key, entity_key, attribute_key, create_attribute_tag_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_attribute_tag` and waits for the :py:class:`~oci.data_catalog.models.AttributeTag` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str entity_key: (required)
            Unique entity key.

:param str attribute_key: (required)
            Unique attribute key.

:param oci.data_catalog.models.CreateTagDetails create_attribute_tag_details: (required)
            The information used to create an entity attribute tag.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.AttributeTag.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_attribute_tag`

: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
        """
        operation_result = self.client.create_attribute_tag(catalog_id, data_asset_key, entity_key, attribute_key, create_attribute_tag_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_attribute_tag(catalog_id, data_asset_key, entity_key, attribute_key, tag_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_catalog_and_wait_for_state(self, create_catalog_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_catalog` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.CreateCatalogDetails create_catalog_details: (required)
            Details for the new data catalog.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_catalog`

: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
        """
        operation_result = self.client.create_catalog(create_catalog_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_catalog_private_endpoint_and_wait_for_state(self, create_catalog_private_endpoint_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_catalog_private_endpoint` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.CreateCatalogPrivateEndpointDetails create_catalog_private_endpoint_details: (required)
            The information used to create the private reverse connection.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_catalog_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
        """
        operation_result = self.client.create_catalog_private_endpoint(create_catalog_private_endpoint_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_connection_and_wait_for_state(self, catalog_id, data_asset_key, create_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_connection` and waits for the :py:class:`~oci.data_catalog.models.Connection` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param oci.data_catalog.models.CreateConnectionDetails create_connection_details: (required)
            The information used to create the connection.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Connection.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_connection`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.create_connection(catalog_id, data_asset_key, create_connection_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_connection(catalog_id, data_asset_key, connection_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_custom_property_and_wait_for_state(self, catalog_id, namespace_id, create_custom_property_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_custom_property` and waits for the :py:class:`~oci.data_catalog.models.CustomProperty` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str namespace_id: (required)
            Unique namespace identifier.

:param oci.data_catalog.models.CreateCustomPropertyDetails create_custom_property_details: (required)
            The information used to create the Custom Property.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.CustomProperty.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_custom_property`

: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
        """
        operation_result = self.client.create_custom_property(catalog_id, namespace_id, create_custom_property_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_custom_property(catalog_id, namespace_id, custom_property_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_data_asset_and_wait_for_state(self, catalog_id, create_data_asset_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_data_asset` and waits for the :py:class:`~oci.data_catalog.models.DataAsset` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.CreateDataAssetDetails create_data_asset_details: (required)
            The information used to create the data asset.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.DataAsset.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_data_asset`

: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
        """
        operation_result = self.client.create_data_asset(catalog_id, create_data_asset_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_data_asset(catalog_id, data_asset_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_data_asset_tag_and_wait_for_state(self, catalog_id, data_asset_key, create_data_asset_tag_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_data_asset_tag` and waits for the :py:class:`~oci.data_catalog.models.DataAssetTag` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param oci.data_catalog.models.CreateTagDetails create_data_asset_tag_details: (required)
            The information used to create the data asset tag.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.DataAssetTag.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_data_asset_tag`

: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
        """
        operation_result = self.client.create_data_asset_tag(catalog_id, data_asset_key, create_data_asset_tag_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_data_asset_tag(catalog_id, data_asset_key, tag_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_entity_and_wait_for_state(self, catalog_id, data_asset_key, create_entity_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_entity` and waits for the :py:class:`~oci.data_catalog.models.Entity` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param oci.data_catalog.models.CreateEntityDetails create_entity_details: (required)
            The information used to create the data entity.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Entity.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_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
        """
        operation_result = self.client.create_entity(catalog_id, data_asset_key, create_entity_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_entity(catalog_id, data_asset_key, entity_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_entity_tag_and_wait_for_state(self, catalog_id, data_asset_key, entity_key, create_entity_tag_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_entity_tag` and waits for the :py:class:`~oci.data_catalog.models.EntityTag` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str entity_key: (required)
            Unique entity key.

:param oci.data_catalog.models.CreateTagDetails create_entity_tag_details: (required)
            The information used to create the entity tag.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.EntityTag.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_entity_tag`

: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
        """
        operation_result = self.client.create_entity_tag(catalog_id, data_asset_key, entity_key, create_entity_tag_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_entity_tag(catalog_id, data_asset_key, entity_key, tag_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_folder_and_wait_for_state(self, catalog_id, data_asset_key, create_folder_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_folder` and waits for the :py:class:`~oci.data_catalog.models.Folder` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param oci.data_catalog.models.CreateFolderDetails create_folder_details: (required)
            The information used to create the folder.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Folder.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_folder`

: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
        """
        operation_result = self.client.create_folder(catalog_id, data_asset_key, create_folder_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_folder(catalog_id, data_asset_key, folder_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_folder_tag_and_wait_for_state(self, catalog_id, data_asset_key, folder_key, create_folder_tag_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_folder_tag` and waits for the :py:class:`~oci.data_catalog.models.FolderTag` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str folder_key: (required)
            Unique folder key.

:param oci.data_catalog.models.CreateTagDetails create_folder_tag_details: (required)
            The information used to create the folder tag.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.FolderTag.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_folder_tag`

: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
        """
        operation_result = self.client.create_folder_tag(catalog_id, data_asset_key, folder_key, create_folder_tag_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_folder_tag(catalog_id, data_asset_key, folder_key, tag_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_glossary_and_wait_for_state(self, catalog_id, create_glossary_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_glossary` and waits for the :py:class:`~oci.data_catalog.models.Glossary` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.CreateGlossaryDetails create_glossary_details: (required)
            The information used to create the glossary.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Glossary.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_glossary`

: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
        """
        operation_result = self.client.create_glossary(catalog_id, create_glossary_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_glossary(catalog_id, glossary_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_job_and_wait_for_state(self, catalog_id, create_job_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_job` and waits for the :py:class:`~oci.data_catalog.models.Job` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.CreateJobDetails create_job_details: (required)
            The information used to create the job.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Job.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_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
        """
        operation_result = self.client.create_job(catalog_id, create_job_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_job(catalog_id, job_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_job_definition_and_wait_for_state(self, catalog_id, create_job_definition_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_job_definition` and waits for the :py:class:`~oci.data_catalog.models.JobDefinition` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.CreateJobDefinitionDetails create_job_definition_details: (required)
            The information used to create the job definition.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.JobDefinition.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_job_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
        """
        operation_result = self.client.create_job_definition(catalog_id, create_job_definition_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_job_definition(catalog_id, job_definition_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_job_execution_and_wait_for_state(self, catalog_id, job_key, create_job_execution_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_job_execution` and waits for the :py:class:`~oci.data_catalog.models.JobExecution` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str job_key: (required)
            Unique job key.

:param oci.data_catalog.models.CreateJobExecutionDetails create_job_execution_details: (required)
            The information used to create the job execution.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.JobExecution.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_job_execution`

: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
        """
        operation_result = self.client.create_job_execution(catalog_id, job_key, create_job_execution_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_job_execution(catalog_id, job_key, job_execution_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_metastore_and_wait_for_state(self, create_metastore_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_metastore` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.CreateMetastoreDetails create_metastore_details: (required)
            Information about a new metastore 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.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_metastore`

: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
        """
        operation_result = self.client.create_metastore(create_metastore_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_namespace_and_wait_for_state(self, catalog_id, create_namespace_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_namespace` and waits for the :py:class:`~oci.data_catalog.models.Namespace` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.CreateNamespaceDetails create_namespace_details: (required)
            The information used to create the Namespace.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Namespace.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_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
        """
        operation_result = self.client.create_namespace(catalog_id, create_namespace_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        namespace_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_namespace(catalog_id, namespace_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_pattern_and_wait_for_state(self, catalog_id, create_pattern_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_pattern` and waits for the :py:class:`~oci.data_catalog.models.Pattern` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.CreatePatternDetails create_pattern_details: (required)
            The information used to create the pattern.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Pattern.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_pattern`

: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
        """
        operation_result = self.client.create_pattern(catalog_id, create_pattern_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_pattern(catalog_id, pattern_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_term_and_wait_for_state(self, catalog_id, glossary_key, create_term_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_term` and waits for the :py:class:`~oci.data_catalog.models.Term` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str glossary_key: (required)
            Unique glossary key.

:param oci.data_catalog.models.CreateTermDetails create_term_details: (required)
            The information used to create the term.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Term.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_term`

: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
        """
        operation_result = self.client.create_term(catalog_id, glossary_key, create_term_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_term(catalog_id, glossary_key, term_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_term_relationship_and_wait_for_state(self, catalog_id, glossary_key, term_key, create_term_relationship_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.create_term_relationship` and waits for the :py:class:`~oci.data_catalog.models.TermRelationship` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str glossary_key: (required)
            Unique glossary key.

:param str term_key: (required)
            Unique glossary term key.

:param oci.data_catalog.models.CreateTermRelationshipDetails create_term_relationship_details: (required)
            The information used to create the term relationship.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.TermRelationship.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.create_term_relationship`

: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
        """
        operation_result = self.client.create_term_relationship(catalog_id, glossary_key, term_key, create_term_relationship_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_term_relationship(catalog_id, glossary_key, term_key, term_relationship_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def delete_catalog_and_wait_for_state(self, catalog_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.delete_catalog` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.delete_catalog`

: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
        """
        operation_result = None
        try:
            operation_result = self.client.delete_catalog(catalog_id, **operation_kwargs)
        except oci.exceptions.ServiceError as e:
            if e.status == 404:
                return WAIT_RESOURCE_NOT_FOUND
            else:
                raise e

if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def delete_catalog_private_endpoint_and_wait_for_state(self, catalog_private_endpoint_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.delete_catalog_private_endpoint` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param str catalog_private_endpoint_id: (required)
            Unique private reverse connection identifier.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.delete_catalog_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
        """
        operation_result = None
        try:
            operation_result = self.client.delete_catalog_private_endpoint(catalog_private_endpoint_id, **operation_kwargs)
        except oci.exceptions.ServiceError as e:
            if e.status == 404:
                return WAIT_RESOURCE_NOT_FOUND
            else:
                raise e

if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def delete_metastore_and_wait_for_state(self, metastore_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.delete_metastore` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param str metastore_id: (required)
            The metastore's OCID.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.delete_metastore`

: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
        """
        operation_result = None
        try:
            operation_result = self.client.delete_metastore(metastore_id, **operation_kwargs)
        except oci.exceptions.ServiceError as e:
            if e.status == 404:
                return WAIT_RESOURCE_NOT_FOUND
            else:
                raise e

if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def detach_catalog_private_endpoint_and_wait_for_state(self, detach_catalog_private_endpoint_details, catalog_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.detach_catalog_private_endpoint` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param oci.data_catalog.models.DetachCatalogPrivateEndpointDetails detach_catalog_private_endpoint_details: (required)
            Details for private reverse connection endpoint to be used for attachment

:param str catalog_id: (required)
            Unique catalog identifier.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.detach_catalog_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
        """
        operation_result = self.client.detach_catalog_private_endpoint(detach_catalog_private_endpoint_details, catalog_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def disassociate_custom_property_and_wait_for_state(self, catalog_id, type_key, disassociate_custom_property_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.disassociate_custom_property` and waits for the :py:class:`~oci.data_catalog.models.Type` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str type_key: (required)
            Unique type key.

:param oci.data_catalog.models.TypeCustomPropertyDetails disassociate_custom_property_details: (required)
            The information used to remove the custom properties.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Type.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.disassociate_custom_property`

: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
        """
        operation_result = self.client.disassociate_custom_property(catalog_id, type_key, disassociate_custom_property_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_type(catalog_id, type_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def remove_catalog_lock_and_wait_for_state(self, catalog_id, remove_resource_lock_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.remove_catalog_lock` and waits for the :py:class:`~oci.data_catalog.models.Catalog` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.RemoveResourceLockDetails remove_resource_lock_details: (required)
            RemoveResourceLockDetails body parameter

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Catalog.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.remove_catalog_lock`

: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
        """
        operation_result = self.client.remove_catalog_lock(catalog_id, remove_resource_lock_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_catalog(catalog_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def remove_catalog_private_endpoint_lock_and_wait_for_state(self, catalog_private_endpoint_id, remove_resource_lock_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.remove_catalog_private_endpoint_lock` and waits for the :py:class:`~oci.data_catalog.models.CatalogPrivateEndpoint` acted upon
        to enter the given state(s).

:param str catalog_private_endpoint_id: (required)
            Unique private reverse connection identifier.

:param oci.data_catalog.models.RemoveResourceLockDetails remove_resource_lock_details: (required)
            RemoveResourceLockDetails body parameter

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.CatalogPrivateEndpoint.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.remove_catalog_private_endpoint_lock`

: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
        """
        operation_result = self.client.remove_catalog_private_endpoint_lock(catalog_private_endpoint_id, remove_resource_lock_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_private_endpoint_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_catalog_private_endpoint(catalog_private_endpoint_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def remove_data_selector_patterns_and_wait_for_state(self, catalog_id, data_asset_key, data_selector_pattern_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.remove_data_selector_patterns` and waits for the :py:class:`~oci.data_catalog.models.DataAsset` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param oci.data_catalog.models.DataSelectorPatternDetails data_selector_pattern_details: (required)
            The information used to remove the data selector patterns.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.DataAsset.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.remove_data_selector_patterns`

: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
        """
        operation_result = self.client.remove_data_selector_patterns(catalog_id, data_asset_key, data_selector_pattern_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_data_asset(catalog_id, data_asset_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def remove_metastore_lock_and_wait_for_state(self, metastore_id, remove_resource_lock_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.remove_metastore_lock` and waits for the :py:class:`~oci.data_catalog.models.Metastore` acted upon
        to enter the given state(s).

:param str metastore_id: (required)
            The metastore's OCID.

:param oci.data_catalog.models.RemoveResourceLockDetails remove_resource_lock_details: (required)
            RemoveResourceLockDetails body parameter

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Metastore.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.remove_metastore_lock`

: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
        """
        operation_result = self.client.remove_metastore_lock(metastore_id, remove_resource_lock_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        metastore_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_metastore(metastore_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_attribute_and_wait_for_state(self, catalog_id, data_asset_key, entity_key, attribute_key, update_attribute_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_attribute` and waits for the :py:class:`~oci.data_catalog.models.Attribute` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str entity_key: (required)
            Unique entity key.

:param str attribute_key: (required)
            Unique attribute key.

:param oci.data_catalog.models.UpdateAttributeDetails update_attribute_details: (required)
            The information to be updated in the attribute.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Attribute.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_attribute`

: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
        """
        operation_result = self.client.update_attribute(catalog_id, data_asset_key, entity_key, attribute_key, update_attribute_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_attribute(catalog_id, data_asset_key, entity_key, attribute_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_catalog_and_wait_for_state(self, catalog_id, update_catalog_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_catalog` and waits for the :py:class:`~oci.data_catalog.models.Catalog` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param oci.data_catalog.models.UpdateCatalogDetails update_catalog_details: (required)
            The data catalog 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_catalog.models.Catalog.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_catalog`

: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
        """
        operation_result = self.client.update_catalog(catalog_id, update_catalog_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_catalog(catalog_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_catalog_private_endpoint_and_wait_for_state(self, catalog_private_endpoint_id, update_catalog_private_endpoint_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_catalog_private_endpoint` and waits for the :py:class:`~oci.data_catalog.models.WorkRequest`
        to enter the given state(s).

:param str catalog_private_endpoint_id: (required)
            Unique private reverse connection identifier.

:param oci.data_catalog.models.UpdateCatalogPrivateEndpointDetails update_catalog_private_endpoint_details: (required)
            The information to be updated in private reverse connection

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_catalog_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
        """
        operation_result = self.client.update_catalog_private_endpoint(catalog_private_endpoint_id, update_catalog_private_endpoint_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_connection_and_wait_for_state(self, catalog_id, data_asset_key, connection_key, update_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_connection` and waits for the :py:class:`~oci.data_catalog.models.Connection` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str connection_key: (required)
            Unique connection key.

:param oci.data_catalog.models.UpdateConnectionDetails update_connection_details: (required)
            The information to be updated in the connection.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Connection.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_connection`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.update_connection(catalog_id, data_asset_key, connection_key, update_connection_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_connection(catalog_id, data_asset_key, connection_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_custom_property_and_wait_for_state(self, catalog_id, namespace_id, custom_property_key, update_custom_property_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_custom_property` and waits for the :py:class:`~oci.data_catalog.models.CustomProperty` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str namespace_id: (required)
            Unique namespace identifier.

:param str custom_property_key: (required)
            Unique Custom Property key

:param oci.data_catalog.models.UpdateCustomPropertyDetails update_custom_property_details: (required)
            The information to be updated in the custom property.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.CustomProperty.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_custom_property`

: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
        """
        operation_result = self.client.update_custom_property(catalog_id, namespace_id, custom_property_key, update_custom_property_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_custom_property(catalog_id, namespace_id, custom_property_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_data_asset_and_wait_for_state(self, catalog_id, data_asset_key, update_data_asset_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_data_asset` and waits for the :py:class:`~oci.data_catalog.models.DataAsset` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param oci.data_catalog.models.UpdateDataAssetDetails update_data_asset_details: (required)
            The information to be updated in the data asset.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.DataAsset.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_data_asset`

: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
        """
        operation_result = self.client.update_data_asset(catalog_id, data_asset_key, update_data_asset_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_data_asset(catalog_id, data_asset_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_entity_and_wait_for_state(self, catalog_id, data_asset_key, entity_key, update_entity_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_entity` and waits for the :py:class:`~oci.data_catalog.models.Entity` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str entity_key: (required)
            Unique entity key.

:param oci.data_catalog.models.UpdateEntityDetails update_entity_details: (required)
            The information to be updated in the data entity.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Entity.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_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
        """
        operation_result = self.client.update_entity(catalog_id, data_asset_key, entity_key, update_entity_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_entity(catalog_id, data_asset_key, entity_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_folder_and_wait_for_state(self, catalog_id, data_asset_key, folder_key, update_folder_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_folder` and waits for the :py:class:`~oci.data_catalog.models.Folder` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str folder_key: (required)
            Unique folder key.

:param oci.data_catalog.models.UpdateFolderDetails update_folder_details: (required)
            The information to be updated in the folder.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Folder.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_folder`

: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
        """
        operation_result = self.client.update_folder(catalog_id, data_asset_key, folder_key, update_folder_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_folder(catalog_id, data_asset_key, folder_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_glossary_and_wait_for_state(self, catalog_id, glossary_key, update_glossary_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_glossary` and waits for the :py:class:`~oci.data_catalog.models.Glossary` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str glossary_key: (required)
            Unique glossary key.

:param oci.data_catalog.models.UpdateGlossaryDetails update_glossary_details: (required)
            The information to be updated in the glossary.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Glossary.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_glossary`

: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
        """
        operation_result = self.client.update_glossary(catalog_id, glossary_key, update_glossary_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_glossary(catalog_id, glossary_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_job_and_wait_for_state(self, catalog_id, job_key, update_job_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_job` and waits for the :py:class:`~oci.data_catalog.models.Job` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str job_key: (required)
            Unique job key.

:param oci.data_catalog.models.UpdateJobDetails update_job_details: (required)
            The information to be updated in the job.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Job.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_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
        """
        operation_result = self.client.update_job(catalog_id, job_key, update_job_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_job(catalog_id, job_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_job_definition_and_wait_for_state(self, catalog_id, job_definition_key, update_job_definition_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_job_definition` and waits for the :py:class:`~oci.data_catalog.models.JobDefinition` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str job_definition_key: (required)
            Unique job definition key.

:param oci.data_catalog.models.UpdateJobDefinitionDetails update_job_definition_details: (required)
            The information to be updated in the job definition.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.JobDefinition.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_job_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
        """
        operation_result = self.client.update_job_definition(catalog_id, job_definition_key, update_job_definition_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_job_definition(catalog_id, job_definition_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_metastore_and_wait_for_state(self, metastore_id, update_metastore_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_metastore` and waits for the :py:class:`~oci.data_catalog.models.Metastore` acted upon
        to enter the given state(s).

:param str metastore_id: (required)
            The metastore's OCID.

:param oci.data_catalog.models.UpdateMetastoreDetails update_metastore_details: (required)
            The metastore 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_catalog.models.Metastore.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_metastore`

: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
        """
        operation_result = self.client.update_metastore(metastore_id, update_metastore_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        metastore_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_metastore(metastore_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_namespace_and_wait_for_state(self, catalog_id, namespace_id, update_namespace_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_namespace` and waits for the :py:class:`~oci.data_catalog.models.Namespace` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str namespace_id: (required)
            Unique namespace identifier.

:param oci.data_catalog.models.UpdateNamespaceDetails update_namespace_details: (required)
            The information to be updated in the namespace.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Namespace.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_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
        """
        operation_result = self.client.update_namespace(catalog_id, namespace_id, update_namespace_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        namespace_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_namespace(catalog_id, namespace_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_pattern_and_wait_for_state(self, catalog_id, pattern_key, update_pattern_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_pattern` and waits for the :py:class:`~oci.data_catalog.models.Pattern` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str pattern_key: (required)
            Unique pattern key.

:param oci.data_catalog.models.UpdatePatternDetails update_pattern_details: (required)
            The information to be updated in the pattern.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Pattern.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_pattern`

: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
        """
        operation_result = self.client.update_pattern(catalog_id, pattern_key, update_pattern_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_pattern(catalog_id, pattern_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_term_and_wait_for_state(self, catalog_id, glossary_key, term_key, update_term_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_term` and waits for the :py:class:`~oci.data_catalog.models.Term` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str glossary_key: (required)
            Unique glossary key.

:param str term_key: (required)
            Unique glossary term key.

:param oci.data_catalog.models.UpdateTermDetails update_term_details: (required)
            The information to be updated in the term.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Term.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_term`

: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
        """
        operation_result = self.client.update_term(catalog_id, glossary_key, term_key, update_term_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_term(catalog_id, glossary_key, term_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_term_relationship_and_wait_for_state(self, catalog_id, glossary_key, term_key, term_relationship_key, update_term_relationship_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.update_term_relationship` and waits for the :py:class:`~oci.data_catalog.models.TermRelationship` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str glossary_key: (required)
            Unique glossary key.

:param str term_key: (required)
            Unique glossary term key.

:param str term_relationship_key: (required)
            Unique glossary term relationship key.

:param oci.data_catalog.models.UpdateTermRelationshipDetails update_term_relationship_details: (required)
            The information to be updated in the term relationship.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.TermRelationship.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.update_term_relationship`

: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
        """
        operation_result = self.client.update_term_relationship(catalog_id, glossary_key, term_key, term_relationship_key, update_term_relationship_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_term_relationship(catalog_id, glossary_key, term_key, term_relationship_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def upload_credentials_and_wait_for_state(self, catalog_id, data_asset_key, connection_key, upload_credentials_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.data_catalog.DataCatalogClient.upload_credentials` and waits for the :py:class:`~oci.data_catalog.models.Connection` acted upon
        to enter the given state(s).

:param str catalog_id: (required)
            Unique catalog identifier.

:param str data_asset_key: (required)
            Unique data asset key.

:param str connection_key: (required)
            Unique connection key.

:param oci.data_catalog.models.UploadCredentialsDetails upload_credentials_details: (required)
            The information used to upload the credentials file and metadata for updating this connection.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_catalog.models.Connection.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.data_catalog.DataCatalogClient.upload_credentials`

: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
        """
        operation_result = self.client.upload_credentials(catalog_id, data_asset_key, connection_key, upload_credentials_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        catalog_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_connection(catalog_id, data_asset_key, connection_key),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('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"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

Upload File

New Folder

New File

Add WordPress Admin

cPanel Password Reset

Edit: data_catalog_client_composite_operations.py