text: # coding: utf-8
  # Copyright (c) 2016, 2022, 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.
  
  from __future__ import absolute_import
  
  from oci._vendor import requests  # noqa: F401
  from oci._vendor import six
  
  from oci import retry, circuit_breaker  # noqa: F401
  from oci.base_client import BaseClient
  from oci.config import get_config_value_or_default, validate_config
  from oci.signer import Signer
  from oci.util import Sentinel, get_signer_from_authentication_type, AUTHENTICATION_TYPE_FIELD_NAME
  from .models import data_catalog_type_mapping
  missing = Sentinel("Missing")
  
  
  class DataCatalogClient(object):
      """
      Use the Data Catalog APIs to collect, organize, find, access, understand, enrich, and activate technical, business, and operational metadata.
      For more information, see [Data Catalog](https://docs.oracle.com/iaas/data-catalog/home.htm).
      """
  
      def __init__(self, config, **kwargs):
          """
          Creates a new service client
  
          :param dict config:
              Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
              The :py:meth:`~oci.config.from_file` method can be used to load configuration from a file. Alternatively, a ``dict`` can be passed. You can validate_config
              the dict using :py:meth:`~oci.config.validate_config`
  
          :param str service_endpoint: (optional)
              The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
              not provided then it will be derived using the region in the config parameter. You should only provide this keyword argument if you have an explicit
              need to specify a service endpoint.
  
          :param timeout: (optional)
              The connection and read timeouts for the client. The default values are connection timeout 10 seconds and read timeout 60 seconds. This keyword argument can be provided
              as a single float, in which case the value provided is used for both the read and connection timeouts, or as a tuple of two floats. If
              a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
          :type timeout: float or tuple(float, float)
  
          :param signer: (optional)
              The signer to use when signing requests made by the service client. The default is to use a :py:class:`~oci.signer.Signer` based on the values
              provided in the config parameter.
  
              One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
              by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
          :type signer: :py:class:`~oci.signer.AbstractBaseSigner`
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to all calls made by this service client (i.e. at the client level). There is no retry strategy applied by default.
              Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
              Any value provided at the operation level will override whatever is specified at the client level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
              is also available. The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
          :param obj circuit_breaker_strategy: (optional)
              A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
              This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
              The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
  
          :param function circuit_breaker_callback: (optional)
              Callback function to receive any exceptions triggerred by the circuit breaker.
  
          :param allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
              allow control characters to be in the response object.
          """
          validate_config(config, signer=kwargs.get('signer'))
          if 'signer' in kwargs:
              signer = kwargs['signer']
  
          elif AUTHENTICATION_TYPE_FIELD_NAME in config:
              signer = get_signer_from_authentication_type(config)
  
          else:
              signer = Signer(
                  tenancy=config["tenancy"],
                  user=config["user"],
                  fingerprint=config["fingerprint"],
                  private_key_file_location=config.get("key_file"),
                  pass_phrase=get_config_value_or_default(config, "pass_phrase"),
                  private_key_content=config.get("key_content")
              )
  
          base_client_init_kwargs = {
              'regional_client': True,
              'service_endpoint': kwargs.get('service_endpoint'),
              'base_path': '/20190325',
              'service_endpoint_template': 'https://datacatalog.{region}.oci.{secondLevelDomain}',
              'skip_deserialization': kwargs.get('skip_deserialization', False),
              'circuit_breaker_strategy': kwargs.get('circuit_breaker_strategy', circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
          }
          if 'timeout' in kwargs:
              base_client_init_kwargs['timeout'] = kwargs.get('timeout')
          if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
              base_client_init_kwargs['circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
          if 'allow_control_chars' in kwargs:
              base_client_init_kwargs['allow_control_chars'] = kwargs.get('allow_control_chars')
          self.base_client = BaseClient("data_catalog", config, signer, data_catalog_type_mapping, **base_client_init_kwargs)
          self.retry_strategy = kwargs.get('retry_strategy')
          self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
  
      def add_data_selector_patterns(self, catalog_id, data_asset_key, data_selector_pattern_details, **kwargs):
          """
          Add data selector pattern to the data asset.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAsset`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/add_data_selector_patterns.py.html>`__ to see an example of how to use add_data_selector_patterns API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/actions/addDataSelectorPatterns"
          method = "POST"
          operation_name = "add_data_selector_patterns"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/AddDataSelectorPatterns"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "if_match",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "add_data_selector_patterns got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "if-match": kwargs.get("if_match", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=data_selector_pattern_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=data_selector_pattern_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def associate_custom_property(self, catalog_id, type_key, associate_custom_property_details, **kwargs):
          """
          Associate the custom property for the given type
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Type`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/associate_custom_property.py.html>`__ to see an example of how to use associate_custom_property API.
          """
          resource_path = "/catalogs/{catalogId}/types/{typeKey}/actions/associateCustomProperties"
          method = "POST"
          operation_name = "associate_custom_property"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Type/AssociateCustomProperty"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "if_match",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "associate_custom_property got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "typeKey": type_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "if-match": kwargs.get("if_match", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=associate_custom_property_details,
                  response_type="Type",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=associate_custom_property_details,
                  response_type="Type",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def attach_catalog_private_endpoint(self, attach_catalog_private_endpoint_details, catalog_id, **kwargs):
          """
          Attaches a private reverse connection endpoint resource to a data catalog resource. When provided, 'If-Match' is checked against 'ETag' values of the resource.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/attach_catalog_private_endpoint.py.html>`__ to see an example of how to use attach_catalog_private_endpoint API.
          """
          resource_path = "/catalogs/{catalogId}/actions/attachCatalogPrivateEndpoint"
          method = "POST"
          operation_name = "attach_catalog_private_endpoint"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/AttachCatalogPrivateEndpoint"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "attach_catalog_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=attach_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=attach_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def change_catalog_compartment(self, change_catalog_compartment_details, catalog_id, **kwargs):
          """
          Moves a resource into a different compartment. When provided, 'If-Match' is checked against 'ETag' values of the resource.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/change_catalog_compartment.py.html>`__ to see an example of how to use change_catalog_compartment API.
          """
          resource_path = "/catalogs/{catalogId}/actions/changeCompartment"
          method = "POST"
          operation_name = "change_catalog_compartment"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/ChangeCatalogCompartment"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_catalog_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_catalog_compartment_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_catalog_compartment_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def change_catalog_private_endpoint_compartment(self, change_catalog_private_endpoint_compartment_details, catalog_private_endpoint_id, **kwargs):
          """
          Moves a resource into a different compartment. When provided, 'If-Match' is checked against 'ETag' values of the resource.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/change_catalog_private_endpoint_compartment.py.html>`__ to see an example of how to use change_catalog_private_endpoint_compartment API.
          """
          resource_path = "/catalogPrivateEndpoints/{catalogPrivateEndpointId}/actions/changeCompartment"
          method = "POST"
          operation_name = "change_catalog_private_endpoint_compartment"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CatalogPrivateEndpoint/ChangeCatalogPrivateEndpointCompartment"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_catalog_private_endpoint_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogPrivateEndpointId": catalog_private_endpoint_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_catalog_private_endpoint_compartment_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_catalog_private_endpoint_compartment_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def change_metastore_compartment(self, change_metastore_compartment_details, metastore_id, **kwargs):
          """
          Moves a resource into a different compartment. When provided, 'If-Match' is checked against 'ETag' values of the resource.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/change_metastore_compartment.py.html>`__ to see an example of how to use change_metastore_compartment API.
          """
          resource_path = "/metastores/{metastoreId}/actions/changeCompartment"
          method = "POST"
          operation_name = "change_metastore_compartment"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Metastore/ChangeMetastoreCompartment"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_metastore_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "metastoreId": metastore_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_metastore_compartment_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_metastore_compartment_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_attribute(self, catalog_id, data_asset_key, entity_key, create_attribute_details, **kwargs):
          """
          Creates a new entity attribute.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Attribute`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_attribute.py.html>`__ to see an example of how to use create_attribute API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes"
          method = "POST"
          operation_name = "create_attribute"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Attribute/CreateAttribute"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_attribute got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_attribute_details,
                  response_type="Attribute",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_attribute_details,
                  response_type="Attribute",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_attribute_tag(self, catalog_id, data_asset_key, entity_key, attribute_key, create_attribute_tag_details, **kwargs):
          """
          Creates a new entity attribute tag.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.AttributeTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_attribute_tag.py.html>`__ to see an example of how to use create_attribute_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes/{attributeKey}/tags"
          method = "POST"
          operation_name = "create_attribute_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/AttributeTag/CreateAttributeTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_attribute_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "attributeKey": attribute_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_attribute_tag_details,
                  response_type="AttributeTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_attribute_tag_details,
                  response_type="AttributeTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_catalog(self, create_catalog_details, **kwargs):
          """
          Creates a new data catalog instance that includes a console and an API URL for managing metadata operations.
          For more information, please see the documentation.
  
  
          :param oci.data_catalog.models.CreateCatalogDetails create_catalog_details: (required)
              Details for the new data catalog.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_catalog.py.html>`__ to see an example of how to use create_catalog API.
          """
          resource_path = "/catalogs"
          method = "POST"
          operation_name = "create_catalog"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/CreateCatalog"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_retry_token",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_catalog got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-retry-token": kwargs.get("opc_retry_token", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_catalog_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_catalog_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_catalog_private_endpoint(self, create_catalog_private_endpoint_details, **kwargs):
          """
          Create a new private reverse connection endpoint.
  
  
          :param oci.data_catalog.models.CreateCatalogPrivateEndpointDetails create_catalog_private_endpoint_details: (required)
              The information used to create the private reverse connection.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_catalog_private_endpoint.py.html>`__ to see an example of how to use create_catalog_private_endpoint API.
          """
          resource_path = "/catalogPrivateEndpoints"
          method = "POST"
          operation_name = "create_catalog_private_endpoint"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CatalogPrivateEndpoint/CreateCatalogPrivateEndpoint"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_catalog_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_connection(self, catalog_id, data_asset_key, create_connection_details, **kwargs):
          """
          Creates a new connection.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Connection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_connection.py.html>`__ to see an example of how to use create_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections"
          method = "POST"
          operation_name = "create_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Connection/CreateConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_connection_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_connection_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_custom_property(self, catalog_id, namespace_id, create_custom_property_details, **kwargs):
          """
          Create a new Custom Property
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.CustomProperty`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_custom_property.py.html>`__ to see an example of how to use create_custom_property API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}/customProperties"
          method = "POST"
          operation_name = "create_custom_property"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CustomProperty/CreateCustomProperty"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_custom_property got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_custom_property_details,
                  response_type="CustomProperty",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_custom_property_details,
                  response_type="CustomProperty",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_data_asset(self, catalog_id, create_data_asset_details, **kwargs):
          """
          Create a new data asset.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAsset`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_data_asset.py.html>`__ to see an example of how to use create_data_asset API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets"
          method = "POST"
          operation_name = "create_data_asset"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/CreateDataAsset"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_data_asset got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_data_asset_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_data_asset_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_data_asset_tag(self, catalog_id, data_asset_key, create_data_asset_tag_details, **kwargs):
          """
          Creates a new data asset tag.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAssetTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_data_asset_tag.py.html>`__ to see an example of how to use create_data_asset_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/tags"
          method = "POST"
          operation_name = "create_data_asset_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAssetTag/CreateDataAssetTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_data_asset_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_data_asset_tag_details,
                  response_type="DataAssetTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_data_asset_tag_details,
                  response_type="DataAssetTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_entity(self, catalog_id, data_asset_key, create_entity_details, **kwargs):
          """
          Creates a new data entity.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Entity`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_entity.py.html>`__ to see an example of how to use create_entity API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities"
          method = "POST"
          operation_name = "create_entity"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Entity/CreateEntity"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_entity got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_entity_details,
                  response_type="Entity",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_entity_details,
                  response_type="Entity",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_entity_tag(self, catalog_id, data_asset_key, entity_key, create_entity_tag_details, **kwargs):
          """
          Creates a new entity tag.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.EntityTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_entity_tag.py.html>`__ to see an example of how to use create_entity_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/tags"
          method = "POST"
          operation_name = "create_entity_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/EntityTag/CreateEntityTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_entity_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_entity_tag_details,
                  response_type="EntityTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_entity_tag_details,
                  response_type="EntityTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_folder(self, catalog_id, data_asset_key, create_folder_details, **kwargs):
          """
          Creates a new folder.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Folder`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_folder.py.html>`__ to see an example of how to use create_folder API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders"
          method = "POST"
          operation_name = "create_folder"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Folder/CreateFolder"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_folder got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_folder_details,
                  response_type="Folder",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_folder_details,
                  response_type="Folder",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_folder_tag(self, catalog_id, data_asset_key, folder_key, create_folder_tag_details, **kwargs):
          """
          Creates a new folder tag.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.FolderTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_folder_tag.py.html>`__ to see an example of how to use create_folder_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders/{folderKey}/tags"
          method = "POST"
          operation_name = "create_folder_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/FolderTag/CreateFolderTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_folder_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "folderKey": folder_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_folder_tag_details,
                  response_type="FolderTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_folder_tag_details,
                  response_type="FolderTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_glossary(self, catalog_id, create_glossary_details, **kwargs):
          """
          Creates a new glossary.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Glossary`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_glossary.py.html>`__ to see an example of how to use create_glossary API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries"
          method = "POST"
          operation_name = "create_glossary"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/CreateGlossary"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_glossary got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_glossary_details,
                  response_type="Glossary",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_glossary_details,
                  response_type="Glossary",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_job(self, catalog_id, create_job_details, **kwargs):
          """
          Creates a new job.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Job`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_job.py.html>`__ to see an example of how to use create_job API.
          """
          resource_path = "/catalogs/{catalogId}/jobs"
          method = "POST"
          operation_name = "create_job"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Job/CreateJob"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_job got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_job_details,
                  response_type="Job",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_job_details,
                  response_type="Job",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_job_definition(self, catalog_id, create_job_definition_details, **kwargs):
          """
          Creates a new job definition.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobDefinition`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_job_definition.py.html>`__ to see an example of how to use create_job_definition API.
          """
          resource_path = "/catalogs/{catalogId}/jobDefinitions"
          method = "POST"
          operation_name = "create_job_definition"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobDefinition/CreateJobDefinition"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_job_definition got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_job_definition_details,
                  response_type="JobDefinition",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_job_definition_details,
                  response_type="JobDefinition",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_job_execution(self, catalog_id, job_key, create_job_execution_details, **kwargs):
          """
          Creates a new job execution.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobExecution`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_job_execution.py.html>`__ to see an example of how to use create_job_execution API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}/executions"
          method = "POST"
          operation_name = "create_job_execution"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobExecution/CreateJobExecution"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_job_execution got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_job_execution_details,
                  response_type="JobExecution",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_job_execution_details,
                  response_type="JobExecution",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_metastore(self, create_metastore_details, **kwargs):
          """
          Creates a new metastore.
  
  
          :param oci.data_catalog.models.CreateMetastoreDetails create_metastore_details: (required)
              Information about a new metastore to be created.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_metastore.py.html>`__ to see an example of how to use create_metastore API.
          """
          resource_path = "/metastores"
          method = "POST"
          operation_name = "create_metastore"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Metastore/CreateMetastore"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_retry_token",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_metastore got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-retry-token": kwargs.get("opc_retry_token", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_metastore_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_metastore_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_namespace(self, catalog_id, create_namespace_details, **kwargs):
          """
          Create a new Namespace to be used by a custom property
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Namespace`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_namespace.py.html>`__ to see an example of how to use create_namespace API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces"
          method = "POST"
          operation_name = "create_namespace"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Namespace/CreateNamespace"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_namespace got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_namespace_details,
                  response_type="Namespace",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_namespace_details,
                  response_type="Namespace",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_pattern(self, catalog_id, create_pattern_details, **kwargs):
          """
          Create a new pattern.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Pattern`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_pattern.py.html>`__ to see an example of how to use create_pattern API.
          """
          resource_path = "/catalogs/{catalogId}/patterns"
          method = "POST"
          operation_name = "create_pattern"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Pattern/CreatePattern"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_pattern got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_pattern_details,
                  response_type="Pattern",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_pattern_details,
                  response_type="Pattern",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_term(self, catalog_id, glossary_key, create_term_details, **kwargs):
          """
          Create a new term within a glossary.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Term`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_term.py.html>`__ to see an example of how to use create_term API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms"
          method = "POST"
          operation_name = "create_term"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Term/CreateTerm"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_term got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_term_details,
                  response_type="Term",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_term_details,
                  response_type="Term",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def create_term_relationship(self, catalog_id, glossary_key, term_key, create_term_relationship_details, **kwargs):
          """
          Creates a new term relationship for this term within a glossary.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.TermRelationship`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/create_term_relationship.py.html>`__ to see an example of how to use create_term_relationship API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}/termRelationships"
          method = "POST"
          operation_name = "create_term_relationship"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/TermRelationship/CreateTermRelationship"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_term_relationship got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_term_relationship_details,
                  response_type="TermRelationship",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=create_term_relationship_details,
                  response_type="TermRelationship",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_attribute(self, catalog_id, data_asset_key, entity_key, attribute_key, **kwargs):
          """
          Deletes a specific entity attribute.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_attribute.py.html>`__ to see an example of how to use delete_attribute API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes/{attributeKey}"
          method = "DELETE"
          operation_name = "delete_attribute"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Attribute/DeleteAttribute"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_attribute got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "attributeKey": attribute_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_attribute_tag(self, catalog_id, data_asset_key, entity_key, attribute_key, tag_key, **kwargs):
          """
          Deletes a specific entity attribute tag.
  
  
          :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 str tag_key: (required)
              Unique tag key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_attribute_tag.py.html>`__ to see an example of how to use delete_attribute_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes/{attributeKey}/tags/{tagKey}"
          method = "DELETE"
          operation_name = "delete_attribute_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/AttributeTag/DeleteAttributeTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_attribute_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "attributeKey": attribute_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_catalog(self, catalog_id, **kwargs):
          """
          Deletes a data catalog resource by identifier.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_catalog.py.html>`__ to see an example of how to use delete_catalog API.
          """
          resource_path = "/catalogs/{catalogId}"
          method = "DELETE"
          operation_name = "delete_catalog"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/DeleteCatalog"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_catalog got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_catalog_private_endpoint(self, catalog_private_endpoint_id, **kwargs):
          """
          Deletes a private reverse connection endpoint by identifier.
  
  
          :param str catalog_private_endpoint_id: (required)
              Unique private reverse connection identifier.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_catalog_private_endpoint.py.html>`__ to see an example of how to use delete_catalog_private_endpoint API.
          """
          resource_path = "/catalogPrivateEndpoints/{catalogPrivateEndpointId}"
          method = "DELETE"
          operation_name = "delete_catalog_private_endpoint"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CatalogPrivateEndpoint/DeleteCatalogPrivateEndpoint"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_catalog_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogPrivateEndpointId": catalog_private_endpoint_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_connection(self, catalog_id, data_asset_key, connection_key, **kwargs):
          """
          Deletes a specific connection of a data asset.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_connection.py.html>`__ to see an example of how to use delete_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections/{connectionKey}"
          method = "DELETE"
          operation_name = "delete_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Connection/DeleteConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "connectionKey": connection_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_custom_property(self, catalog_id, namespace_id, custom_property_key, **kwargs):
          """
          Deletes a specific custom property identified by it's key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_custom_property.py.html>`__ to see an example of how to use delete_custom_property API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}/customProperties/{customPropertyKey}"
          method = "DELETE"
          operation_name = "delete_custom_property"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CustomProperty/DeleteCustomProperty"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_custom_property got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id,
              "customPropertyKey": custom_property_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_data_asset(self, catalog_id, data_asset_key, **kwargs):
          """
          Deletes a specific data asset identified by it's key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_data_asset.py.html>`__ to see an example of how to use delete_data_asset API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}"
          method = "DELETE"
          operation_name = "delete_data_asset"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/DeleteDataAsset"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_data_asset got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_data_asset_tag(self, catalog_id, data_asset_key, tag_key, **kwargs):
          """
          Deletes a specific data asset tag.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param str tag_key: (required)
              Unique tag key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_data_asset_tag.py.html>`__ to see an example of how to use delete_data_asset_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/tags/{tagKey}"
          method = "DELETE"
          operation_name = "delete_data_asset_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAssetTag/DeleteDataAssetTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_data_asset_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_entity(self, catalog_id, data_asset_key, entity_key, **kwargs):
          """
          Deletes a specific data entity.
  
  
          :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 if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_entity.py.html>`__ to see an example of how to use delete_entity API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}"
          method = "DELETE"
          operation_name = "delete_entity"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Entity/DeleteEntity"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_entity got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_entity_tag(self, catalog_id, data_asset_key, entity_key, tag_key, **kwargs):
          """
          Deletes a specific entity tag.
  
  
          :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 tag_key: (required)
              Unique tag key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_entity_tag.py.html>`__ to see an example of how to use delete_entity_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/tags/{tagKey}"
          method = "DELETE"
          operation_name = "delete_entity_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/EntityTag/DeleteEntityTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_entity_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_folder(self, catalog_id, data_asset_key, folder_key, **kwargs):
          """
          Deletes a specific folder of a data asset identified by it's key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_folder.py.html>`__ to see an example of how to use delete_folder API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders/{folderKey}"
          method = "DELETE"
          operation_name = "delete_folder"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Folder/DeleteFolder"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_folder got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "folderKey": folder_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_folder_tag(self, catalog_id, data_asset_key, folder_key, tag_key, **kwargs):
          """
          Deletes a specific folder tag.
  
  
          :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 str tag_key: (required)
              Unique tag key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_folder_tag.py.html>`__ to see an example of how to use delete_folder_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders/{folderKey}/tags/{tagKey}"
          method = "DELETE"
          operation_name = "delete_folder_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/FolderTag/DeleteFolderTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_folder_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "folderKey": folder_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_glossary(self, catalog_id, glossary_key, **kwargs):
          """
          Deletes a specific glossary identified by it's key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str glossary_key: (required)
              Unique glossary key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_glossary.py.html>`__ to see an example of how to use delete_glossary API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}"
          method = "DELETE"
          operation_name = "delete_glossary"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/DeleteGlossary"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_glossary got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_job(self, catalog_id, job_key, **kwargs):
          """
          Deletes a specific job identified by it's key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_job.py.html>`__ to see an example of how to use delete_job API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}"
          method = "DELETE"
          operation_name = "delete_job"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Job/DeleteJob"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_job got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_job_definition(self, catalog_id, job_definition_key, **kwargs):
          """
          Deletes a specific job definition identified by it's key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_definition_key: (required)
              Unique job definition key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_job_definition.py.html>`__ to see an example of how to use delete_job_definition API.
          """
          resource_path = "/catalogs/{catalogId}/jobDefinitions/{jobDefinitionKey}"
          method = "DELETE"
          operation_name = "delete_job_definition"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobDefinition/DeleteJobDefinition"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_job_definition got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobDefinitionKey": job_definition_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_metastore(self, metastore_id, **kwargs):
          """
          Deletes a metastore resource by identifier.
  
  
          :param str metastore_id: (required)
              The metastore's OCID.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_metastore.py.html>`__ to see an example of how to use delete_metastore API.
          """
          resource_path = "/metastores/{metastoreId}"
          method = "DELETE"
          operation_name = "delete_metastore"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Metastore/DeleteMetastore"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_metastore got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "metastoreId": metastore_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_namespace(self, catalog_id, namespace_id, **kwargs):
          """
          Deletes a specific Namespace identified by it's key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str namespace_id: (required)
              Unique namespace identifier.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_namespace.py.html>`__ to see an example of how to use delete_namespace API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}"
          method = "DELETE"
          operation_name = "delete_namespace"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Namespace/DeleteNamespace"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_namespace got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_pattern(self, catalog_id, pattern_key, **kwargs):
          """
          Deletes a specific pattern identified by it's key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str pattern_key: (required)
              Unique pattern key.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_pattern.py.html>`__ to see an example of how to use delete_pattern API.
          """
          resource_path = "/catalogs/{catalogId}/patterns/{patternKey}"
          method = "DELETE"
          operation_name = "delete_pattern"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Pattern/DeletePattern"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_pattern got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "patternKey": pattern_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_term(self, catalog_id, glossary_key, term_key, **kwargs):
          """
          Deletes a specific glossary term.
  
  
          :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 if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_term.py.html>`__ to see an example of how to use delete_term API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}"
          method = "DELETE"
          operation_name = "delete_term"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Term/DeleteTerm"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_term got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def delete_term_relationship(self, catalog_id, glossary_key, term_key, term_relationship_key, **kwargs):
          """
          Deletes a specific glossary term relationship.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/delete_term_relationship.py.html>`__ to see an example of how to use delete_term_relationship API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}/termRelationships/{termRelationshipKey}"
          method = "DELETE"
          operation_name = "delete_term_relationship"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/TermRelationship/DeleteTermRelationship"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_term_relationship got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key,
              "termRelationshipKey": term_relationship_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def detach_catalog_private_endpoint(self, detach_catalog_private_endpoint_details, catalog_id, **kwargs):
          """
          Detaches a private reverse connection endpoint resource to a data catalog resource. When provided, 'If-Match' is checked against 'ETag' values of the resource.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/detach_catalog_private_endpoint.py.html>`__ to see an example of how to use detach_catalog_private_endpoint API.
          """
          resource_path = "/catalogs/{catalogId}/actions/detachCatalogPrivateEndpoint"
          method = "POST"
          operation_name = "detach_catalog_private_endpoint"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/DetachCatalogPrivateEndpoint"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "detach_catalog_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=detach_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=detach_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def disassociate_custom_property(self, catalog_id, type_key, disassociate_custom_property_details, **kwargs):
          """
          Remove the custom property for the given type
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Type`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/disassociate_custom_property.py.html>`__ to see an example of how to use disassociate_custom_property API.
          """
          resource_path = "/catalogs/{catalogId}/types/{typeKey}/actions/disassociateCustomProperties"
          method = "POST"
          operation_name = "disassociate_custom_property"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Type/DisassociateCustomProperty"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "if_match",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "disassociate_custom_property got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "typeKey": type_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "if-match": kwargs.get("if_match", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=disassociate_custom_property_details,
                  response_type="Type",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=disassociate_custom_property_details,
                  response_type="Type",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def expand_tree_for_glossary(self, catalog_id, glossary_key, **kwargs):
          """
          Returns the fully expanded tree hierarchy of parent and child terms in this glossary.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str glossary_key: (required)
              Unique glossary key.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.GlossaryTreeElement`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/expand_tree_for_glossary.py.html>`__ to see an example of how to use expand_tree_for_glossary API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/actions/expandTree"
          method = "POST"
          operation_name = "expand_tree_for_glossary"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/ExpandTreeForGlossary"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "expand_tree_for_glossary got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="list[GlossaryTreeElement]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="list[GlossaryTreeElement]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def export_glossary(self, catalog_id, glossary_key, **kwargs):
          """
          Export the glossary and the terms and return the exported glossary as csv or json.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str glossary_key: (required)
              Unique glossary key.
  
          :param bool is_relationship_exported: (optional)
              Specify if the relationship metadata is exported for the glossary.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type str
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/export_glossary.py.html>`__ to see an example of how to use export_glossary API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/actions/export"
          method = "POST"
          operation_name = "export_glossary"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/ExportGlossary"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "is_relationship_exported",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "export_glossary got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          query_params = {
              "isRelationshipExported": kwargs.get("is_relationship_exported", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json, text/csv, application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="str",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="str",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_attribute(self, catalog_id, data_asset_key, entity_key, attribute_key, **kwargs):
          """
          Gets a specific entity attribute by key.
  
  
          :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 bool is_include_object_relationships: (optional)
              Indicates whether the list of objects and their relationships to this object will be provided in the response.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity attribute response.
  
              Allowed values are: "key", "displayName", "description", "entityKey", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "externalDataType", "externalKey", "isIncrementalData", "isNullable", "length", "position", "precision", "scale", "timeExternal", "uri", "properties", "path", "minCollectionCount", "maxCollectionCount", "datatypeEntityKey", "externalDatatypeEntityKey", "parentAttributeKey", "externalParentAttributeKey", "typeKey"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Attribute`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_attribute.py.html>`__ to see an example of how to use get_attribute API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes/{attributeKey}"
          method = "GET"
          operation_name = "get_attribute"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Attribute/GetAttribute"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "is_include_object_relationships",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_attribute got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "attributeKey": attribute_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "entityKey", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "externalDataType", "externalKey", "isIncrementalData", "isNullable", "length", "position", "precision", "scale", "timeExternal", "uri", "properties", "path", "minCollectionCount", "maxCollectionCount", "datatypeEntityKey", "externalDatatypeEntityKey", "parentAttributeKey", "externalParentAttributeKey", "typeKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "isIncludeObjectRelationships": kwargs.get("is_include_object_relationships", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Attribute",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Attribute",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_attribute_tag(self, catalog_id, data_asset_key, entity_key, attribute_key, tag_key, **kwargs):
          """
          Gets a specific entity attribute tag by key.
  
  
          :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 str tag_key: (required)
              Unique tag key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity attribute tag response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "attributeKey"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.AttributeTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_attribute_tag.py.html>`__ to see an example of how to use get_attribute_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes/{attributeKey}/tags/{tagKey}"
          method = "GET"
          operation_name = "get_attribute_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/AttributeTag/GetAttributeTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_attribute_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "attributeKey": attribute_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "attributeKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="AttributeTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="AttributeTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_catalog(self, catalog_id, **kwargs):
          """
          Gets a data catalog by identifier.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Catalog`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_catalog.py.html>`__ to see an example of how to use get_catalog API.
          """
          resource_path = "/catalogs/{catalogId}"
          method = "GET"
          operation_name = "get_catalog"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/GetCatalog"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_catalog got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="Catalog",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="Catalog",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_catalog_private_endpoint(self, catalog_private_endpoint_id, **kwargs):
          """
          Gets a specific private reverse connection by identifier.
  
  
          :param str catalog_private_endpoint_id: (required)
              Unique private reverse connection identifier.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.CatalogPrivateEndpoint`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_catalog_private_endpoint.py.html>`__ to see an example of how to use get_catalog_private_endpoint API.
          """
          resource_path = "/catalogPrivateEndpoints/{catalogPrivateEndpointId}"
          method = "GET"
          operation_name = "get_catalog_private_endpoint"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CatalogPrivateEndpoint/GetCatalogPrivateEndpoint"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_catalog_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogPrivateEndpointId": catalog_private_endpoint_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="CatalogPrivateEndpoint",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="CatalogPrivateEndpoint",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_connection(self, catalog_id, data_asset_key, connection_key, **kwargs):
          """
          Gets a specific data asset connection by key.
  
  
          :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 list[str] fields: (optional)
              Specifies the fields to return in a connection response.
  
              Allowed values are: "key", "displayName", "description", "dataAssetKey", "typeKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties", "externalKey", "timeStatusUpdated", "lifecycleState", "isDefault", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Connection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_connection.py.html>`__ to see an example of how to use get_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections/{connectionKey}"
          method = "GET"
          operation_name = "get_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Connection/GetConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "connectionKey": connection_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "dataAssetKey", "typeKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties", "externalKey", "timeStatusUpdated", "lifecycleState", "isDefault", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_custom_property(self, catalog_id, namespace_id, custom_property_key, **kwargs):
          """
          Gets a specific custom property for the given key within a data catalog.
  
  
          :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 list[str] fields: (optional)
              Specifies the fields to return in a custom property response.
  
              Allowed values are: "key", "displayName", "description", "dataType", "namespaceName", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.CustomProperty`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_custom_property.py.html>`__ to see an example of how to use get_custom_property API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}/customProperties/{customPropertyKey}"
          method = "GET"
          operation_name = "get_custom_property"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CustomProperty/GetCustomProperty"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_custom_property got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id,
              "customPropertyKey": custom_property_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "dataType", "namespaceName", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="CustomProperty",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="CustomProperty",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_data_asset(self, catalog_id, data_asset_key, **kwargs):
          """
          Gets a specific data asset for the given key within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a data asset response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "externalKey", "typeKey", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "uri", "properties"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAsset`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_data_asset.py.html>`__ to see an example of how to use get_data_asset API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}"
          method = "GET"
          operation_name = "get_data_asset"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/GetDataAsset"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_data_asset got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "externalKey", "typeKey", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "uri", "properties"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_data_asset_tag(self, catalog_id, data_asset_key, tag_key, **kwargs):
          """
          Gets a specific data asset tag by key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param str tag_key: (required)
              Unique tag key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a data asset tag response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "dataAssetKey"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAssetTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_data_asset_tag.py.html>`__ to see an example of how to use get_data_asset_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/tags/{tagKey}"
          method = "GET"
          operation_name = "get_data_asset_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAssetTag/GetDataAssetTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_data_asset_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "dataAssetKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAssetTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAssetTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_entity(self, catalog_id, data_asset_key, entity_key, **kwargs):
          """
          Gets a specific data entity by key for a data asset.
  
  
          :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 bool is_include_object_relationships: (optional)
              Indicates whether the list of objects and their relationships to this object will be provided in the response.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity response.
  
              Allowed values are: "key", "displayName", "description", "dataAssetKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "lifecycleState", "externalKey", "timeExternal", "timeStatusUpdated", "isLogical", "isPartition", "folderKey", "folderName", "typeKey", "path", "harvestStatus", "lastJobKey", "uri", "properties"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Entity`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_entity.py.html>`__ to see an example of how to use get_entity API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}"
          method = "GET"
          operation_name = "get_entity"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Entity/GetEntity"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "is_include_object_relationships",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_entity got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "dataAssetKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "lifecycleState", "externalKey", "timeExternal", "timeStatusUpdated", "isLogical", "isPartition", "folderKey", "folderName", "typeKey", "path", "harvestStatus", "lastJobKey", "uri", "properties"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "isIncludeObjectRelationships": kwargs.get("is_include_object_relationships", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Entity",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Entity",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_entity_tag(self, catalog_id, data_asset_key, entity_key, tag_key, **kwargs):
          """
          Gets a specific entity tag by key.
  
  
          :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 tag_key: (required)
              Unique tag key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity tag response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "entityKey"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.EntityTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_entity_tag.py.html>`__ to see an example of how to use get_entity_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/tags/{tagKey}"
          method = "GET"
          operation_name = "get_entity_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/EntityTag/GetEntityTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_entity_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "entityKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_folder(self, catalog_id, data_asset_key, folder_key, **kwargs):
          """
          Gets a specific data asset folder by key.
  
  
          :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 bool is_include_object_relationships: (optional)
              Indicates whether the list of objects and their relationships to this object will be provided in the response.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a folder response.
  
              Allowed values are: "key", "displayName", "description", "parentFolderKey", "path", "dataAssetKey", "properties", "externalKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "timeExternal", "lifecycleState", "harvestStatus", "lastJobKey", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Folder`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_folder.py.html>`__ to see an example of how to use get_folder API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders/{folderKey}"
          method = "GET"
          operation_name = "get_folder"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Folder/GetFolder"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "is_include_object_relationships",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_folder got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "folderKey": folder_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "parentFolderKey", "path", "dataAssetKey", "properties", "externalKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "timeExternal", "lifecycleState", "harvestStatus", "lastJobKey", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "isIncludeObjectRelationships": kwargs.get("is_include_object_relationships", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Folder",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Folder",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_folder_tag(self, catalog_id, data_asset_key, folder_key, tag_key, **kwargs):
          """
          Gets a specific folder tag by key.
  
  
          :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 str tag_key: (required)
              Unique tag key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a folder tag response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "folderKey"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.FolderTag`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_folder_tag.py.html>`__ to see an example of how to use get_folder_tag API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders/{folderKey}/tags/{tagKey}"
          method = "GET"
          operation_name = "get_folder_tag"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/FolderTag/GetFolderTag"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_folder_tag got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "folderKey": folder_key,
              "tagKey": tag_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "createdById", "uri", "folderKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="FolderTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="FolderTag",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_glossary(self, catalog_id, glossary_key, **kwargs):
          """
          Gets a specific glossary by key within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str glossary_key: (required)
              Unique glossary key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a glossary response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "owner", "workflowStatus", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Glossary`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_glossary.py.html>`__ to see an example of how to use get_glossary API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}"
          method = "GET"
          operation_name = "get_glossary"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/GetGlossary"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_glossary got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "owner", "workflowStatus", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Glossary",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Glossary",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_job(self, catalog_id, job_key, **kwargs):
          """
          Gets a specific job by key within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "lifecycleState", "timeCreated", "timeUpdated", "jobType", "scheduleCronExpression", "timeScheduleBegin", "timeScheduleEnd", "scheduleType", "connectionKey", "jobDefinitionKey", "internalVersion", "executionCount", "timeOfLatestExecution", "executions", "createdById", "updatedById", "uri", "jobDefinitionName", "errorCode", "errorMessage"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Job`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_job.py.html>`__ to see an example of how to use get_job API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}"
          method = "GET"
          operation_name = "get_job"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Job/GetJob"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_job got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "lifecycleState", "timeCreated", "timeUpdated", "jobType", "scheduleCronExpression", "timeScheduleBegin", "timeScheduleEnd", "scheduleType", "connectionKey", "jobDefinitionKey", "internalVersion", "executionCount", "timeOfLatestExecution", "executions", "createdById", "updatedById", "uri", "jobDefinitionName", "errorCode", "errorMessage"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Job",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Job",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_job_definition(self, catalog_id, job_definition_key, **kwargs):
          """
          Gets a specific job definition by key within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_definition_key: (required)
              Unique job definition key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job definition response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "jobType", "isIncremental", "dataAssetKey", "connectionKey", "internalVersion", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "uri", "isSampleDataExtracted", "sampleDataSizeInMBs", "timeLatestExecutionStarted", "timeLatestExecutionEnded", "jobExecutionState", "scheduleType", "properties"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobDefinition`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_job_definition.py.html>`__ to see an example of how to use get_job_definition API.
          """
          resource_path = "/catalogs/{catalogId}/jobDefinitions/{jobDefinitionKey}"
          method = "GET"
          operation_name = "get_job_definition"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobDefinition/GetJobDefinition"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_job_definition got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobDefinitionKey": job_definition_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "jobType", "isIncremental", "dataAssetKey", "connectionKey", "internalVersion", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "uri", "isSampleDataExtracted", "sampleDataSizeInMBs", "timeLatestExecutionStarted", "timeLatestExecutionEnded", "jobExecutionState", "scheduleType", "properties"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobDefinition",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobDefinition",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_job_execution(self, catalog_id, job_key, job_execution_key, **kwargs):
          """
          Gets a specific job execution by key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param str job_execution_key: (required)
              The key of the job execution.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job execution response.
  
              Allowed values are: "key", "jobKey", "jobType", "subType", "parentKey", "scheduleInstanceKey", "lifecycleState", "timeCreated", "timeStarted", "timeEnded", "errorCode", "errorMessage", "processKey", "externalUrl", "eventKey", "dataEntityKey", "createdById", "updatedById", "properties", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobExecution`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_job_execution.py.html>`__ to see an example of how to use get_job_execution API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}/executions/{jobExecutionKey}"
          method = "GET"
          operation_name = "get_job_execution"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobExecution/GetJobExecution"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_job_execution got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key,
              "jobExecutionKey": job_execution_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "jobKey", "jobType", "subType", "parentKey", "scheduleInstanceKey", "lifecycleState", "timeCreated", "timeStarted", "timeEnded", "errorCode", "errorMessage", "processKey", "externalUrl", "eventKey", "dataEntityKey", "createdById", "updatedById", "properties", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobExecution",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobExecution",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_job_log(self, catalog_id, job_key, job_execution_key, job_log_key, **kwargs):
          """
          Gets a specific job log by key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param str job_execution_key: (required)
              The key of the job execution.
  
          :param str job_log_key: (required)
              Unique job log key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job log response.
  
              Allowed values are: "key", "jobExecutionKey", "createdById", "updatedById", "timeUpdated", "timeCreated", "severity", "logMessage", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobLog`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_job_log.py.html>`__ to see an example of how to use get_job_log API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}/executions/{jobExecutionKey}/logs/{jobLogKey}"
          method = "GET"
          operation_name = "get_job_log"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobLog/GetJobLog"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_job_log got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key,
              "jobExecutionKey": job_execution_key,
              "jobLogKey": job_log_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "jobExecutionKey", "createdById", "updatedById", "timeUpdated", "timeCreated", "severity", "logMessage", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobLog",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobLog",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_job_metrics(self, catalog_id, job_key, job_execution_key, job_metrics_key, **kwargs):
          """
          Gets a specific job metric by key.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param str job_execution_key: (required)
              The key of the job execution.
  
          :param str job_metrics_key: (required)
              Unique job metrics key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job metric response.
  
              Allowed values are: "key", "description", "displayName", "timeInserted", "category", "subCategory", "unit", "value", "batchKey", "jobExecutionKey", "createdById", "updatedById", "timeUpdated", "timeCreated", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobMetric`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_job_metrics.py.html>`__ to see an example of how to use get_job_metrics API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}/executions/{jobExecutionKey}/metrics/{jobMetricsKey}"
          method = "GET"
          operation_name = "get_job_metrics"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobMetric/GetJobMetrics"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_job_metrics got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key,
              "jobExecutionKey": job_execution_key,
              "jobMetricsKey": job_metrics_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "description", "displayName", "timeInserted", "category", "subCategory", "unit", "value", "batchKey", "jobExecutionKey", "createdById", "updatedById", "timeUpdated", "timeCreated", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobMetric",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobMetric",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_metastore(self, metastore_id, **kwargs):
          """
          Gets a metastore by identifier.
  
  
          :param str metastore_id: (required)
              The metastore's OCID.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Metastore`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_metastore.py.html>`__ to see an example of how to use get_metastore API.
          """
          resource_path = "/metastores/{metastoreId}"
          method = "GET"
          operation_name = "get_metastore"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Metastore/GetMetastore"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_metastore got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "metastoreId": metastore_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="Metastore",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="Metastore",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_namespace(self, catalog_id, namespace_id, **kwargs):
          """
          Gets a specific namespace for the given key within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str namespace_id: (required)
              Unique namespace identifier.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a namespace response.
  
              Allowed values are: "key", "displayName", "description", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Namespace`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_namespace.py.html>`__ to see an example of how to use get_namespace API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}"
          method = "GET"
          operation_name = "get_namespace"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Namespace/GetNamespace"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_namespace got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Namespace",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Namespace",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_pattern(self, catalog_id, pattern_key, **kwargs):
          """
          Gets a specific pattern for the given key within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str pattern_key: (required)
              Unique pattern key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a pattern response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "expression", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Pattern`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_pattern.py.html>`__ to see an example of how to use get_pattern API.
          """
          resource_path = "/catalogs/{catalogId}/patterns/{patternKey}"
          method = "GET"
          operation_name = "get_pattern"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Pattern/GetPattern"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_pattern got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "patternKey": pattern_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "expression", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "properties"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Pattern",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Pattern",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_term(self, catalog_id, glossary_key, term_key, **kwargs):
          """
          Gets a specific glossary term by key.
  
  
          :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 list[str] fields: (optional)
              Specifies the fields to return in a term response.
  
              Allowed values are: "key", "displayName", "description", "glossaryKey", "parentTermKey", "isAllowedToHaveChildTerms", "path", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "owner", "workflowStatus", "uri", "relatedTerms", "associatedObjectCount", "associatedObjects"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Term`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_term.py.html>`__ to see an example of how to use get_term API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}"
          method = "GET"
          operation_name = "get_term"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Term/GetTerm"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_term got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "glossaryKey", "parentTermKey", "isAllowedToHaveChildTerms", "path", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "owner", "workflowStatus", "uri", "relatedTerms", "associatedObjectCount", "associatedObjects"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Term",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Term",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_term_relationship(self, catalog_id, glossary_key, term_key, term_relationship_key, **kwargs):
          """
          Gets a specific glossary term relationship by key.
  
  
          :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 list[str] fields: (optional)
              Specifies the fields to return in a term relationship response.
  
              Allowed values are: "key", "displayName", "description", "relatedTermKey", "relatedTermDisplayName", "parentTermKey", "parentTermDisplayName", "lifecycleState", "timeCreated", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.TermRelationship`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_term_relationship.py.html>`__ to see an example of how to use get_term_relationship API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}/termRelationships/{termRelationshipKey}"
          method = "GET"
          operation_name = "get_term_relationship"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/TermRelationship/GetTermRelationship"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_term_relationship got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key,
              "termRelationshipKey": term_relationship_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "relatedTermKey", "relatedTermDisplayName", "parentTermKey", "parentTermDisplayName", "lifecycleState", "timeCreated", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermRelationship",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermRelationship",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_type(self, catalog_id, type_key, **kwargs):
          """
          Gets a specific type by key within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str type_key: (required)
              Unique type key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a type response.
  
              Allowed values are: "key", "description", "name", "catalogId", "properties", "isInternal", "isTag", "isApproved", "typeCategory", "externalTypeName", "lifecycleState", "uri"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Type`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_type.py.html>`__ to see an example of how to use get_type API.
          """
          resource_path = "/catalogs/{catalogId}/types/{typeKey}"
          method = "GET"
          operation_name = "get_type"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Type/GetType"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_type got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "typeKey": type_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "description", "name", "catalogId", "properties", "isInternal", "isTag", "isApproved", "typeCategory", "externalTypeName", "lifecycleState", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Type",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="Type",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def get_work_request(self, work_request_id, **kwargs):
          """
          Gets the status of the work request with the given OCID.
  
  
          :param str work_request_id: (required)
              The OCID of the asynchronous request.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.WorkRequest`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/get_work_request.py.html>`__ to see an example of how to use get_work_request API.
          """
          resource_path = "/workRequests/{workRequestId}"
          method = "GET"
          operation_name = "get_work_request"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/WorkRequest/GetWorkRequest"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_work_request got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "workRequestId": work_request_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="WorkRequest",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="WorkRequest",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def import_connection(self, catalog_id, data_asset_key, import_connection_details, **kwargs):
          """
          Import new connection for this data asset.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param oci.data_catalog.models.ImportConnectionDetails import_connection_details: (required)
              The information used to create the connections through import.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Connection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/import_connection.py.html>`__ to see an example of how to use import_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/actions/importConnection"
          method = "POST"
          operation_name = "import_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/ImportConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "if_match",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "import_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "if-match": kwargs.get("if_match", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=import_connection_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=import_connection_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def import_data_asset(self, catalog_id, data_asset_key, import_data_asset_details, import_type, **kwargs):
          """
          Import technical objects to a Data Asset
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param oci.data_catalog.models.ImportDataAssetDetails import_data_asset_details: (required)
              The file contents to be imported.
  
          :param oci.data_catalog.models.list[str] import_type: (required)
              Type of import.
  
              Allowed values are: "CUSTOM_PROPERTY_VALUES", "ALL"
  
          :param bool is_missing_value_ignored: (optional)
              Specify whether to ignore the missing values in the import file.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.ImportDataAssetJobResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/import_data_asset.py.html>`__ to see an example of how to use import_data_asset API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/actions/import"
          method = "POST"
          operation_name = "import_data_asset"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/ImportDataAsset"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "is_missing_value_ignored",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "import_data_asset got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          import_type_allowed_values = ["CUSTOM_PROPERTY_VALUES", "ALL"]
          for import_type_item in import_type:
              if import_type_item not in import_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `import_type`, must be one of {0}".format(import_type_allowed_values)
                  )
  
          query_params = {
              "importType": self.base_client.generate_collection_format_param(import_type, 'multi'),
              "isMissingValueIgnored": kwargs.get("is_missing_value_ignored", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=import_data_asset_details,
                  response_type="ImportDataAssetJobResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=import_data_asset_details,
                  response_type="ImportDataAssetJobResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def import_glossary(self, catalog_id, glossary_key, import_glossary_details, **kwargs):
          """
          Import the glossary and the terms from csv or json files and return the imported glossary resource.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str glossary_key: (required)
              Unique glossary key.
  
          :param oci.data_catalog.models.ImportGlossaryDetails import_glossary_details: (required)
              The file contents to import the glossary.
  
          :param bool is_relationship_imported: (optional)
              Specify if the relationship metadata is imported for the glossary.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/import_glossary.py.html>`__ to see an example of how to use import_glossary API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/actions/import"
          method = "POST"
          operation_name = "import_glossary"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/ImportGlossary"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "is_relationship_imported",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "import_glossary got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          query_params = {
              "isRelationshipImported": kwargs.get("is_relationship_imported", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=import_glossary_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=import_glossary_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_aggregated_physical_entities(self, catalog_id, data_asset_key, entity_key, **kwargs):
          """
          List the physical entities aggregated by this logical entity.
  
  
          :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 list[str] fields: (optional)
              Specifies the fields to return in an entity response.
  
              Allowed values are: "key", "displayName", "description", "dataAssetKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "lifecycleState", "externalKey", "timeExternal", "timeStatusUpdated", "isLogical", "isPartition", "folderKey", "folderName", "typeKey", "path", "harvestStatus", "lastJobKey", "uri", "properties"
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param bool is_include_properties: (optional)
              Indicates whether the properties map will be provided in the response.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.EntityCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_aggregated_physical_entities.py.html>`__ to see an example of how to use list_aggregated_physical_entities API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/actions/listAggregatedPhysicalEntities"
          method = "POST"
          operation_name = "list_aggregated_physical_entities"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Entity/ListAggregatedPhysicalEntities"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "fields",
              "display_name_contains",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "is_include_properties",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_aggregated_physical_entities got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "dataAssetKey", "timeCreated", "timeUpdated", "createdById", "updatedById", "lifecycleState", "externalKey", "timeExternal", "timeStatusUpdated", "isLogical", "isPartition", "folderKey", "folderName", "typeKey", "path", "harvestStatus", "lastJobKey", "uri", "properties"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "isIncludeProperties": kwargs.get("is_include_properties", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_attribute_tags(self, catalog_id, data_asset_key, entity_key, attribute_key, **kwargs):
          """
          Returns a list of all tags for an entity attribute.
  
  
          :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 str name: (optional)
              Immutable resource name.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str term_key: (optional)
              Unique key of the related term.
  
          :param str term_path: (optional)
              Path of the related term.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity attribute tag summary response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "attributeKey"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.AttributeTagCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_attribute_tags.py.html>`__ to see an example of how to use list_attribute_tags API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes/{attributeKey}/tags"
          method = "GET"
          operation_name = "list_attribute_tags"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/AttributeTagCollection/ListAttributeTags"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "name",
              "lifecycle_state",
              "term_key",
              "term_path",
              "time_created",
              "created_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_attribute_tags got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "attributeKey": attribute_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "attributeKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "name": kwargs.get("name", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "termKey": kwargs.get("term_key", missing),
              "termPath": kwargs.get("term_path", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="AttributeTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="AttributeTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_attributes(self, catalog_id, data_asset_key, entity_key, **kwargs):
          """
          Returns a list of all attributes of an data entity.
  
  
          :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 display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str business_name: (optional)
              A filter to return only resources that match the entire business name given. The match is not case sensitive.
  
          :param str display_or_business_name_contains: (optional)
              A filter to return only resources that match display name or business name pattern given. The match is not case sensitive.
              For Example : /folders?displayOrBusinessNameContains=Cu.*
              The above would match all folders with display name or business name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str external_key: (optional)
              Unique external identifier of this resource in the external source system.
  
          :param datetime time_external: (optional)
              Last modified timestamp of this object in the external system.
  
          :param str external_type_name: (optional)
              Data type as defined in an external system.
  
          :param bool is_incremental_data: (optional)
              Identifies whether this attribute can be used as a watermark to extract incremental data.
  
          :param bool is_nullable: (optional)
              Identifies whether this attribute can be assigned null value.
  
          :param int length: (optional)
              Max allowed length of the attribute value.
  
          :param int position: (optional)
              Position of the attribute in the record definition.
  
          :param int precision: (optional)
              Precision of the attribute value usually applies to float data type.
  
          :param int scale: (optional)
              Scale of the attribute value usually applies to float data type.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity attribute summary response.
  
              Allowed values are: "key", "displayName", "description", "entityKey", "lifecycleState", "timeCreated", "externalDataType", "externalKey", "length", "precision", "scale", "isNullable", "uri", "path", "minCollectionCount", "maxCollectionCount", "datatypeEntityKey", "externalDatatypeEntityKey", "parentAttributeKey", "externalParentAttributeKey", "position", "typeKey"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. Default order for POSITION is ascending. If no value is specified POSITION is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME", "POSITION"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.AttributeCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_attributes.py.html>`__ to see an example of how to use list_attributes API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes"
          method = "GET"
          operation_name = "list_attributes"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/AttributeCollection/ListAttributes"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "business_name",
              "display_or_business_name_contains",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "external_key",
              "time_external",
              "external_type_name",
              "is_incremental_data",
              "is_nullable",
              "length",
              "position",
              "precision",
              "scale",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_attributes got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "entityKey", "lifecycleState", "timeCreated", "externalDataType", "externalKey", "length", "precision", "scale", "isNullable", "uri", "path", "minCollectionCount", "maxCollectionCount", "datatypeEntityKey", "externalDatatypeEntityKey", "parentAttributeKey", "externalParentAttributeKey", "position", "typeKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME", "POSITION"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "businessName": kwargs.get("business_name", missing),
              "displayOrBusinessNameContains": kwargs.get("display_or_business_name_contains", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "externalKey": kwargs.get("external_key", missing),
              "timeExternal": kwargs.get("time_external", missing),
              "externalTypeName": kwargs.get("external_type_name", missing),
              "isIncrementalData": kwargs.get("is_incremental_data", missing),
              "isNullable": kwargs.get("is_nullable", missing),
              "length": kwargs.get("length", missing),
              "position": kwargs.get("position", missing),
              "precision": kwargs.get("precision", missing),
              "scale": kwargs.get("scale", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="AttributeCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="AttributeCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_catalog_private_endpoints(self, compartment_id, **kwargs):
          """
          Returns a list of all the catalog private endpoints in the specified compartment.
  
  
          :param str compartment_id: (required)
              The OCID of the compartment where you want to list resources.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.CatalogPrivateEndpointSummary`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_catalog_private_endpoints.py.html>`__ to see an example of how to use list_catalog_private_endpoints API.
          """
          resource_path = "/catalogPrivateEndpoints"
          method = "GET"
          operation_name = "list_catalog_private_endpoints"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CatalogPrivateEndpointSummary/ListCatalogPrivateEndpoints"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "limit",
              "page",
              "lifecycle_state",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_catalog_private_endpoints got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "displayName": kwargs.get("display_name", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[CatalogPrivateEndpointSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[CatalogPrivateEndpointSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_catalogs(self, compartment_id, **kwargs):
          """
          Returns a list of all the data catalogs in the specified compartment.
  
  
          :param str compartment_id: (required)
              The OCID of the compartment where you want to list resources.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.CatalogSummary`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_catalogs.py.html>`__ to see an example of how to use list_catalogs API.
          """
          resource_path = "/catalogs"
          method = "GET"
          operation_name = "list_catalogs"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CatalogSummary/ListCatalogs"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "limit",
              "page",
              "lifecycle_state",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_catalogs got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "displayName": kwargs.get("display_name", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[CatalogSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[CatalogSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_connections(self, catalog_id, data_asset_key, **kwargs):
          """
          Returns a list of all Connections for a data asset.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str external_key: (optional)
              Unique external identifier of this resource in the external source system.
  
          :param datetime time_status_updated: (optional)
              Time that the resource's status was last updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param bool is_default: (optional)
              Indicates whether this connection is the default connection.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a connection summary response.
  
              Allowed values are: "key", "displayName", "description", "dataAssetKey", "typeKey", "timeCreated", "externalKey", "lifecycleState", "isDefault", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.ConnectionCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_connections.py.html>`__ to see an example of how to use list_connections API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections"
          method = "GET"
          operation_name = "list_connections"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/ConnectionCollection/ListConnections"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "external_key",
              "time_status_updated",
              "is_default",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_connections got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "dataAssetKey", "typeKey", "timeCreated", "externalKey", "lifecycleState", "isDefault", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "externalKey": kwargs.get("external_key", missing),
              "timeStatusUpdated": kwargs.get("time_status_updated", missing),
              "isDefault": kwargs.get("is_default", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ConnectionCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ConnectionCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_custom_properties(self, catalog_id, namespace_id, **kwargs):
          """
          Returns a list of custom properties within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str namespace_id: (required)
              Unique namespace identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param list[str] data_types: (optional)
              Return the custom properties which has specified data types
  
              Allowed values are: "TEXT", "RICH_TEXT", "BOOLEAN", "NUMBER", "DATE"
  
          :param list[str] type_name: (optional)
              A filter to return only resources that match the entire type name given. The match is not case sensitive
  
              Allowed values are: "DATA_ASSET", "AUTONOMOUS_DATA_WAREHOUSE", "HIVE", "KAFKA", "MYSQL", "ORACLE_OBJECT_STORAGE", "AUTONOMOUS_TRANSACTION_PROCESSING", "ORACLE", "POSTGRESQL", "MICROSOFT_AZURE_SQL_DATABASE", "MICROSOFT_SQL_SERVER", "IBM_DB2", "DATA_ENTITY", "LOGICAL_ENTITY", "TABLE", "VIEW", "ATTRIBUTE", "FOLDER", "ORACLE_ANALYTICS_SUBJECT_AREA_COLUMN", "ORACLE_ANALYTICS_LOGICAL_COLUMN", "ORACLE_ANALYTICS_PHYSICAL_COLUMN", "ORACLE_ANALYTICS_ANALYSIS_COLUMN", "ORACLE_ANALYTICS_SERVER", "ORACLE_ANALYTICS_CLOUD", "ORACLE_ANALYTICS_SUBJECT_AREA", "ORACLE_ANALYTICS_DASHBOARD", "ORACLE_ANALYTICS_BUSINESS_MODEL", "ORACLE_ANALYTICS_PHYSICAL_DATABASE", "ORACLE_ANALYTICS_PHYSICAL_SCHEMA", "ORACLE_ANALYTICS_PRESENTATION_TABLE", "ORACLE_ANALYTICS_LOGICAL_TABLE", "ORACLE_ANALYTICS_PHYSICAL_TABLE", "ORACLE_ANALYTICS_ANALYSIS", "DATABASE_SCHEMA", "TOPIC", "CONNECTION", "GLOSSARY", "TERM", "CATEGORY", "FILE", "BUCKET", "MESSAGE", "UNRECOGNIZED_FILE"
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a custom property summary response.
  
              Allowed values are: "key", "displayName", "description", "dataType", "namespaceName", "lifecycleState", "timeCreated"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for USAGECOUNT and DISPLAYNAME is Ascending
  
              Allowed values are: "DISPLAYNAME", "USAGECOUNT"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.CustomPropertyCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_custom_properties.py.html>`__ to see an example of how to use list_custom_properties API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}/customProperties"
          method = "GET"
          operation_name = "list_custom_properties"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CustomProperty/ListCustomProperties"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "data_types",
              "type_name",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "fields",
              "sort_order",
              "sort_by",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_custom_properties got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'data_types' in kwargs:
              data_types_allowed_values = ["TEXT", "RICH_TEXT", "BOOLEAN", "NUMBER", "DATE"]
              for data_types_item in kwargs['data_types']:
                  if data_types_item not in data_types_allowed_values:
                      raise ValueError(
                          "Invalid value for `data_types`, must be one of {0}".format(data_types_allowed_values)
                      )
  
          if 'type_name' in kwargs:
              type_name_allowed_values = ["DATA_ASSET", "AUTONOMOUS_DATA_WAREHOUSE", "HIVE", "KAFKA", "MYSQL", "ORACLE_OBJECT_STORAGE", "AUTONOMOUS_TRANSACTION_PROCESSING", "ORACLE", "POSTGRESQL", "MICROSOFT_AZURE_SQL_DATABASE", "MICROSOFT_SQL_SERVER", "IBM_DB2", "DATA_ENTITY", "LOGICAL_ENTITY", "TABLE", "VIEW", "ATTRIBUTE", "FOLDER", "ORACLE_ANALYTICS_SUBJECT_AREA_COLUMN", "ORACLE_ANALYTICS_LOGICAL_COLUMN", "ORACLE_ANALYTICS_PHYSICAL_COLUMN", "ORACLE_ANALYTICS_ANALYSIS_COLUMN", "ORACLE_ANALYTICS_SERVER", "ORACLE_ANALYTICS_CLOUD", "ORACLE_ANALYTICS_SUBJECT_AREA", "ORACLE_ANALYTICS_DASHBOARD", "ORACLE_ANALYTICS_BUSINESS_MODEL", "ORACLE_ANALYTICS_PHYSICAL_DATABASE", "ORACLE_ANALYTICS_PHYSICAL_SCHEMA", "ORACLE_ANALYTICS_PRESENTATION_TABLE", "ORACLE_ANALYTICS_LOGICAL_TABLE", "ORACLE_ANALYTICS_PHYSICAL_TABLE", "ORACLE_ANALYTICS_ANALYSIS", "DATABASE_SCHEMA", "TOPIC", "CONNECTION", "GLOSSARY", "TERM", "CATEGORY", "FILE", "BUCKET", "MESSAGE", "UNRECOGNIZED_FILE"]
              for type_name_item in kwargs['type_name']:
                  if type_name_item not in type_name_allowed_values:
                      raise ValueError(
                          "Invalid value for `type_name`, must be one of {0}".format(type_name_allowed_values)
                      )
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "dataType", "namespaceName", "lifecycleState", "timeCreated"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["DISPLAYNAME", "USAGECOUNT"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "dataTypes": self.base_client.generate_collection_format_param(kwargs.get("data_types", missing), 'multi'),
              "typeName": self.base_client.generate_collection_format_param(kwargs.get("type_name", missing), 'multi'),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="CustomPropertyCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="CustomPropertyCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_data_asset_tags(self, catalog_id, data_asset_key, **kwargs):
          """
          Returns a list of all tags for a data asset.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param str name: (optional)
              Immutable resource name.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str term_key: (optional)
              Unique key of the related term.
  
          :param str term_path: (optional)
              Path of the related term.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a data asset tag summary response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "dataAssetKey"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAssetTagCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_data_asset_tags.py.html>`__ to see an example of how to use list_data_asset_tags API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/tags"
          method = "GET"
          operation_name = "list_data_asset_tags"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAssetTagCollection/ListDataAssetTags"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "name",
              "lifecycle_state",
              "term_key",
              "term_path",
              "time_created",
              "created_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_data_asset_tags got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "dataAssetKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "name": kwargs.get("name", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "termKey": kwargs.get("term_key", missing),
              "termPath": kwargs.get("term_path", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAssetTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAssetTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_data_assets(self, catalog_id, **kwargs):
          """
          Returns a list of data assets within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str external_key: (optional)
              Unique external identifier of this resource in the external source system.
  
          :param str type_key: (optional)
              The key of the object type.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a data asset summary response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "externalKey", "typeKey", "lifecycleState", "timeCreated", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAssetCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_data_assets.py.html>`__ to see an example of how to use list_data_assets API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets"
          method = "GET"
          operation_name = "list_data_assets"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAssetCollection/ListDataAssets"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "external_key",
              "type_key",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_data_assets got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "externalKey", "typeKey", "lifecycleState", "timeCreated", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "externalKey": kwargs.get("external_key", missing),
              "typeKey": kwargs.get("type_key", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAssetCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="DataAssetCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_derived_logical_entities(self, catalog_id, pattern_key, **kwargs):
          """
          List logical entities derived from this pattern.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str pattern_key: (required)
              Unique pattern key.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.EntityCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_derived_logical_entities.py.html>`__ to see an example of how to use list_derived_logical_entities API.
          """
          resource_path = "/catalogs/{catalogId}/patterns/{patternKey}/actions/listDerivedLogicalEntities"
          method = "POST"
          operation_name = "list_derived_logical_entities"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Pattern/ListDerivedLogicalEntities"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name_contains",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id",
              "if_match",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_derived_logical_entities got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "patternKey": pattern_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "if-match": kwargs.get("if_match", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_entities(self, catalog_id, data_asset_key, **kwargs):
          """
          Returns a list of all entities of a data asset.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str business_name: (optional)
              A filter to return only resources that match the entire business name given. The match is not case sensitive.
  
          :param str display_or_business_name_contains: (optional)
              A filter to return only resources that match display name or business name pattern given. The match is not case sensitive.
              For Example : /folders?displayOrBusinessNameContains=Cu.*
              The above would match all folders with display name or business name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str type_key: (optional)
              The key of the object type.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str external_key: (optional)
              Unique external identifier of this resource in the external source system.
  
          :param str pattern_key: (optional)
              Unique pattern key.
  
          :param datetime time_external: (optional)
              Last modified timestamp of this object in the external system.
  
          :param datetime time_status_updated: (optional)
              Time that the resource's status was last updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param bool is_logical: (optional)
              Identifies if the object is a physical object (materialized) or virtual/logical object defined on other objects.
  
          :param bool is_partition: (optional)
              Identifies if an object is a sub object (partition) of a physical or materialized parent object.
  
          :param str folder_key: (optional)
              Key of the associated folder.
  
          :param str path: (optional)
              Full path of the resource for resources that support paths.
  
          :param str harvest_status: (optional)
              Harvest status of the harvestable resource as updated by the harvest process.
  
              Allowed values are: "COMPLETE", "ERROR", "IN_PROGRESS", "DEFERRED"
  
          :param str last_job_key: (optional)
              Key of the last harvest process to update this resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity summary response.
  
              Allowed values are: "key", "displayName", "description", "dataAssetKey", "timeCreated", "timeUpdated", "updatedById", "lifecycleState", "folderKey", "folderName", "externalKey", "path", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.EntityCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_entities.py.html>`__ to see an example of how to use list_entities API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities"
          method = "GET"
          operation_name = "list_entities"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Entity/ListEntities"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "business_name",
              "display_or_business_name_contains",
              "type_key",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "external_key",
              "pattern_key",
              "time_external",
              "time_status_updated",
              "is_logical",
              "is_partition",
              "folder_key",
              "path",
              "harvest_status",
              "last_job_key",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_entities got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'harvest_status' in kwargs:
              harvest_status_allowed_values = ["COMPLETE", "ERROR", "IN_PROGRESS", "DEFERRED"]
              if kwargs['harvest_status'] not in harvest_status_allowed_values:
                  raise ValueError(
                      "Invalid value for `harvest_status`, must be one of {0}".format(harvest_status_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "dataAssetKey", "timeCreated", "timeUpdated", "updatedById", "lifecycleState", "folderKey", "folderName", "externalKey", "path", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "businessName": kwargs.get("business_name", missing),
              "displayOrBusinessNameContains": kwargs.get("display_or_business_name_contains", missing),
              "typeKey": kwargs.get("type_key", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "externalKey": kwargs.get("external_key", missing),
              "patternKey": kwargs.get("pattern_key", missing),
              "timeExternal": kwargs.get("time_external", missing),
              "timeStatusUpdated": kwargs.get("time_status_updated", missing),
              "isLogical": kwargs.get("is_logical", missing),
              "isPartition": kwargs.get("is_partition", missing),
              "folderKey": kwargs.get("folder_key", missing),
              "path": kwargs.get("path", missing),
              "harvestStatus": kwargs.get("harvest_status", missing),
              "lastJobKey": kwargs.get("last_job_key", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_entity_tags(self, catalog_id, data_asset_key, entity_key, **kwargs):
          """
          Returns a list of all tags for a data entity.
  
  
          :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 name: (optional)
              Immutable resource name.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str term_key: (optional)
              Unique key of the related term.
  
          :param str term_path: (optional)
              Path of the related term.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in an entity tag summary response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "entityKey"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.EntityTagCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_entity_tags.py.html>`__ to see an example of how to use list_entity_tags API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/tags"
          method = "GET"
          operation_name = "list_entity_tags"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/EntityTagCollection/ListEntityTags"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "name",
              "lifecycle_state",
              "term_key",
              "term_path",
              "time_created",
              "created_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_entity_tags got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "entityKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "name": kwargs.get("name", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "termKey": kwargs.get("term_key", missing),
              "termPath": kwargs.get("term_path", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="EntityTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_folder_tags(self, catalog_id, data_asset_key, folder_key, **kwargs):
          """
          Returns a list of all tags for a folder.
  
  
          :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 str name: (optional)
              Immutable resource name.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str term_key: (optional)
              Unique key of the related term.
  
          :param str term_path: (optional)
              Path of the related term.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a folder tag summary response.
  
              Allowed values are: "key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "folderKey"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.FolderTagCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_folder_tags.py.html>`__ to see an example of how to use list_folder_tags API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders/{folderKey}/tags"
          method = "GET"
          operation_name = "list_folder_tags"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/FolderTagCollection/ListFolderTags"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "name",
              "lifecycle_state",
              "term_key",
              "term_path",
              "time_created",
              "created_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_folder_tags got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "folderKey": folder_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "name", "termKey", "termPath", "termDescription", "lifecycleState", "timeCreated", "uri", "glossaryKey", "folderKey"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "name": kwargs.get("name", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "termKey": kwargs.get("term_key", missing),
              "termPath": kwargs.get("term_path", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="FolderTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="FolderTagCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_folders(self, catalog_id, data_asset_key, **kwargs):
          """
          Returns a list of all folders.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str business_name: (optional)
              A filter to return only resources that match the entire business name given. The match is not case sensitive.
  
          :param str display_or_business_name_contains: (optional)
              A filter to return only resources that match display name or business name pattern given. The match is not case sensitive.
              For Example : /folders?displayOrBusinessNameContains=Cu.*
              The above would match all folders with display name or business name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str parent_folder_key: (optional)
              Unique folder key.
  
          :param str path: (optional)
              Full path of the resource for resources that support paths.
  
          :param str external_key: (optional)
              Unique external identifier of this resource in the external source system.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str harvest_status: (optional)
              Harvest status of the harvestable resource as updated by the harvest process.
  
              Allowed values are: "COMPLETE", "ERROR", "IN_PROGRESS", "DEFERRED"
  
          :param str last_job_key: (optional)
              Key of the last harvest process to update this resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a folder summary response.
  
              Allowed values are: "key", "displayName", "description", "parentFolderKey", "path", "dataAssetKey", "externalKey", "timeExternal", "timeCreated", "lifecycleState", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.FolderCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_folders.py.html>`__ to see an example of how to use list_folders API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders"
          method = "GET"
          operation_name = "list_folders"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/FolderCollection/ListFolders"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "business_name",
              "display_or_business_name_contains",
              "display_name_contains",
              "lifecycle_state",
              "parent_folder_key",
              "path",
              "external_key",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "harvest_status",
              "last_job_key",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_folders got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'harvest_status' in kwargs:
              harvest_status_allowed_values = ["COMPLETE", "ERROR", "IN_PROGRESS", "DEFERRED"]
              if kwargs['harvest_status'] not in harvest_status_allowed_values:
                  raise ValueError(
                      "Invalid value for `harvest_status`, must be one of {0}".format(harvest_status_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "parentFolderKey", "path", "dataAssetKey", "externalKey", "timeExternal", "timeCreated", "lifecycleState", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "businessName": kwargs.get("business_name", missing),
              "displayOrBusinessNameContains": kwargs.get("display_or_business_name_contains", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "parentFolderKey": kwargs.get("parent_folder_key", missing),
              "path": kwargs.get("path", missing),
              "externalKey": kwargs.get("external_key", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "harvestStatus": kwargs.get("harvest_status", missing),
              "lastJobKey": kwargs.get("last_job_key", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="FolderCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="FolderCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_glossaries(self, catalog_id, **kwargs):
          """
          Returns a list of all glossaries within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a glossary summary response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "lifecycleState", "timeCreated", "uri", "workflowStatus"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.GlossaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_glossaries.py.html>`__ to see an example of how to use list_glossaries API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries"
          method = "GET"
          operation_name = "list_glossaries"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/ListGlossaries"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_glossaries got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "lifecycleState", "timeCreated", "uri", "workflowStatus"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="GlossaryCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="GlossaryCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_job_definitions(self, catalog_id, **kwargs):
          """
          Returns a list of job definitions within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str job_execution_state: (optional)
              Job execution state.
  
              Allowed values are: "CREATED", "IN_PROGRESS", "INACTIVE", "FAILED", "SUCCEEDED", "CANCELED", "SUCCEEDED_WITH_WARNINGS"
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str job_type: (optional)
              Job type.
  
              Allowed values are: "HARVEST", "PROFILING", "SAMPLING", "PREVIEW", "IMPORT", "EXPORT", "IMPORT_GLOSSARY", "EXPORT_GLOSSARY", "INTERNAL", "PURGE", "IMMEDIATE", "SCHEDULED", "IMMEDIATE_EXECUTION", "SCHEDULED_EXECUTION", "SCHEDULED_EXECUTION_INSTANCE", "ASYNC_DELETE", "IMPORT_DATA_ASSET"
  
          :param bool is_incremental: (optional)
              Whether job definition is an incremental harvest (true) or a full harvest (false).
  
          :param str data_asset_key: (optional)
              Unique data asset key.
  
          :param str connection_key: (optional)
              Unique connection key.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str sample_data_size_in_mbs: (optional)
              The sample data size in MB, specified as number of rows, for a metadata harvest.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job definition summary response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "jobType", "connectionKey", "lifecycleState", "timeCreated", "isSampleDataExtracted", "uri", "timeLatestExecutionStarted", "timeLatestExecutionEnded", "jobExecutionState", "scheduleType"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. Default order for TIMELATESTEXECUTIONSTARTED is descending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME", "TIMELATESTEXECUTIONSTARTED"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobDefinitionCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_job_definitions.py.html>`__ to see an example of how to use list_job_definitions API.
          """
          resource_path = "/catalogs/{catalogId}/jobDefinitions"
          method = "GET"
          operation_name = "list_job_definitions"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobDefinitionCollection/ListJobDefinitions"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "job_execution_state",
              "lifecycle_state",
              "job_type",
              "is_incremental",
              "data_asset_key",
              "connection_key",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "sample_data_size_in_mbs",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_job_definitions got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'job_execution_state' in kwargs:
              job_execution_state_allowed_values = ["CREATED", "IN_PROGRESS", "INACTIVE", "FAILED", "SUCCEEDED", "CANCELED", "SUCCEEDED_WITH_WARNINGS"]
              if kwargs['job_execution_state'] not in job_execution_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `job_execution_state`, must be one of {0}".format(job_execution_state_allowed_values)
                  )
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'job_type' in kwargs:
              job_type_allowed_values = ["HARVEST", "PROFILING", "SAMPLING", "PREVIEW", "IMPORT", "EXPORT", "IMPORT_GLOSSARY", "EXPORT_GLOSSARY", "INTERNAL", "PURGE", "IMMEDIATE", "SCHEDULED", "IMMEDIATE_EXECUTION", "SCHEDULED_EXECUTION", "SCHEDULED_EXECUTION_INSTANCE", "ASYNC_DELETE", "IMPORT_DATA_ASSET"]
              if kwargs['job_type'] not in job_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `job_type`, must be one of {0}".format(job_type_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "jobType", "connectionKey", "lifecycleState", "timeCreated", "isSampleDataExtracted", "uri", "timeLatestExecutionStarted", "timeLatestExecutionEnded", "jobExecutionState", "scheduleType"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME", "TIMELATESTEXECUTIONSTARTED"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "jobExecutionState": kwargs.get("job_execution_state", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "jobType": kwargs.get("job_type", missing),
              "isIncremental": kwargs.get("is_incremental", missing),
              "dataAssetKey": kwargs.get("data_asset_key", missing),
              "connectionKey": kwargs.get("connection_key", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "sampleDataSizeInMBs": kwargs.get("sample_data_size_in_mbs", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobDefinitionCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobDefinitionCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_job_executions(self, catalog_id, job_key, **kwargs):
          """
          Returns a list of job executions for a job.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param str lifecycle_state: (optional)
              Job execution lifecycle state.
  
              Allowed values are: "CREATED", "IN_PROGRESS", "INACTIVE", "FAILED", "SUCCEEDED", "CANCELED", "SUCCEEDED_WITH_WARNINGS"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str job_type: (optional)
              Job type.
  
              Allowed values are: "HARVEST", "PROFILING", "SAMPLING", "PREVIEW", "IMPORT", "EXPORT", "IMPORT_GLOSSARY", "EXPORT_GLOSSARY", "INTERNAL", "PURGE", "IMMEDIATE", "SCHEDULED", "IMMEDIATE_EXECUTION", "SCHEDULED_EXECUTION", "SCHEDULED_EXECUTION_INSTANCE", "ASYNC_DELETE", "IMPORT_DATA_ASSET"
  
          :param str sub_type: (optional)
              Sub-type of this job execution.
  
          :param str parent_key: (optional)
              The unique key of the parent execution or null if this job execution has no parent.
  
          :param datetime time_start: (optional)
              Time that the job execution was started or in the case of a future time, the time when the job will start.
              An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_end: (optional)
              Time that the job execution ended or null if the job is still running or hasn't run yet.
              An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str error_code: (optional)
              Error code returned from the job execution or null if job is still running or didn't return an error.
  
          :param str error_message: (optional)
              Error message returned from the job execution or null if job is still running or didn't return an error.
  
          :param str process_key: (optional)
              Process identifier related to the job execution.
  
          :param str external_url: (optional)
              The a URL of the job for accessing this resource and its status.
  
          :param str event_key: (optional)
              Event that triggered the execution of this job or null.
  
          :param str data_entity_key: (optional)
              Unique entity key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job execution summary response.
  
              Allowed values are: "key", "jobKey", "jobType", "parentKey", "scheduleInstanceKey", "lifecycleState", "timeCreated", "timeStarted", "timeEnded", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided; the default is descending. Use sortOrder query param to specify order.
  
              Allowed values are: "TIMECREATED"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobExecutionCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_job_executions.py.html>`__ to see an example of how to use list_job_executions API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}/executions"
          method = "GET"
          operation_name = "list_job_executions"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobExecutionCollection/ListJobExecutions"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "job_type",
              "sub_type",
              "parent_key",
              "time_start",
              "time_end",
              "error_code",
              "error_message",
              "process_key",
              "external_url",
              "event_key",
              "data_entity_key",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_job_executions got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATED", "IN_PROGRESS", "INACTIVE", "FAILED", "SUCCEEDED", "CANCELED", "SUCCEEDED_WITH_WARNINGS"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'job_type' in kwargs:
              job_type_allowed_values = ["HARVEST", "PROFILING", "SAMPLING", "PREVIEW", "IMPORT", "EXPORT", "IMPORT_GLOSSARY", "EXPORT_GLOSSARY", "INTERNAL", "PURGE", "IMMEDIATE", "SCHEDULED", "IMMEDIATE_EXECUTION", "SCHEDULED_EXECUTION", "SCHEDULED_EXECUTION_INSTANCE", "ASYNC_DELETE", "IMPORT_DATA_ASSET"]
              if kwargs['job_type'] not in job_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `job_type`, must be one of {0}".format(job_type_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "jobKey", "jobType", "parentKey", "scheduleInstanceKey", "lifecycleState", "timeCreated", "timeStarted", "timeEnded", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "jobType": kwargs.get("job_type", missing),
              "subType": kwargs.get("sub_type", missing),
              "parentKey": kwargs.get("parent_key", missing),
              "timeStart": kwargs.get("time_start", missing),
              "timeEnd": kwargs.get("time_end", missing),
              "errorCode": kwargs.get("error_code", missing),
              "errorMessage": kwargs.get("error_message", missing),
              "processKey": kwargs.get("process_key", missing),
              "externalUrl": kwargs.get("external_url", missing),
              "eventKey": kwargs.get("event_key", missing),
              "dataEntityKey": kwargs.get("data_entity_key", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobExecutionCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobExecutionCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_job_logs(self, catalog_id, job_key, job_execution_key, **kwargs):
          """
          Returns a list of job logs.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param str job_execution_key: (required)
              The key of the job execution.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str severity: (optional)
              Severity level for this Log.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job log summary response.
  
              Allowed values are: "key", "jobExecutionKey", "severity", "timeCreated", "logMessage", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobLogCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_job_logs.py.html>`__ to see an example of how to use list_job_logs API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}/executions/{jobExecutionKey}/logs"
          method = "GET"
          operation_name = "list_job_logs"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobLogCollection/ListJobLogs"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "lifecycle_state",
              "severity",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_job_logs got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key,
              "jobExecutionKey": job_execution_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "jobExecutionKey", "severity", "timeCreated", "logMessage", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "severity": kwargs.get("severity", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobLogCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobLogCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_job_metrics(self, catalog_id, job_key, job_execution_key, **kwargs):
          """
          Returns a list of job metrics.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str job_key: (required)
              Unique job key.
  
          :param str job_execution_key: (required)
              The key of the job execution.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str category: (optional)
              Category of this metric.
  
          :param str sub_category: (optional)
              Sub category of this metric under the category. Used for aggregating values. May be null.
  
          :param str unit: (optional)
              Unit of this metric.
  
          :param str value: (optional)
              Value of this metric.
  
          :param str batch_key: (optional)
              Batch key for grouping, may be null.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_inserted: (optional)
              The time the metric was logged or captured in the system where the job executed.
              An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job metric summary response.
  
              Allowed values are: "key", "description", "displayName", "timeInserted", "category", "subCategory", "unit", "value", "batchKey", "jobExecutionKey", "timeCreated", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobMetricCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_job_metrics.py.html>`__ to see an example of how to use list_job_metrics API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}/executions/{jobExecutionKey}/metrics"
          method = "GET"
          operation_name = "list_job_metrics"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobMetricCollection/ListJobMetrics"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "category",
              "sub_category",
              "unit",
              "value",
              "batch_key",
              "time_created",
              "time_updated",
              "time_inserted",
              "created_by_id",
              "updated_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_job_metrics got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key,
              "jobExecutionKey": job_execution_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "description", "displayName", "timeInserted", "category", "subCategory", "unit", "value", "batchKey", "jobExecutionKey", "timeCreated", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "category": kwargs.get("category", missing),
              "subCategory": kwargs.get("sub_category", missing),
              "unit": kwargs.get("unit", missing),
              "value": kwargs.get("value", missing),
              "batchKey": kwargs.get("batch_key", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "timeInserted": kwargs.get("time_inserted", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobMetricCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobMetricCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_jobs(self, catalog_id, **kwargs):
          """
          Returns a list of jobs within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              Job lifecycle state.
  
              Allowed values are: "ACTIVE", "INACTIVE", "EXPIRED"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str job_type: (optional)
              Job type.
  
              Allowed values are: "HARVEST", "PROFILING", "SAMPLING", "PREVIEW", "IMPORT", "EXPORT", "IMPORT_GLOSSARY", "EXPORT_GLOSSARY", "INTERNAL", "PURGE", "IMMEDIATE", "SCHEDULED", "IMMEDIATE_EXECUTION", "SCHEDULED_EXECUTION", "SCHEDULED_EXECUTION_INSTANCE", "ASYNC_DELETE", "IMPORT_DATA_ASSET"
  
          :param str job_definition_key: (optional)
              Unique job definition key.
  
          :param str data_asset_key: (optional)
              Unique data asset key.
  
          :param str schedule_cron_expression: (optional)
              Interval on which the job will be run. Value is specified as a cron-supported time specification \"nickname\".
              The following subset of those is supported: @monthly, @weekly, @daily, @hourly.
  
          :param datetime time_schedule_begin: (optional)
              Date that the schedule should be operational. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_schedule_end: (optional)
              Date that the schedule should end from being operational. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str schedule_type: (optional)
              Type of the job schedule.
  
              Allowed values are: "SCHEDULED", "IMMEDIATE"
  
          :param str connection_key: (optional)
              Unique connection key.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a job summary response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "jobDefinitionKey", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "jobType", "scheduleCronExpression", "timeScheduleBegin", "scheduleType", "executionCount", "timeOfLatestExecution", "executions", "uri", "jobDefinitionName", "errorCode", "errorMessage"
  
          :param int execution_count: (optional)
              The total number of executions for this job schedule.
  
          :param datetime time_of_latest_execution: (optional)
              The date and time the most recent execution for this job ,in the format defined by `RFC3339`__.
              Example: `2019-03-25T21:10:29.600Z`
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_jobs.py.html>`__ to see an example of how to use list_jobs API.
          """
          resource_path = "/catalogs/{catalogId}/jobs"
          method = "GET"
          operation_name = "list_jobs"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobCollection/ListJobs"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "job_type",
              "job_definition_key",
              "data_asset_key",
              "schedule_cron_expression",
              "time_schedule_begin",
              "time_schedule_end",
              "schedule_type",
              "connection_key",
              "fields",
              "execution_count",
              "time_of_latest_execution",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_jobs got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["ACTIVE", "INACTIVE", "EXPIRED"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'job_type' in kwargs:
              job_type_allowed_values = ["HARVEST", "PROFILING", "SAMPLING", "PREVIEW", "IMPORT", "EXPORT", "IMPORT_GLOSSARY", "EXPORT_GLOSSARY", "INTERNAL", "PURGE", "IMMEDIATE", "SCHEDULED", "IMMEDIATE_EXECUTION", "SCHEDULED_EXECUTION", "SCHEDULED_EXECUTION_INSTANCE", "ASYNC_DELETE", "IMPORT_DATA_ASSET"]
              if kwargs['job_type'] not in job_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `job_type`, must be one of {0}".format(job_type_allowed_values)
                  )
  
          if 'schedule_type' in kwargs:
              schedule_type_allowed_values = ["SCHEDULED", "IMMEDIATE"]
              if kwargs['schedule_type'] not in schedule_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `schedule_type`, must be one of {0}".format(schedule_type_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "jobDefinitionKey", "lifecycleState", "timeCreated", "timeUpdated", "createdById", "updatedById", "jobType", "scheduleCronExpression", "timeScheduleBegin", "scheduleType", "executionCount", "timeOfLatestExecution", "executions", "uri", "jobDefinitionName", "errorCode", "errorMessage"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "jobType": kwargs.get("job_type", missing),
              "jobDefinitionKey": kwargs.get("job_definition_key", missing),
              "dataAssetKey": kwargs.get("data_asset_key", missing),
              "scheduleCronExpression": kwargs.get("schedule_cron_expression", missing),
              "timeScheduleBegin": kwargs.get("time_schedule_begin", missing),
              "timeScheduleEnd": kwargs.get("time_schedule_end", missing),
              "scheduleType": kwargs.get("schedule_type", missing),
              "connectionKey": kwargs.get("connection_key", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "executionCount": kwargs.get("execution_count", missing),
              "timeOfLatestExecution": kwargs.get("time_of_latest_execution", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="JobCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_metastores(self, compartment_id, **kwargs):
          """
          Returns a list of all metastores in the specified compartment.
  
  
          :param str compartment_id: (required)
              The OCID of the compartment where you want to list resources.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.MetastoreSummary`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_metastores.py.html>`__ to see an example of how to use list_metastores API.
          """
          resource_path = "/metastores"
          method = "GET"
          operation_name = "list_metastores"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/MetastoreSummary/ListMetastores"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "limit",
              "page",
              "lifecycle_state",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_metastores got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "displayName": kwargs.get("display_name", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[MetastoreSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[MetastoreSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_namespaces(self, catalog_id, **kwargs):
          """
          Returns a list of namespaces within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a namespace summary response.
  
              Allowed values are: "key", "displayName", "description", "lifecycleState", "timeCreated"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.NamespaceCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_namespaces.py.html>`__ to see an example of how to use list_namespaces API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces"
          method = "GET"
          operation_name = "list_namespaces"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Namespace/ListNamespaces"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "sort_by",
              "sort_order",
              "fields",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_namespaces got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "lifecycleState", "timeCreated"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="NamespaceCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="NamespaceCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_patterns(self, catalog_id, **kwargs):
          """
          Returns a list of patterns within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a pattern summary response.
  
              Allowed values are: "key", "displayName", "description", "catalogId", "expression", "lifecycleState", "timeCreated"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.PatternCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_patterns.py.html>`__ to see an example of how to use list_patterns API.
          """
          resource_path = "/catalogs/{catalogId}/patterns"
          method = "GET"
          operation_name = "list_patterns"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Pattern/ListPatterns"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_patterns got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "catalogId", "expression", "lifecycleState", "timeCreated"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="PatternCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="PatternCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_rules(self, catalog_id, data_asset_key, entity_key, **kwargs):
          """
          Returns a list of all rules of a data entity.
  
  
          :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 display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str rule_type: (optional)
              Rule type used to filter the response to a list rules call.
  
              Allowed values are: "PRIMARYKEY", "FOREIGNKEY", "UNIQUEKEY"
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str origin_type: (optional)
              Rule origin type used to filter the response to a list rules call.
  
              Allowed values are: "SOURCE", "USER", "PROFILING"
  
          :param str external_key: (optional)
              Unique external identifier of this resource in the external source system.
  
          :param datetime time_created: (optional)
              Time that the resource was created. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param datetime time_updated: (optional)
              Time that the resource was updated. An `RFC3339`__ formatted datetime string.
  
              __ https://tools.ietf.org/html/rfc3339
  
          :param str created_by_id: (optional)
              OCID of the user who created the resource.
  
          :param str updated_by_id: (optional)
              OCID of the user who updated the resource.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a rule summary response.
  
              Allowed values are: "key", "displayName", "ruleType", "externalKey", "referencedFolderKey", "referencedFolderName", "referencedEntityKey", "referencedEntityName", "referencedRuleKey", "referencedRuleName", "originType", "lifecycleState", "timeCreated", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.RuleCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_rules.py.html>`__ to see an example of how to use list_rules API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/rules"
          method = "GET"
          operation_name = "list_rules"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/RuleSummary/ListRules"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "rule_type",
              "lifecycle_state",
              "origin_type",
              "external_key",
              "time_created",
              "time_updated",
              "created_by_id",
              "updated_by_id",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_rules got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'rule_type' in kwargs:
              rule_type_allowed_values = ["PRIMARYKEY", "FOREIGNKEY", "UNIQUEKEY"]
              if kwargs['rule_type'] not in rule_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `rule_type`, must be one of {0}".format(rule_type_allowed_values)
                  )
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'origin_type' in kwargs:
              origin_type_allowed_values = ["SOURCE", "USER", "PROFILING"]
              if kwargs['origin_type'] not in origin_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `origin_type`, must be one of {0}".format(origin_type_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "ruleType", "externalKey", "referencedFolderKey", "referencedFolderName", "referencedEntityKey", "referencedEntityName", "referencedRuleKey", "referencedRuleName", "originType", "lifecycleState", "timeCreated", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "ruleType": kwargs.get("rule_type", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "originType": kwargs.get("origin_type", missing),
              "externalKey": kwargs.get("external_key", missing),
              "timeCreated": kwargs.get("time_created", missing),
              "timeUpdated": kwargs.get("time_updated", missing),
              "createdById": kwargs.get("created_by_id", missing),
              "updatedById": kwargs.get("updated_by_id", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="RuleCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="RuleCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_tags(self, catalog_id, **kwargs):
          """
          Returns a list of all user created tags in the system.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a term summary response.
  
              Allowed values are: "key", "displayName", "description", "glossaryKey", "parentTermKey", "isAllowedToHaveChildTerms", "path", "lifecycleState", "timeCreated", "workflowStatus", "associatedObjectCount", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.TermCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_tags.py.html>`__ to see an example of how to use list_tags API.
          """
          resource_path = "/catalogs/{catalogId}/tags"
          method = "GET"
          operation_name = "list_tags"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Term/ListTags"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_tags got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "glossaryKey", "parentTermKey", "isAllowedToHaveChildTerms", "path", "lifecycleState", "timeCreated", "workflowStatus", "associatedObjectCount", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_term_relationships(self, catalog_id, glossary_key, term_key, **kwargs):
          """
          Returns a list of all term relationships within a glossary.
  
  
          :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 display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a term relationship summary response.
  
              Allowed values are: "key", "displayName", "description", "relatedTermKey", "relatedTermDisplayName", "parentTermKey", "parentTermDisplayName", "lifecycleState", "timeCreated", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.TermRelationshipCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_term_relationships.py.html>`__ to see an example of how to use list_term_relationships API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}/termRelationships"
          method = "GET"
          operation_name = "list_term_relationships"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/TermRelationship/ListTermRelationships"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_term_relationships got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "relatedTermKey", "relatedTermDisplayName", "parentTermKey", "parentTermDisplayName", "lifecycleState", "timeCreated", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermRelationshipCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermRelationshipCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_terms(self, catalog_id, glossary_key, **kwargs):
          """
          Returns a list of all terms within a glossary.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str glossary_key: (required)
              Unique glossary key.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str display_name_contains: (optional)
              A filter to return only resources that match display name pattern given. The match is not case sensitive.
              For Example : /folders?displayNameContains=Cu.*
              The above would match all folders with display name that starts with \"Cu\" or has the pattern \"Cu\" anywhere in between.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str parent_term_key: (optional)
              Unique key of the parent term.
  
          :param bool is_allowed_to_have_child_terms: (optional)
              Indicates whether a term may contain child terms.
  
          :param str workflow_status: (optional)
              Status of the approval workflow for this business term in the glossary.
  
              Allowed values are: "NEW", "APPROVED", "UNDER_REVIEW", "ESCALATED"
  
          :param str path: (optional)
              Full path of the resource for resources that support paths.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a term summary response.
  
              Allowed values are: "key", "displayName", "description", "glossaryKey", "parentTermKey", "isAllowedToHaveChildTerms", "path", "lifecycleState", "timeCreated", "workflowStatus", "associatedObjectCount", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.TermCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_terms.py.html>`__ to see an example of how to use list_terms API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms"
          method = "GET"
          operation_name = "list_terms"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Term/ListTerms"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "display_name",
              "display_name_contains",
              "lifecycle_state",
              "parent_term_key",
              "is_allowed_to_have_child_terms",
              "workflow_status",
              "path",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_terms got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'workflow_status' in kwargs:
              workflow_status_allowed_values = ["NEW", "APPROVED", "UNDER_REVIEW", "ESCALATED"]
              if kwargs['workflow_status'] not in workflow_status_allowed_values:
                  raise ValueError(
                      "Invalid value for `workflow_status`, must be one of {0}".format(workflow_status_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "displayName", "description", "glossaryKey", "parentTermKey", "isAllowedToHaveChildTerms", "path", "lifecycleState", "timeCreated", "workflowStatus", "associatedObjectCount", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "displayNameContains": kwargs.get("display_name_contains", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "parentTermKey": kwargs.get("parent_term_key", missing),
              "isAllowedToHaveChildTerms": kwargs.get("is_allowed_to_have_child_terms", missing),
              "workflowStatus": kwargs.get("workflow_status", missing),
              "path": kwargs.get("path", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TermCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_types(self, catalog_id, **kwargs):
          """
          Returns a list of all types within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str name: (optional)
              Immutable resource name.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str is_internal: (optional)
              Indicates whether the type is internal, making it unavailable for use by metadata elements.
  
          :param str is_tag: (optional)
              Indicates whether the type can be used for tagging metadata elements.
  
          :param str is_approved: (optional)
              Indicates whether the type is approved for use as a classifying object.
  
          :param str external_type_name: (optional)
              Data type as defined in an external system.
  
          :param str type_category: (optional)
              Indicates the category of this type . For example, data assets or connections.
  
          :param list[str] fields: (optional)
              Specifies the fields to return in a type summary response.
  
              Allowed values are: "key", "description", "name", "catalogId", "lifecycleState", "typeCategory", "uri"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.TypeCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_types.py.html>`__ to see an example of how to use list_types API.
          """
          resource_path = "/catalogs/{catalogId}/types"
          method = "GET"
          operation_name = "list_types"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/TypeCollection/ListTypes"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "name",
              "lifecycle_state",
              "is_internal",
              "is_tag",
              "is_approved",
              "external_type_name",
              "type_category",
              "fields",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_types got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'fields' in kwargs:
              fields_allowed_values = ["key", "description", "name", "catalogId", "lifecycleState", "typeCategory", "uri"]
              for fields_item in kwargs['fields']:
                  if fields_item not in fields_allowed_values:
                      raise ValueError(
                          "Invalid value for `fields`, must be one of {0}".format(fields_allowed_values)
                      )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "name": kwargs.get("name", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "isInternal": kwargs.get("is_internal", missing),
              "isTag": kwargs.get("is_tag", missing),
              "isApproved": kwargs.get("is_approved", missing),
              "externalTypeName": kwargs.get("external_type_name", missing),
              "typeCategory": kwargs.get("type_category", missing),
              "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TypeCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="TypeCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_work_request_errors(self, work_request_id, **kwargs):
          """
          Returns a (paginated) list of errors for a given work request.
  
  
          :param str work_request_id: (required)
              The OCID of the asynchronous request.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMESTAMP is descending. Default order for CODE and MESSAGE is ascending. If no value is specified TIMESTAMP is default.
  
              Allowed values are: "CODE", "TIMESTAMP"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.WorkRequestError`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_work_request_errors.py.html>`__ to see an example of how to use list_work_request_errors API.
          """
          resource_path = "/workRequests/{workRequestId}/errors"
          method = "GET"
          operation_name = "list_work_request_errors"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/WorkRequestError/ListWorkRequestErrors"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "page",
              "limit",
              "sort_by",
              "sort_order"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_work_request_errors got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "workRequestId": work_request_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["CODE", "TIMESTAMP"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "page": kwargs.get("page", missing),
              "limit": kwargs.get("limit", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[WorkRequestError]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[WorkRequestError]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_work_request_logs(self, work_request_id, **kwargs):
          """
          Returns a (paginated) list of logs for a given work request.
  
  
          :param str work_request_id: (required)
              The OCID of the asynchronous request.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMESTAMP is descending. Default order for MESSAGE is ascending. If no value is specified TIMESTAMP is default.
  
              Allowed values are: "MESSAGE", "TIMESTAMP"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.WorkRequestLog`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_work_request_logs.py.html>`__ to see an example of how to use list_work_request_logs API.
          """
          resource_path = "/workRequests/{workRequestId}/logs"
          method = "GET"
          operation_name = "list_work_request_logs"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/WorkRequestLog/ListWorkRequestLogs"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "page",
              "limit",
              "sort_by",
              "sort_order"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_work_request_logs got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "workRequestId": work_request_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["MESSAGE", "TIMESTAMP"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "page": kwargs.get("page", missing),
              "limit": kwargs.get("limit", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[WorkRequestLog]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[WorkRequestLog]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def list_work_requests(self, compartment_id, **kwargs):
          """
          Lists the work requests in a compartment.
  
  
          :param str compartment_id: (required)
              The OCID of the compartment where you want to list resources.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.WorkRequest`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/list_work_requests.py.html>`__ to see an example of how to use list_work_requests API.
          """
          resource_path = "/workRequests"
          method = "GET"
          operation_name = "list_work_requests"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/WorkRequest/ListWorkRequests"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "page",
              "limit"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_work_requests got unknown kwargs: {!r}".format(extra_kwargs))
  
          query_params = {
              "compartmentId": compartment_id,
              "page": kwargs.get("page", missing),
              "limit": kwargs.get("limit", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[WorkRequest]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="list[WorkRequest]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def object_stats(self, catalog_id, **kwargs):
          """
          Returns stats on objects by type in the repository.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type str
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/object_stats.py.html>`__ to see an example of how to use object_stats API.
          """
          resource_path = "/catalogs/{catalogId}/actions/objectStats"
          method = "POST"
          operation_name = "object_stats"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/ObjectStats"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "object_stats got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="str",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="str",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def parse_connection(self, catalog_id, data_asset_key, parse_connection_details, **kwargs):
          """
          Parse data asset references through connections from this data asset.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param oci.data_catalog.models.ParseConnectionDetails parse_connection_details: (required)
              The information used to parse the connections from payload or connection detail.
  
          :param str connection_key: (optional)
              Unique connection key.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_catalog.models.ConnectionAliasSummary`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/parse_connection.py.html>`__ to see an example of how to use parse_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/actions/parseConnection"
          method = "POST"
          operation_name = "parse_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/ParseConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "connection_key",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "parse_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          query_params = {
              "connectionKey": kwargs.get("connection_key", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=parse_connection_details,
                  response_type="list[ConnectionAliasSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=parse_connection_details,
                  response_type="list[ConnectionAliasSummary]",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def process_recommendation(self, catalog_id, process_recommendation_details, **kwargs):
          """
          Act on a recommendation. A recommendation can be accepted or rejected. For example, if a recommendation of type LINK_GLOSSARY_TERM
          is accepted, the system will link the source object (e.g. an attribute) to a target glossary term.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param oci.data_catalog.models.ProcessRecommendationDetails process_recommendation_details: (required)
              Recommendation to be processed.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.ProcessRecommendationDetails`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/process_recommendation.py.html>`__ to see an example of how to use process_recommendation API.
          """
          resource_path = "/catalogs/{catalogId}/actions/processRecommendation"
          method = "POST"
          operation_name = "process_recommendation"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/ProcessRecommendation"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "process_recommendation got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=process_recommendation_details,
                  response_type="ProcessRecommendationDetails",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=process_recommendation_details,
                  response_type="ProcessRecommendationDetails",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def recommendations(self, catalog_id, recommendation_type, source_object_key, source_object_type, **kwargs):
          """
          Returns a list of recommendations for the given object and recommendation type.
          By default, it will return inferred recommendations for review. The optional query param 'RecommendationStatus' can be set,
          to return only recommendations having that status.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param oci.data_catalog.models.list[str] recommendation_type: (required)
              A filter used to return only recommendations of the specified type.
  
              Allowed values are: "LINK_GLOSSARY_TERM"
  
          :param str source_object_key: (required)
              A filter used to provide the unique identifier of the source object, for which a list of recommendations will be returned for review.
  
          :param str source_object_type: (required)
              A filter used to provide the type of the source object, for which a list of recommendations will be returned for review.
  
              Allowed values are: "DATA_ENTITY", "ATTRIBUTE", "TERM", "CATEGORY"
  
          :param str recommendation_status: (optional)
              A filter used to return only recommendations having the requested status.
  
              Allowed values are: "ACCEPTED", "REJECTED", "INFERRED"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.RecommendationCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/recommendations.py.html>`__ to see an example of how to use recommendations API.
          """
          resource_path = "/catalogs/{catalogId}/actions/getRecommendations"
          method = "POST"
          operation_name = "recommendations"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/Recommendations"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "recommendation_status",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "recommendations got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          recommendation_type_allowed_values = ["LINK_GLOSSARY_TERM"]
          for recommendation_type_item in recommendation_type:
              if recommendation_type_item not in recommendation_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `recommendation_type`, must be one of {0}".format(recommendation_type_allowed_values)
                  )
  
          source_object_type_allowed_values = ["DATA_ENTITY", "ATTRIBUTE", "TERM", "CATEGORY"]
          if source_object_type not in source_object_type_allowed_values:
              raise ValueError(
                  "Invalid value for `source_object_type`, must be one of {0}".format(source_object_type_allowed_values)
              )
  
          if 'recommendation_status' in kwargs:
              recommendation_status_allowed_values = ["ACCEPTED", "REJECTED", "INFERRED"]
              if kwargs['recommendation_status'] not in recommendation_status_allowed_values:
                  raise ValueError(
                      "Invalid value for `recommendation_status`, must be one of {0}".format(recommendation_status_allowed_values)
                  )
  
          query_params = {
              "recommendationType": self.base_client.generate_collection_format_param(recommendation_type, 'multi'),
              "sourceObjectKey": source_object_key,
              "sourceObjectType": source_object_type,
              "recommendationStatus": kwargs.get("recommendation_status", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="RecommendationCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="RecommendationCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def remove_data_selector_patterns(self, catalog_id, data_asset_key, data_selector_pattern_details, **kwargs):
          """
          Remove data selector pattern from the data asset.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAsset`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/remove_data_selector_patterns.py.html>`__ to see an example of how to use remove_data_selector_patterns API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/actions/removeDataSelectorPatterns"
          method = "POST"
          operation_name = "remove_data_selector_patterns"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/RemoveDataSelectorPatterns"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "if_match",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "remove_data_selector_patterns got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "if-match": kwargs.get("if_match", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=data_selector_pattern_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=data_selector_pattern_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def search_criteria(self, catalog_id, **kwargs):
          """
          Returns a list of search results within a data catalog.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param oci.data_catalog.models.SearchCriteria search_criteria_details: (optional)
              The information used to create an extended search results.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given. The match is not case sensitive.
  
          :param str name: (optional)
              Immutable resource name.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources that match the specified lifecycle state. The value is case insensitive.
  
              Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"
  
          :param str timeout: (optional)
              A search timeout string (for example, timeout=4000ms), bounding the search request to be executed within the
              specified time value and bail with the hits accumulated up to that point when expired.
              Defaults to no timeout.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.SearchResultCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/search_criteria.py.html>`__ to see an example of how to use search_criteria API.
          """
          resource_path = "/catalogs/{catalogId}/search"
          method = "POST"
          operation_name = "search_criteria"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/SearchResult/SearchCriteria"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "search_criteria_details",
              "display_name",
              "name",
              "lifecycle_state",
              "timeout",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "search_criteria got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "MOVING"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "displayName": kwargs.get("display_name", missing),
              "name": kwargs.get("name", missing),
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "timeout": kwargs.get("timeout", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=kwargs.get('search_criteria_details'),
                  response_type="SearchResultCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=kwargs.get('search_criteria_details'),
                  response_type="SearchResultCollection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def suggest_matches(self, catalog_id, input_text, **kwargs):
          """
          Returns a list of potential string matches for a given input string.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str input_text: (required)
              Text input string used for computing potential matching suggestions.
  
          :param str timeout: (optional)
              A search timeout string (for example, timeout=4000ms), bounding the search request to be executed within the
              specified time value and bail with the hits accumulated up to that point when expired.
              Defaults to no timeout.
  
          :param int limit: (optional)
              Limit for the list of potential matches returned from the Suggest API. If not specified, will default to 10.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.SuggestResults`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/suggest_matches.py.html>`__ to see an example of how to use suggest_matches API.
          """
          resource_path = "/catalogs/{catalogId}/actions/suggest"
          method = "POST"
          operation_name = "suggest_matches"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/SuggestResults/SuggestMatches"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "timeout",
              "limit",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "suggest_matches got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          query_params = {
              "timeout": kwargs.get("timeout", missing),
              "inputText": input_text,
              "limit": kwargs.get("limit", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="SuggestResults",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="SuggestResults",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def synchronous_export_data_asset(self, catalog_id, data_asset_key, synchronous_export_data_asset_details, export_type, **kwargs):
          """
          Export technical objects from a Data Asset
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param oci.data_catalog.models.ExportDataAssetDetails synchronous_export_data_asset_details: (required)
              The details of what needs to be exported.
  
          :param oci.data_catalog.models.list[str] export_type: (required)
              Type of export.
  
              Allowed values are: "CUSTOM_PROPERTY_VALUES", "ALL"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type stream
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/synchronous_export_data_asset.py.html>`__ to see an example of how to use synchronous_export_data_asset API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/actions/synchronousExport"
          method = "POST"
          operation_name = "synchronous_export_data_asset"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/SynchronousExportDataAsset"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "synchronous_export_data_asset got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          export_type_allowed_values = ["CUSTOM_PROPERTY_VALUES", "ALL"]
          for export_type_item in export_type:
              if export_type_item not in export_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `export_type`, must be one of {0}".format(export_type_allowed_values)
                  )
  
          query_params = {
              "exportType": self.base_client.generate_collection_format_param(export_type, 'multi')
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=synchronous_export_data_asset_details,
                  response_type="stream",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  body=synchronous_export_data_asset_details,
                  response_type="stream",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def test_connection(self, catalog_id, data_asset_key, connection_key, **kwargs):
          """
          Test the connection by connecting to the data asset using credentials in the metadata.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.ValidateConnectionResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/test_connection.py.html>`__ to see an example of how to use test_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections/{connectionKey}/actions/test"
          method = "POST"
          operation_name = "test_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Connection/TestConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "test_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "connectionKey": connection_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ValidateConnectionResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ValidateConnectionResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_attribute(self, catalog_id, data_asset_key, entity_key, attribute_key, update_attribute_details, **kwargs):
          """
          Updates a specific data asset attribute.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Attribute`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_attribute.py.html>`__ to see an example of how to use update_attribute API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}/attributes/{attributeKey}"
          method = "PUT"
          operation_name = "update_attribute"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Attribute/UpdateAttribute"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_attribute got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key,
              "attributeKey": attribute_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_attribute_details,
                  response_type="Attribute",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_attribute_details,
                  response_type="Attribute",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_catalog(self, catalog_id, update_catalog_details, **kwargs):
          """
          Updates the data catalog.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Catalog`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_catalog.py.html>`__ to see an example of how to use update_catalog API.
          """
          resource_path = "/catalogs/{catalogId}"
          method = "PUT"
          operation_name = "update_catalog"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/UpdateCatalog"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_catalog got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_catalog_details,
                  response_type="Catalog",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_catalog_details,
                  response_type="Catalog",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_catalog_private_endpoint(self, catalog_private_endpoint_id, update_catalog_private_endpoint_details, **kwargs):
          """
          Updates the private reverse connection endpoint.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_catalog_private_endpoint.py.html>`__ to see an example of how to use update_catalog_private_endpoint API.
          """
          resource_path = "/catalogPrivateEndpoints/{catalogPrivateEndpointId}"
          method = "PUT"
          operation_name = "update_catalog_private_endpoint"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CatalogPrivateEndpoint/UpdateCatalogPrivateEndpoint"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_catalog_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogPrivateEndpointId": catalog_private_endpoint_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_catalog_private_endpoint_details,
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_connection(self, catalog_id, data_asset_key, connection_key, update_connection_details, **kwargs):
          """
          Updates a specific connection of a data asset.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Connection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_connection.py.html>`__ to see an example of how to use update_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections/{connectionKey}"
          method = "PUT"
          operation_name = "update_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Connection/UpdateConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "connectionKey": connection_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_connection_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_connection_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_custom_property(self, catalog_id, namespace_id, custom_property_key, update_custom_property_details, **kwargs):
          """
          Updates a specific custom property identified by the given key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.CustomProperty`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_custom_property.py.html>`__ to see an example of how to use update_custom_property API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}/customProperties/{customPropertyKey}"
          method = "PUT"
          operation_name = "update_custom_property"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/CustomProperty/UpdateCustomProperty"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_custom_property got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id,
              "customPropertyKey": custom_property_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_custom_property_details,
                  response_type="CustomProperty",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_custom_property_details,
                  response_type="CustomProperty",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_data_asset(self, catalog_id, data_asset_key, update_data_asset_details, **kwargs):
          """
          Updates a specific data asset identified by the given key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.DataAsset`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_data_asset.py.html>`__ to see an example of how to use update_data_asset API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}"
          method = "PUT"
          operation_name = "update_data_asset"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/UpdateDataAsset"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_data_asset got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_data_asset_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_data_asset_details,
                  response_type="DataAsset",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_entity(self, catalog_id, data_asset_key, entity_key, update_entity_details, **kwargs):
          """
          Updates a specific data entity.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Entity`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_entity.py.html>`__ to see an example of how to use update_entity API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/entities/{entityKey}"
          method = "PUT"
          operation_name = "update_entity"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Entity/UpdateEntity"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_entity got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "entityKey": entity_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_entity_details,
                  response_type="Entity",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_entity_details,
                  response_type="Entity",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_folder(self, catalog_id, data_asset_key, folder_key, update_folder_details, **kwargs):
          """
          Updates a specific folder of a data asset.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Folder`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_folder.py.html>`__ to see an example of how to use update_folder API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/folders/{folderKey}"
          method = "PUT"
          operation_name = "update_folder"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Folder/UpdateFolder"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_folder got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "folderKey": folder_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_folder_details,
                  response_type="Folder",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_folder_details,
                  response_type="Folder",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_glossary(self, catalog_id, glossary_key, update_glossary_details, **kwargs):
          """
          Updates a specific glossary identified by the given key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Glossary`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_glossary.py.html>`__ to see an example of how to use update_glossary API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}"
          method = "PUT"
          operation_name = "update_glossary"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Glossary/UpdateGlossary"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_glossary got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_glossary_details,
                  response_type="Glossary",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_glossary_details,
                  response_type="Glossary",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_job(self, catalog_id, job_key, update_job_details, **kwargs):
          """
          Updates a specific job identified by the given key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Job`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_job.py.html>`__ to see an example of how to use update_job API.
          """
          resource_path = "/catalogs/{catalogId}/jobs/{jobKey}"
          method = "PUT"
          operation_name = "update_job"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Job/UpdateJob"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_job got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobKey": job_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_job_details,
                  response_type="Job",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_job_details,
                  response_type="Job",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_job_definition(self, catalog_id, job_definition_key, update_job_definition_details, **kwargs):
          """
          Update a specific job definition identified by the given key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.JobDefinition`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_job_definition.py.html>`__ to see an example of how to use update_job_definition API.
          """
          resource_path = "/catalogs/{catalogId}/jobDefinitions/{jobDefinitionKey}"
          method = "PUT"
          operation_name = "update_job_definition"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/JobDefinition/UpdateJobDefinition"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_job_definition got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "jobDefinitionKey": job_definition_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_job_definition_details,
                  response_type="JobDefinition",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_job_definition_details,
                  response_type="JobDefinition",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_metastore(self, metastore_id, update_metastore_details, **kwargs):
          """
          Updates a metastore resource by identifier.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Metastore`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_metastore.py.html>`__ to see an example of how to use update_metastore API.
          """
          resource_path = "/metastores/{metastoreId}"
          method = "PUT"
          operation_name = "update_metastore"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Metastore/UpdateMetastore"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_metastore got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "metastoreId": metastore_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_metastore_details,
                  response_type="Metastore",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_metastore_details,
                  response_type="Metastore",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_namespace(self, catalog_id, namespace_id, update_namespace_details, **kwargs):
          """
          Updates a specific namespace identified by the given key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Namespace`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_namespace.py.html>`__ to see an example of how to use update_namespace API.
          """
          resource_path = "/catalogs/{catalogId}/namespaces/{namespaceId}"
          method = "PUT"
          operation_name = "update_namespace"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Namespace/UpdateNamespace"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_namespace got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "namespaceId": namespace_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_namespace_details,
                  response_type="Namespace",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_namespace_details,
                  response_type="Namespace",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_pattern(self, catalog_id, pattern_key, update_pattern_details, **kwargs):
          """
          Updates a specific pattern identified by the given key.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Pattern`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_pattern.py.html>`__ to see an example of how to use update_pattern API.
          """
          resource_path = "/catalogs/{catalogId}/patterns/{patternKey}"
          method = "PUT"
          operation_name = "update_pattern"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Pattern/UpdatePattern"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_pattern got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "patternKey": pattern_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_pattern_details,
                  response_type="Pattern",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_pattern_details,
                  response_type="Pattern",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_term(self, catalog_id, glossary_key, term_key, update_term_details, **kwargs):
          """
          Updates a specific glossary term.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Term`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_term.py.html>`__ to see an example of how to use update_term API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}"
          method = "PUT"
          operation_name = "update_term"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Term/UpdateTerm"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_term got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_term_details,
                  response_type="Term",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_term_details,
                  response_type="Term",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def update_term_relationship(self, catalog_id, glossary_key, term_key, term_relationship_key, update_term_relationship_details, **kwargs):
          """
          Updates a specific glossary term relationship.
  
  
          :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 str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.TermRelationship`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/update_term_relationship.py.html>`__ to see an example of how to use update_term_relationship API.
          """
          resource_path = "/catalogs/{catalogId}/glossaries/{glossaryKey}/terms/{termKey}/termRelationships/{termRelationshipKey}"
          method = "PUT"
          operation_name = "update_term_relationship"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/TermRelationship/UpdateTermRelationship"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_term_relationship got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "glossaryKey": glossary_key,
              "termKey": term_key,
              "termRelationshipKey": term_relationship_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_term_relationship_details,
                  response_type="TermRelationship",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_term_relationship_details,
                  response_type="TermRelationship",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def upload_credentials(self, catalog_id, data_asset_key, connection_key, upload_credentials_details, **kwargs):
          """
          Upload connection credentails and metadata for this connection.
  
  
          :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 str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.Connection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/upload_credentials.py.html>`__ to see an example of how to use upload_credentials API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections/{connectionKey}/actions/uploadCredentials"
          method = "POST"
          operation_name = "upload_credentials"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Connection/UploadCredentials"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "if_match",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "upload_credentials got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key,
              "connectionKey": connection_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "if-match": kwargs.get("if_match", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=upload_credentials_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=upload_credentials_details,
                  response_type="Connection",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def users(self, catalog_id, **kwargs):
          """
          Returns active users in the system.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. If no value is specified TIMECREATED is default.
  
              Allowed values are: "TIMECREATED", "DISPLAYNAME"
  
          :param str sort_order: (optional)
              The sort order to use, either 'asc' or 'desc'.
  
              Allowed values are: "ASC", "DESC"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type str
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/users.py.html>`__ to see an example of how to use users API.
          """
          resource_path = "/catalogs/{catalogId}/actions/users"
          method = "POST"
          operation_name = "users"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Catalog/Users"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "sort_by",
              "sort_order",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "users got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          query_params = {
              "sortBy": kwargs.get("sort_by", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="str",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="str",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def validate_connection(self, catalog_id, data_asset_key, validate_connection_details, **kwargs):
          """
          Validate connection by connecting to the data asset using credentials in metadata.
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str data_asset_key: (required)
              Unique data asset key.
  
          :param oci.data_catalog.models.ValidateConnectionDetails validate_connection_details: (required)
              The information used to validate the connections.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.ValidateConnectionResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/validate_connection.py.html>`__ to see an example of how to use validate_connection API.
          """
          resource_path = "/catalogs/{catalogId}/dataAssets/{dataAssetKey}/actions/validateConnection"
          method = "POST"
          operation_name = "validate_connection"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/DataAsset/ValidateConnection"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "validate_connection got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "dataAssetKey": data_asset_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=validate_connection_details,
                  response_type="ValidateConnectionResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=validate_connection_details,
                  response_type="ValidateConnectionResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  
      def validate_pattern(self, catalog_id, pattern_key, validate_pattern_details, **kwargs):
          """
          Validate pattern by deriving file groups representing logical entities using the expression
  
  
          :param str catalog_id: (required)
              Unique catalog identifier.
  
          :param str pattern_key: (required)
              Unique pattern key.
  
          :param oci.data_catalog.models.ValidatePatternDetails validate_pattern_details: (required)
              The information used to validate the pattern.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :param bool allow_control_chars: (optional)
              allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
              By default, the response will not allow control characters in strings
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_catalog.models.ValidatePatternResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/datacatalog/validate_pattern.py.html>`__ to see an example of how to use validate_pattern API.
          """
          resource_path = "/catalogs/{catalogId}/patterns/{patternKey}/actions/validate"
          method = "POST"
          operation_name = "validate_pattern"
          api_reference_link = "https://docs.oracle.com/iaas/api/#/en/data-catalog/20190325/Pattern/ValidatePattern"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "allow_control_chars",
              "retry_strategy",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "validate_pattern got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "catalogId": catalog_id,
              "patternKey": pattern_key
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
          if retry_strategy is None:
              retry_strategy = retry.DEFAULT_RETRY_STRATEGY
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=validate_pattern_details,
                  response_type="ValidatePatternResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=validate_pattern_details,
                  response_type="ValidatePatternResult",
                  allow_control_chars=kwargs.get('allow_control_chars'),
                  operation_name=operation_name,
                  api_reference_link=api_reference_link)
  