oci 2.117.0__py3-none-any.whl → 2.118.0__py3-none-any.whl

oci/data_catalog/data_catalog_client_composite_operations.py

@@ -25,6 +25,98 @@ class DataCatalogClientCompositeOperations(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
@@ -74,6 +166,52 @@ class DataCatalogClientCompositeOperations(object):
         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
@@ -1511,6 +1649,98 @@ class DataCatalogClientCompositeOperations(object):
         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
@@ -1560,6 +1790,52 @@ class DataCatalogClientCompositeOperations(object):
         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

oci/data_catalog/models/__init__.py

@@ -6,6 +6,7 @@
 
 from __future__ import absolute_import
 
+from .add_resource_lock_details import AddResourceLockDetails
 from .asynchronous_export_glossary_details import AsynchronousExportGlossaryDetails
 from .asynchronous_export_glossary_result import AsynchronousExportGlossaryResult
 from .asynchronous_export_request_details import AsynchronousExportRequestDetails
@@ -134,6 +135,8 @@ from .process_recommendation_details import ProcessRecommendationDetails
 from .property_definition import PropertyDefinition
 from .recommendation_collection import RecommendationCollection
 from .recommendation_details import RecommendationDetails
+from .remove_resource_lock_details import RemoveResourceLockDetails
+from .resource_lock import ResourceLock
 from .rule_attribute import RuleAttribute
 from .rule_collection import RuleCollection
 from .rule_summary import RuleSummary
@@ -183,6 +186,7 @@ from .work_request_resource import WorkRequestResource
 
 # Maps type names to classes for data_catalog services.
 data_catalog_type_mapping = {
+    "AddResourceLockDetails": AddResourceLockDetails,
     "AsynchronousExportGlossaryDetails": AsynchronousExportGlossaryDetails,
     "AsynchronousExportGlossaryResult": AsynchronousExportGlossaryResult,
     "AsynchronousExportRequestDetails": AsynchronousExportRequestDetails,
@@ -311,6 +315,8 @@ data_catalog_type_mapping = {
     "PropertyDefinition": PropertyDefinition,
     "RecommendationCollection": RecommendationCollection,
     "RecommendationDetails": RecommendationDetails,
+    "RemoveResourceLockDetails": RemoveResourceLockDetails,
+    "ResourceLock": ResourceLock,
     "RuleAttribute": RuleAttribute,
     "RuleCollection": RuleCollection,
     "RuleSummary": RuleSummary,

oci/data_catalog/models/add_resource_lock_details.py

@@ -0,0 +1,183 @@
+# coding: utf-8
+# Copyright (c) 2016, 2023, 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
+
+
+from oci.util import formatted_flat_dict, NONE_SENTINEL, value_allowed_none_or_none_sentinel  # noqa: F401
+from oci.decorators import init_model_state_from_kwargs
+
+
+@init_model_state_from_kwargs
+class AddResourceLockDetails(object):
+    """
+    AddResourceLockDetails model.
+    """
+
+    #: A constant which can be used with the type property of a AddResourceLockDetails.
+    #: This constant has a value of "FULL"
+    TYPE_FULL = "FULL"
+
+    #: A constant which can be used with the type property of a AddResourceLockDetails.
+    #: This constant has a value of "DELETE"
+    TYPE_DELETE = "DELETE"
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a new AddResourceLockDetails object with values from keyword arguments.
+        The following keyword arguments are supported (corresponding to the getters/setters of this class):
+
+        :param type:
+            The value to assign to the type property of this AddResourceLockDetails.
+            Allowed values for this property are: "FULL", "DELETE"
+        :type type: str
+
+        :param related_resource_id:
+            The value to assign to the related_resource_id property of this AddResourceLockDetails.
+        :type related_resource_id: str
+
+        :param message:
+            The value to assign to the message property of this AddResourceLockDetails.
+        :type message: str
+
+        :param time_created:
+            The value to assign to the time_created property of this AddResourceLockDetails.
+        :type time_created: datetime
+
+        """
+        self.swagger_types = {
+            'type': 'str',
+            'related_resource_id': 'str',
+            'message': 'str',
+            'time_created': 'datetime'
+        }
+
+        self.attribute_map = {
+            'type': 'type',
+            'related_resource_id': 'relatedResourceId',
+            'message': 'message',
+            'time_created': 'timeCreated'
+        }
+
+        self._type = None
+        self._related_resource_id = None
+        self._message = None
+        self._time_created = None
+
+    @property
+    def type(self):
+        """
+        **[Required]** Gets the type of this AddResourceLockDetails.
+        Type of the lock.
+
+        Allowed values for this property are: "FULL", "DELETE"
+
+
+        :return: The type of this AddResourceLockDetails.
+        :rtype: str
+        """
+        return self._type
+
+    @type.setter
+    def type(self, type):
+        """
+        Sets the type of this AddResourceLockDetails.
+        Type of the lock.
+
+
+        :param type: The type of this AddResourceLockDetails.
+        :type: str
+        """
+        allowed_values = ["FULL", "DELETE"]
+        if not value_allowed_none_or_none_sentinel(type, allowed_values):
+            raise ValueError(
+                f"Invalid value for `type`, must be None or one of {allowed_values}"
+            )
+        self._type = type
+
+    @property
+    def related_resource_id(self):
+        """
+        Gets the related_resource_id of this AddResourceLockDetails.
+        The id of the resource that is locking this resource. Indicates that deleting this resource will remove the lock.
+
+
+        :return: The related_resource_id of this AddResourceLockDetails.
+        :rtype: str
+        """
+        return self._related_resource_id
+
+    @related_resource_id.setter
+    def related_resource_id(self, related_resource_id):
+        """
+        Sets the related_resource_id of this AddResourceLockDetails.
+        The id of the resource that is locking this resource. Indicates that deleting this resource will remove the lock.
+
+
+        :param related_resource_id: The related_resource_id of this AddResourceLockDetails.
+        :type: str
+        """
+        self._related_resource_id = related_resource_id
+
+    @property
+    def message(self):
+        """
+        Gets the message of this AddResourceLockDetails.
+        A message added by the creator of the lock. This is typically used to give an
+        indication of why the resource is locked.
+
+
+        :return: The message of this AddResourceLockDetails.
+        :rtype: str
+        """
+        return self._message
+
+    @message.setter
+    def message(self, message):
+        """
+        Sets the message of this AddResourceLockDetails.
+        A message added by the creator of the lock. This is typically used to give an
+        indication of why the resource is locked.
+
+
+        :param message: The message of this AddResourceLockDetails.
+        :type: str
+        """
+        self._message = message
+
+    @property
+    def time_created(self):
+        """
+        Gets the time_created of this AddResourceLockDetails.
+        When the lock was created.
+
+
+        :return: The time_created of this AddResourceLockDetails.
+        :rtype: datetime
+        """
+        return self._time_created
+
+    @time_created.setter
+    def time_created(self, time_created):
+        """
+        Sets the time_created of this AddResourceLockDetails.
+        When the lock was created.
+
+
+        :param time_created: The time_created of this AddResourceLockDetails.
+        :type: datetime
+        """
+        self._time_created = time_created
+
+    def __repr__(self):
+        return formatted_flat_dict(self)
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not self == other

oci/data_catalog/models/catalog.py

@@ -98,6 +98,10 @@ class Catalog(object):
             The value to assign to the freeform_tags property of this Catalog.
         :type freeform_tags: dict(str, str)
 
+        :param system_tags:
+            The value to assign to the system_tags property of this Catalog.
+        :type system_tags: dict(str, dict(str, object))
+
         :param defined_tags:
             The value to assign to the defined_tags property of this Catalog.
         :type defined_tags: dict(str, dict(str, object))
@@ -106,6 +110,10 @@ class Catalog(object):
             The value to assign to the attached_catalog_private_endpoints property of this Catalog.
         :type attached_catalog_private_endpoints: list[str]
 
+        :param locks:
+            The value to assign to the locks property of this Catalog.
+        :type locks: list[oci.data_catalog.models.ResourceLock]
+
         """
         self.swagger_types = {
             'id': 'str',
@@ -119,8 +127,10 @@ class Catalog(object):
             'lifecycle_state': 'str',
             'lifecycle_details': 'str',
             'freeform_tags': 'dict(str, str)',
+            'system_tags': 'dict(str, dict(str, object))',
             'defined_tags': 'dict(str, dict(str, object))',
-            'attached_catalog_private_endpoints': 'list[str]'
+            'attached_catalog_private_endpoints': 'list[str]',
+            'locks': 'list[ResourceLock]'
         }
 
         self.attribute_map = {
@@ -135,8 +145,10 @@ class Catalog(object):
             'lifecycle_state': 'lifecycleState',
             'lifecycle_details': 'lifecycleDetails',
             'freeform_tags': 'freeformTags',
+            'system_tags': 'systemTags',
             'defined_tags': 'definedTags',
-            'attached_catalog_private_endpoints': 'attachedCatalogPrivateEndpoints'
+            'attached_catalog_private_endpoints': 'attachedCatalogPrivateEndpoints',
+            'locks': 'locks'
         }
 
         self._id = None
@@ -150,8 +162,10 @@ class Catalog(object):
         self._lifecycle_state = None
         self._lifecycle_details = None
         self._freeform_tags = None
+        self._system_tags = None
         self._defined_tags = None
         self._attached_catalog_private_endpoints = None
+        self._locks = None
 
     @property
     def id(self):
@@ -437,6 +451,42 @@ class Catalog(object):
         """
         self._freeform_tags = freeform_tags
 
+    @property
+    def system_tags(self):
+        """
+        Gets the system_tags of this Catalog.
+        System tags for this resource. Each key is predefined and scoped to a namespace.
+        For more information, see `Resource Tags`__.
+        System tags can be viewed by users, but can only be created by the system.
+
+        Example: `{\"orcl-cloud\": {\"free-tier-retained\": \"true\"}}`
+
+        __ https://docs.cloud.oracle.com/Content/General/Concepts/resourcetags.htm
+
+
+        :return: The system_tags of this Catalog.
+        :rtype: dict(str, dict(str, object))
+        """
+        return self._system_tags
+
+    @system_tags.setter
+    def system_tags(self, system_tags):
+        """
+        Sets the system_tags of this Catalog.
+        System tags for this resource. Each key is predefined and scoped to a namespace.
+        For more information, see `Resource Tags`__.
+        System tags can be viewed by users, but can only be created by the system.
+
+        Example: `{\"orcl-cloud\": {\"free-tier-retained\": \"true\"}}`
+
+        __ https://docs.cloud.oracle.com/Content/General/Concepts/resourcetags.htm
+
+
+        :param system_tags: The system_tags of this Catalog.
+        :type: dict(str, dict(str, object))
+        """
+        self._system_tags = system_tags
+
     @property
     def defined_tags(self):
         """
@@ -487,6 +537,30 @@ class Catalog(object):
         """
         self._attached_catalog_private_endpoints = attached_catalog_private_endpoints
 
+    @property
+    def locks(self):
+        """
+        Gets the locks of this Catalog.
+        Locks associated with this resource.
+
+
+        :return: The locks of this Catalog.
+        :rtype: list[oci.data_catalog.models.ResourceLock]
+        """
+        return self._locks
+
+    @locks.setter
+    def locks(self, locks):
+        """
+        Sets the locks of this Catalog.
+        Locks associated with this resource.
+
+
+        :param locks: The locks of this Catalog.
+        :type: list[oci.data_catalog.models.ResourceLock]
+        """
+        self._locks = locks
+
     def __repr__(self):
         return formatted_flat_dict(self)