apache-airflow-providers-google 12.0.0rc1__py3-none-any.whl → 13.0.0__py3-none-any.whl

airflow/providers/google/cloud/hooks/dataplex.py

@@ -19,35 +19,53 @@
 from __future__ import annotations
 
 import time
-from collections.abc import Sequence
+from collections.abc import MutableSequence, Sequence
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 
+from airflow.exceptions import AirflowException
+from airflow.providers.google.common.consts import CLIENT_INFO
+from airflow.providers.google.common.hooks.base_google import (
+    PROVIDE_PROJECT_ID,
+    GoogleBaseAsyncHook,
+    GoogleBaseHook,
+)
 from google.api_core.client_options import ClientOptions
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
-from google.cloud.dataplex_v1 import DataplexServiceClient, DataScanServiceAsyncClient, DataScanServiceClient
+from google.cloud.dataplex_v1 import (
+    DataplexServiceClient,
+    DataScanServiceAsyncClient,
+    DataScanServiceClient,
+)
+from google.cloud.dataplex_v1.services.catalog_service import CatalogServiceClient
 from google.cloud.dataplex_v1.types import (
+    AspectType,
     Asset,
     DataScan,
     DataScanJob,
+    Entry,
+    EntryGroup,
+    EntryType,
+    EntryView,
     Lake,
     Task,
     Zone,
 )
 from google.protobuf.field_mask_pb2 import FieldMask
 
-from airflow.exceptions import AirflowException
-from airflow.providers.google.common.consts import CLIENT_INFO
-from airflow.providers.google.common.hooks.base_google import (
-    PROVIDE_PROJECT_ID,
-    GoogleBaseAsyncHook,
-    GoogleBaseHook,
-)
-
 if TYPE_CHECKING:
+    from googleapiclient.discovery import Resource
+
     from google.api_core.operation import Operation
     from google.api_core.retry import Retry
     from google.api_core.retry_async import AsyncRetry
-    from googleapiclient.discovery import Resource
+    from google.cloud.dataplex_v1.services.catalog_service.pagers import (
+        ListAspectTypesPager,
+        ListEntriesPager,
+        ListEntryGroupsPager,
+        ListEntryTypesPager,
+        SearchEntriesPager,
+    )
 
 PATH_DATA_SCAN = "projects/{project_id}/locations/{region}/dataScans/{data_scan_id}"
 
@@ -110,6 +128,14 @@ class DataplexHook(GoogleBaseHook):
             credentials=self.get_credentials(), client_info=CLIENT_INFO, client_options=client_options
         )
 
+    def get_dataplex_catalog_client(self) -> CatalogServiceClient:
+        """Return CatalogServiceClient."""
+        client_options = ClientOptions(api_endpoint="dataplex.googleapis.com:443")
+
+        return CatalogServiceClient(
+            credentials=self.get_credentials(), client_info=CLIENT_INFO, client_options=client_options
+        )
+
     def wait_for_operation(self, timeout: float | None, operation: Operation):
         """Wait for long-lasting operation to complete."""
         try:
@@ -118,6 +144,1001 @@ class DataplexHook(GoogleBaseHook):
             error = operation.exception(timeout=timeout)
             raise AirflowException(error)
 
+    @GoogleBaseHook.fallback_to_default_project_id
+    def create_entry(
+        self,
+        location: str,
+        entry_id: str,
+        entry_group_id: str,
+        entry_configuration: Entry | dict,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Entry:
+        """
+        Create an EntryType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+            Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+            names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+            The format is a full resource name of the resource without the prefix double slashes in the API
+            service name part of the full resource name. This allows retrieval of entries using their
+            associated resource name.
+
+            For example, if the full resource name of a resource is
+            ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+            ``library.googleapis.com/shelves/shelf1/books/book2``.
+
+            It is also suggested to follow the same convention for entries corresponding to resources from
+            providers or systems other than Google Cloud.
+            The maximum size of the field is 4000 characters.
+        :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+        :param entry_configuration: Required. Entry configuration body.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.create_entry(
+            request={
+                "parent": client.entry_group_path(project_id, location, entry_group_id),
+                "entry_id": entry_id,
+                "entry": entry_configuration,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def get_entry(
+        self,
+        location: str,
+        entry_id: str,
+        entry_group_id: str,
+        view: EntryView | str | None = None,
+        aspect_types: MutableSequence[str] | None = None,
+        paths: MutableSequence[str] | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Entry:
+        """
+        Get an Entry resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+            Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+            names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+            The format is a full resource name of the resource without the prefix double slashes in the API
+            service name part of the full resource name. This allows retrieval of entries using their
+            associated resource name.
+
+            For example, if the full resource name of a resource is
+            ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+            ``library.googleapis.com/shelves/shelf1/books/book2``.
+
+            It is also suggested to follow the same convention for entries corresponding to resources from
+            providers or systems other than Google Cloud.
+            The maximum size of the field is 4000 characters.
+        :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+        :param view: Optional. View to control which parts of an entry the service should return.
+        :param aspect_types: Optional. Limits the aspects returned to the provided aspect types.
+            It only works for CUSTOM view.
+        :param paths: Optional. Limits the aspects returned to those associated with the provided paths
+            within the Entry. It only works for CUSTOM view.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.get_entry(
+            request={
+                "name": client.entry_path(project_id, location, entry_group_id, entry_id),
+                "view": view,
+                "aspect_types": aspect_types,
+                "paths": paths,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def delete_entry(
+        self,
+        location: str,
+        entry_id: str,
+        entry_group_id: str,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Entry:
+        """
+        Delete an AspectType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+            Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+            names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+            The format is a full resource name of the resource without the prefix double slashes in the API
+            service name part of the full resource name. This allows retrieval of entries using their
+            associated resource name.
+
+            For example, if the full resource name of a resource is
+            ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+            ``library.googleapis.com/shelves/shelf1/books/book2``.
+
+            It is also suggested to follow the same convention for entries corresponding to resources from
+            providers or systems other than Google Cloud.
+            The maximum size of the field is 4000 characters.
+        :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.delete_entry(
+            request={
+                "name": client.entry_path(project_id, location, entry_group_id, entry_id),
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def list_entries(
+        self,
+        location: str,
+        entry_group_id: str,
+        filter_by: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> ListEntriesPager:
+        r"""
+        List Entries resources from specific location.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+        :param filter_by: Optional. A filter on the entries to return. Filters are case-sensitive.
+            You can filter the request by the following fields:
+
+            - entry_type
+            - entry_source.display_name
+
+            The comparison operators are =, !=, <, >, <=, >=. The service compares strings according to
+            lexical order.
+            You can use the logical operators AND, OR, NOT in the filter. You can use Wildcard "*", but for
+            entry_type you need to provide the full project id or number.
+            Example filter expressions:
+
+            - "entry_source.display_name=AnExampleDisplayName"
+            - "entry_type=projects/example-project/locations/global/entryTypes/example-entry_type"
+            - "entry_type=projects/example-project/locations/us/entryTypes/a\*
+               OR entry_type=projects/another-project/locations/\*"
+            - "NOT entry_source.display_name=AnotherExampleDisplayName".
+
+        :param page_size: Optional. Number of items to return per page. If there are remaining results,
+            the service returns a next_page_token. If unspecified, the service returns at most 10 Entries.
+            The maximum value is 100; values above 100 will be coerced to 100.
+        :param page_token: Optional. Page token received from a previous ``ListEntries`` call. Provide
+            this to retrieve the subsequent page.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.list_entries(
+            request={
+                "parent": client.entry_group_path(project_id, location, entry_group_id),
+                "filter": filter_by,
+                "page_size": page_size,
+                "page_token": page_token,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def search_entries(
+        self,
+        location: str,
+        query: str,
+        order_by: str | None = None,
+        scope: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> SearchEntriesPager:
+        """
+        Search for Entries matching the given query and scope.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param query: Required. The query against which entries in scope should be matched. The query
+            syntax is defined in `Search syntax for Dataplex Catalog
+            <https://cloud.google.com/dataplex/docs/search-syntax>`__.
+        :param order_by: Optional. Specifies the ordering of results. Supported values are:
+
+            - ``relevance`` (default)
+            - ``last_modified_timestamp``
+            - ``last_modified_timestamp asc``
+
+        :param scope: Optional. The scope under which the search should be operating. It must either be
+            ``organizations/<org_id>`` or ``projects/<project_ref>``. If it is unspecified, it
+            defaults to the organization where the project provided in ``name`` is located.
+        :param page_size: Optional. Number of items to return per page. If there are remaining results,
+            the service returns a next_page_token. If unspecified, the service returns at most 10 Entries.
+            The maximum value is 100; values above 100 will be coerced to 100.
+        :param page_token: Optional. Page token received from a previous ``ListEntries`` call. Provide
+            this to retrieve the subsequent page.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.search_entries(
+            request={
+                "name": client.common_location_path(project_id, location),
+                "query": query,
+                "order_by": order_by,
+                "page_size": page_size,
+                "page_token": page_token,
+                "scope": scope,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def lookup_entry(
+        self,
+        location: str,
+        entry_id: str,
+        entry_group_id: str,
+        view: EntryView | str | None = None,
+        aspect_types: MutableSequence[str] | None = None,
+        paths: MutableSequence[str] | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Entry:
+        """
+        Look up a single Entry by name using the permission on the source system.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+            Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+            names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+            The format is a full resource name of the resource without the prefix double slashes in the API
+            service name part of the full resource name. This allows retrieval of entries using their
+            associated resource name.
+            For example, if the full resource name of a resource is
+            ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+            ``library.googleapis.com/shelves/shelf1/books/book2``.
+            It is also suggested to follow the same convention for entries corresponding to resources from
+            providers or systems other than Google Cloud.
+            The maximum size of the field is 4000 characters.
+        :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+        :param view: Optional. View to control which parts of an entry the service should return.
+        :param aspect_types: Optional. Limits the aspects returned to the provided aspect types.
+            It only works for CUSTOM view.
+        :param paths: Optional. Limits the aspects returned to those associated with the provided paths
+            within the Entry. It only works for CUSTOM view.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.lookup_entry(
+            request={
+                "name": client.common_location_path(project_id, location),
+                "entry": client.entry_path(project_id, location, entry_group_id, entry_id),
+                "view": view,
+                "aspect_types": aspect_types,
+                "paths": paths,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def update_entry(
+        self,
+        location: str,
+        entry_id: str,
+        entry_group_id: str,
+        entry_configuration: dict | Entry,
+        allow_missing: bool | None = False,
+        delete_missing_aspects: bool | None = False,
+        aspect_keys: MutableSequence[str] | None = None,
+        update_mask: list[str] | FieldMask | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Entry:
+        """
+        Update an Entry resource.
+
+        :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+            Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+            names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+            The format is a full resource name of the resource without the prefix double slashes in the API
+            service name part of the full resource name. This allows retrieval of entries using their
+            associated resource name.
+            For example, if the full resource name of a resource is
+            ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+            ``library.googleapis.com/shelves/shelf1/books/book2``.
+            It is also suggested to follow the same convention for entries corresponding to resources from
+            providers or systems other than Google Cloud.
+            The maximum size of the field is 4000 characters.
+        :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+        :param entry_configuration: Required. The updated configuration body of the Entry.
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param update_mask: Optional. Names of fields whose values to overwrite on an entry group.
+            If this parameter is absent or empty, all modifiable fields are overwritten. If such
+            fields are non-required and omitted in the request body, their values are emptied.
+        :param allow_missing: Optional. If set to true and entry doesn't exist, the service will create it.
+        :param delete_missing_aspects: Optional. If set to true and the aspect_keys specify aspect
+            ranges, the service deletes any existing aspects from that range that weren't provided
+            in the request.
+        :param aspect_keys: Optional. The map keys of the Aspects which the service should modify.
+            It supports the following syntax:
+
+            - ``<aspect_type_reference>`` - matches an aspect of the given type and empty path.
+            - ``<aspect_type_reference>@path`` - matches an aspect of the given type and specified path.
+                For example, to attach an aspect to a field that is specified by the ``schema``
+                aspect, the path should have the format ``Schema.<field_name>``.
+            - ``<aspect_type_reference>@*`` - matches aspects of the given type for all paths.
+            - ``*@path`` - matches aspects of all types on the given path.
+
+            The service will not remove existing aspects matching the syntax unless ``delete_missing_aspects``
+            is set to true.
+            If this field is left empty, the service treats it as specifying exactly those Aspects present
+            in the request.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        _entry = (
+            deepcopy(entry_configuration)
+            if isinstance(entry_configuration, dict)
+            else Entry.to_dict(entry_configuration)
+        )
+        _entry["name"] = client.entry_path(project_id, location, entry_group_id, entry_id)
+        return client.update_entry(
+            request={
+                "entry": _entry,
+                "update_mask": FieldMask(paths=update_mask) if type(update_mask) is list else update_mask,
+                "allow_missing": allow_missing,
+                "delete_missing_aspects": delete_missing_aspects,
+                "aspect_keys": aspect_keys,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def create_aspect_type(
+        self,
+        location: str,
+        aspect_type_id: str,
+        aspect_type_configuration: AspectType | dict,
+        project_id: str = PROVIDE_PROJECT_ID,
+        validate_only: bool = False,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Create an EntryType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param aspect_type_id: Required. AspectType identifier.
+        :param aspect_type_configuration: Required. AspectType configuration body.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param validate_only: Optional. If set, performs request validation, but does not actually execute
+            the create request.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.create_aspect_type(
+            request={
+                "parent": client.common_location_path(project_id, location),
+                "aspect_type_id": aspect_type_id,
+                "aspect_type": aspect_type_configuration,
+                "validate_only": validate_only,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def get_aspect_type(
+        self,
+        location: str,
+        aspect_type_id: str,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> AspectType:
+        """
+        Get an AspectType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param aspect_type_id: Required. AspectType identifier.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.get_aspect_type(
+            request={
+                "name": client.aspect_type_path(project_id, location, aspect_type_id),
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def create_entry_type(
+        self,
+        location: str,
+        entry_type_id: str,
+        entry_type_configuration: EntryType | dict,
+        project_id: str = PROVIDE_PROJECT_ID,
+        validate_only: bool = False,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Create an EntryType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_type_id: Required. EntryType identifier.
+        :param entry_type_configuration: Required. EntryType configuration body.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param validate_only: Optional. If set, performs request validation, but does not actually execute
+            the create request.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.create_entry_type(
+            request={
+                "parent": client.common_location_path(project_id, location),
+                "entry_type_id": entry_type_id,
+                "entry_type": entry_type_configuration,
+                "validate_only": validate_only,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def get_entry_type(
+        self,
+        location: str,
+        entry_type_id: str,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> EntryType:
+        """
+        Get an EntryType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_type_id: Required. EntryGroup identifier.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.get_entry_type(
+            request={
+                "name": client.entry_type_path(project_id, location, entry_type_id),
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def delete_aspect_type(
+        self,
+        location: str,
+        aspect_type_id: str,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Delete an AspectType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param aspect_type_id: Required. AspectType identifier.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.delete_aspect_type(
+            request={
+                "name": client.aspect_type_path(project_id, location, aspect_type_id),
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def list_aspect_types(
+        self,
+        location: str,
+        filter_by: str | None = None,
+        order_by: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> ListAspectTypesPager:
+        """
+        List AspectTypes resources from specific location.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param filter_by: Optional. Filter to apply on the list results.
+        :param order_by: Optional. Fields to order the results by.
+        :param page_size: Optional. Maximum number of EntryGroups to return on one page.
+        :param page_token: Optional. Token to retrieve the next page of results.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.list_aspect_types(
+            request={
+                "parent": client.common_location_path(project_id, location),
+                "filter": filter_by,
+                "order_by": order_by,
+                "page_size": page_size,
+                "page_token": page_token,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def update_aspect_type(
+        self,
+        location: str,
+        aspect_type_id: str,
+        aspect_type_configuration: dict | AspectType,
+        project_id: str = PROVIDE_PROJECT_ID,
+        update_mask: list[str] | FieldMask | None = None,
+        validate_only: bool | None = False,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Update an AspectType resource.
+
+        :param aspect_type_id: Required. ID of the AspectType to update.
+        :param aspect_type_configuration: Required. The updated configuration body of the AspectType.
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param update_mask: Optional. Names of fields whose values to overwrite on an entry group.
+            If this parameter is absent or empty, all modifiable fields are overwritten. If such
+            fields are non-required and omitted in the request body, their values are emptied.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param validate_only: Optional. The service validates the request without performing any mutations.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        _aspect_type = (
+            deepcopy(aspect_type_configuration)
+            if isinstance(aspect_type_configuration, dict)
+            else AspectType.to_dict(aspect_type_configuration)
+        )
+        _aspect_type["name"] = client.aspect_type_path(project_id, location, aspect_type_id)
+        return client.update_aspect_type(
+            request={
+                "aspect_type": _aspect_type,
+                "update_mask": FieldMask(paths=update_mask) if type(update_mask) is list else update_mask,
+                "validate_only": validate_only,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def delete_entry_type(
+        self,
+        location: str,
+        entry_type_id: str,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Delete an EntryType resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_type_id: Required. EntryType identifier.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.delete_entry_type(
+            request={
+                "name": client.entry_type_path(project_id, location, entry_type_id),
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def list_entry_types(
+        self,
+        location: str,
+        filter_by: str | None = None,
+        order_by: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> ListEntryTypesPager:
+        """
+        List EntryTypes resources from specific location.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param filter_by: Optional. Filter to apply on the list results.
+        :param order_by: Optional. Fields to order the results by.
+        :param page_size: Optional. Maximum number of EntryGroups to return on one page.
+        :param page_token: Optional. Token to retrieve the next page of results.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.list_entry_types(
+            request={
+                "parent": client.common_location_path(project_id, location),
+                "filter": filter_by,
+                "order_by": order_by,
+                "page_size": page_size,
+                "page_token": page_token,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def update_entry_type(
+        self,
+        location: str,
+        entry_type_id: str,
+        entry_type_configuration: dict | EntryType,
+        project_id: str = PROVIDE_PROJECT_ID,
+        update_mask: list[str] | FieldMask | None = None,
+        validate_only: bool | None = False,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Update an EntryType resource.
+
+        :param entry_type_id: Required. ID of the EntryType to update.
+        :param entry_type_configuration: Required. The updated configuration body of the EntryType.
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param update_mask: Optional. Names of fields whose values to overwrite on an entry group.
+            If this parameter is absent or empty, all modifiable fields are overwritten. If such
+            fields are non-required and omitted in the request body, their values are emptied.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param validate_only: Optional. The service validates the request without performing any mutations.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        _entry_type = (
+            deepcopy(entry_type_configuration)
+            if isinstance(entry_type_configuration, dict)
+            else EntryType.to_dict(entry_type_configuration)
+        )
+        _entry_type["name"] = client.entry_type_path(project_id, location, entry_type_id)
+        return client.update_entry_type(
+            request={
+                "entry_type": _entry_type,
+                "update_mask": FieldMask(paths=update_mask) if type(update_mask) is list else update_mask,
+                "validate_only": validate_only,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def create_entry_group(
+        self,
+        location: str,
+        entry_group_id: str,
+        entry_group_configuration: EntryGroup | dict,
+        project_id: str = PROVIDE_PROJECT_ID,
+        validate_only: bool = False,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Create an Entry resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_group_id: Required. EntryGroup identifier.
+        :param entry_group_configuration: Required. EntryGroup configuration body.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param validate_only: Optional. If set, performs request validation, but does not actually execute
+            the create request.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.create_entry_group(
+            request={
+                "parent": client.common_location_path(project_id, location),
+                "entry_group_id": entry_group_id,
+                "entry_group": entry_group_configuration,
+                "validate_only": validate_only,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def get_entry_group(
+        self,
+        location: str,
+        entry_group_id: str,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> EntryGroup:
+        """
+        Get an EntryGroup resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_group_id: Required. EntryGroup identifier.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.get_entry_group(
+            request={
+                "name": client.entry_group_path(project_id, location, entry_group_id),
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def delete_entry_group(
+        self,
+        location: str,
+        entry_group_id: str,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Delete an EntryGroup resource.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param entry_group_id: Required. EntryGroup identifier.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.delete_entry_group(
+            request={
+                "name": client.entry_group_path(project_id, location, entry_group_id),
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def list_entry_groups(
+        self,
+        location: str,
+        filter_by: str | None = None,
+        order_by: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        project_id: str = PROVIDE_PROJECT_ID,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> ListEntryGroupsPager:
+        """
+        List EntryGroups resources from specific location.
+
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param filter_by: Optional. Filter to apply on the list results.
+        :param order_by: Optional. Fields to order the results by.
+        :param page_size: Optional. Maximum number of EntryGroups to return on one page.
+        :param page_token: Optional. Token to retrieve the next page of results.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        return client.list_entry_groups(
+            request={
+                "parent": client.common_location_path(project_id, location),
+                "filter": filter_by,
+                "order_by": order_by,
+                "page_size": page_size,
+                "page_token": page_token,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def update_entry_group(
+        self,
+        location: str,
+        entry_group_id: str,
+        entry_group_configuration: dict | EntryGroup,
+        project_id: str = PROVIDE_PROJECT_ID,
+        update_mask: list[str] | FieldMask | None = None,
+        validate_only: bool | None = False,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> Operation:
+        """
+        Update an EntryGroup resource.
+
+        :param entry_group_id: Required. ID of the EntryGroup to update.
+        :param entry_group_configuration: Required. The updated configuration body of the EntryGroup.
+        :param location: Required. The ID of the Google Cloud location that the task belongs to.
+        :param update_mask: Optional. Names of fields whose values to overwrite on an entry group.
+            If this parameter is absent or empty, all modifiable fields are overwritten. If such
+            fields are non-required and omitted in the request body, their values are emptied.
+        :param project_id: Optional. The ID of the Google Cloud project that the task belongs to.
+        :param validate_only: Optional. The service validates the request without performing any mutations.
+        :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+        :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+            Note that if `retry` is specified, the timeout applies to each individual attempt.
+        :param metadata: Optional. Additional metadata that is provided to the method.
+        """
+        client = self.get_dataplex_catalog_client()
+        _entry_group = (
+            deepcopy(entry_group_configuration)
+            if isinstance(entry_group_configuration, dict)
+            else EntryGroup.to_dict(entry_group_configuration)
+        )
+        _entry_group["name"] = client.entry_group_path(project_id, location, entry_group_id)
+        return client.update_entry_group(
+            request={
+                "entry_group": _entry_group,
+                "update_mask": FieldMask(paths=update_mask) if type(update_mask) is list else update_mask,
+                "validate_only": validate_only,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
     @GoogleBaseHook.fallback_to_default_project_id
     def create_task(
         self,