apache-airflow-providers-google 14.0.0__py3-none-any.whl → 19.1.0rc1__py3-none-any.whl

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

@@ -19,23 +19,81 @@
 
 from __future__ import annotations
 
+import base64
+import datetime
+import json
+import time
 from collections.abc import Sequence
 from copy import deepcopy
 from typing import TYPE_CHECKING
 
+from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
+from google.auth.transport import requests as google_requests
+from google.cloud.managedkafka_v1 import Cluster, ConsumerGroup, ManagedKafkaClient, Topic, types
+
 from airflow.exceptions import AirflowException
 from airflow.providers.google.common.consts import CLIENT_INFO
 from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
-from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
-from google.cloud.managedkafka_v1 import Cluster, ManagedKafkaClient, Topic, types
 
 if TYPE_CHECKING:
     from google.api_core.operation import Operation
     from google.api_core.retry import Retry
-    from google.cloud.managedkafka_v1.services.managed_kafka.pagers import ListClustersPager, ListTopicsPager
+    from google.auth.credentials import Credentials
+    from google.cloud.managedkafka_v1.services.managed_kafka.pagers import (
+        ListClustersPager,
+        ListConsumerGroupsPager,
+        ListTopicsPager,
+    )
     from google.protobuf.field_mask_pb2 import FieldMask
 
 
+class ManagedKafkaTokenProvider:
+    """Helper for providing authentication token for establishing connection via confluent to Apache Kafka cluster managed by Google Cloud."""
+
+    def __init__(
+        self,
+        credentials: Credentials,
+    ):
+        self._credentials = credentials
+        self._header = json.dumps(dict(typ="JWT", alg="GOOG_OAUTH2_TOKEN"))
+
+    def _valid_credentials(self):
+        if not self._credentials.valid:
+            self._credentials.refresh(google_requests.Request())
+            return self._credentials
+
+    def _get_jwt(self, credentials):
+        return json.dumps(
+            dict(
+                exp=credentials.expiry.timestamp(),
+                iss="Google",
+                iat=datetime.datetime.now(datetime.timezone.utc).timestamp(),
+                scope="kafka",
+                sub=credentials.service_account_email,
+            )
+        )
+
+    def _b64_encode(self, source):
+        return base64.urlsafe_b64encode(source.encode("utf-8")).decode("utf-8").rstrip("=")
+
+    def _get_kafka_access_token(self, credentials):
+        return ".".join(
+            [
+                self._b64_encode(self._header),
+                self._b64_encode(self._get_jwt(credentials)),
+                self._b64_encode(credentials.token),
+            ]
+        )
+
+    def confluent_token(self):
+        credentials = self._valid_credentials()
+
+        utc_expiry = credentials.expiry.replace(tzinfo=datetime.timezone.utc)
+        expiry_seconds = (utc_expiry - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
+
+        return self._get_kafka_access_token(credentials), time.time() + expiry_seconds
+
+
 class ManagedKafkaHook(GoogleBaseHook):
     """Hook for Managed Service for Apache Kafka APIs."""
 
@@ -62,6 +120,12 @@ class ManagedKafkaHook(GoogleBaseHook):
             error = operation.exception(timeout=timeout)
             raise AirflowException(error)
 
+    def get_confluent_token(self, config_str: str):
+        """Get the authentication token for confluent client."""
+        token_provider = ManagedKafkaTokenProvider(credentials=self.get_credentials())
+        token = token_provider.confluent_token()
+        return token
+
     @GoogleBaseHook.fallback_to_default_project_id
     def create_cluster(
         self,
@@ -480,3 +544,163 @@ class ManagedKafkaHook(GoogleBaseHook):
             timeout=timeout,
             metadata=metadata,
         )
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def list_consumer_groups(
+        self,
+        project_id: str,
+        location: str,
+        cluster_id: str,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> ListConsumerGroupsPager:
+        """
+        List the consumer groups in a given cluster.
+
+        :param project_id: Required. The ID of the Google Cloud project that the service belongs to.
+        :param location: Required. The ID of the Google Cloud region that the service belongs to.
+        :param cluster_id: Required. The ID of the cluster whose consumer groups are to be listed.
+        :param page_size: Optional. The maximum number of consumer groups to return. The service may return
+            fewer than this value. If unset or zero, all consumer groups for the parent is returned.
+        :param page_token: Optional. A page token, received from a previous ``ListConsumerGroups`` call.
+            Provide this to retrieve the subsequent page. When paginating, all other parameters provided to
+            ``ListConsumerGroups`` must match the call that provided the page token.
+        :param retry: Designation of what errors, if any, should be retried.
+        :param timeout: The timeout for this request.
+        :param metadata: Strings which should be sent along with the request as metadata.
+        """
+        client = self.get_managed_kafka_client()
+        parent = client.cluster_path(project_id, location, cluster_id)
+
+        result = client.list_consumer_groups(
+            request={
+                "parent": parent,
+                "page_size": page_size,
+                "page_token": page_token,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+        return result
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def get_consumer_group(
+        self,
+        project_id: str,
+        location: str,
+        cluster_id: str,
+        consumer_group_id: str,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> types.ConsumerGroup:
+        """
+        Return the properties of a single consumer group.
+
+        :param project_id: Required. The ID of the Google Cloud project that the service belongs to.
+        :param location: Required. The ID of the Google Cloud region that the service belongs to.
+        :param cluster_id: Required. The ID of the cluster whose consumer group is to be returned.
+        :param consumer_group_id: Required. The ID of the consumer group whose configuration to return.
+        :param retry: Designation of what errors, if any, should be retried.
+        :param timeout: The timeout for this request.
+        :param metadata: Strings which should be sent along with the request as metadata.
+        """
+        client = self.get_managed_kafka_client()
+        name = client.consumer_group_path(project_id, location, cluster_id, consumer_group_id)
+
+        result = client.get_consumer_group(
+            request={
+                "name": name,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+        return result
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def update_consumer_group(
+        self,
+        project_id: str,
+        location: str,
+        cluster_id: str,
+        consumer_group_id: str,
+        consumer_group: types.ConsumerGroup | dict,
+        update_mask: FieldMask | dict,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> types.ConsumerGroup:
+        """
+        Update the properties of a single consumer group.
+
+        :param project_id: Required. The ID of the Google Cloud project that the service belongs to.
+        :param location: Required. The ID of the Google Cloud region that the service belongs to.
+        :param cluster_id: Required. The ID of the cluster whose topic is to be updated.
+        :param consumer_group_id: Required. The ID of the consumer group whose configuration to update.
+        :param consumer_group: Required. The consumer_group to update. Its ``name`` field must be populated.
+        :param update_mask: Required. Field mask is used to specify the fields to be overwritten in the
+            ConsumerGroup resource by the update. The fields specified in the update_mask are relative to the
+            resource, not the full request. A field will be overwritten if it is in the mask.
+        :param retry: Designation of what errors, if any, should be retried.
+        :param timeout: The timeout for this request.
+        :param metadata: Strings which should be sent along with the request as metadata.
+        """
+        client = self.get_managed_kafka_client()
+        _consumer_group = (
+            deepcopy(consumer_group)
+            if isinstance(consumer_group, dict)
+            else ConsumerGroup.to_dict(consumer_group)
+        )
+        _consumer_group["name"] = client.consumer_group_path(
+            project_id, location, cluster_id, consumer_group_id
+        )
+
+        result = client.update_consumer_group(
+            request={
+                "update_mask": update_mask,
+                "consumer_group": _consumer_group,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+        return result
+
+    @GoogleBaseHook.fallback_to_default_project_id
+    def delete_consumer_group(
+        self,
+        project_id: str,
+        location: str,
+        cluster_id: str,
+        consumer_group_id: str,
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+    ) -> None:
+        """
+        Delete a single consumer group.
+
+        :param project_id: Required. The ID of the Google Cloud project that the service belongs to.
+        :param location: Required. The ID of the Google Cloud region that the service belongs to.
+        :param cluster_id: Required. The ID of the cluster whose consumer group is to be deleted.
+        :param consumer_group_id: Required. The ID of the consumer group to delete.
+        :param retry: Designation of what errors, if any, should be retried.
+        :param timeout: The timeout for this request.
+        :param metadata: Strings which should be sent along with the request as metadata.
+        """
+        client = self.get_managed_kafka_client()
+        name = client.consumer_group_path(project_id, location, cluster_id, consumer_group_id)
+
+        client.delete_consumer_group(
+            request={
+                "name": name,
+            },
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )

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

@@ -23,7 +23,8 @@ import contextlib
 import logging
 import random
 import time
-from typing import TYPE_CHECKING, Callable
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 
 from aiohttp import ClientSession
 from gcloud.aio.auth import AioSession, Token
@@ -78,8 +79,7 @@ def _poll_with_exponential_delay(
             if e.resp.status != 429:
                 log.info("Something went wrong. Not retrying: %s", format(e))
                 raise
-            else:
-                time.sleep((2**i) + random.random())
+            time.sleep((2**i) + random.random())
 
     raise ValueError(f"Connection could not be established after {max_n} retries.")
 
@@ -219,12 +219,11 @@ class MLEngineHook(GoogleBaseHook):
             if e.resp.status == 404:
                 self.log.error("Job with job_id %s does not exist. ", job_id)
                 raise
-            elif e.resp.status == 400:
+            if e.resp.status == 400:
                 self.log.info("Job with job_id %s is already complete, cancellation aborted.", job_id)
                 return {}
-            else:
-                self.log.error("Failed to cancel MLEngine job: %s", e)
-                raise
+            self.log.error("Failed to cancel MLEngine job: %s", e)
+            raise
 
     def get_job(self, project_id: str, job_id: str) -> dict:
         """
@@ -589,7 +588,7 @@ class MLEngineAsyncHook(GoogleBaseAsyncHook):
                 job = await self.get_job(
                     project_id=project_id,
                     job_id=job_id,
-                    session=session,  #  type: ignore
+                    session=session,  # type: ignore
                 )
                 job = await job.json(content_type=None)
                 self.log.info("Retrieving json_response: %s", job)

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

@@ -22,8 +22,6 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
-from airflow.providers.google.common.consts import CLIENT_INFO
-from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
 from google.cloud.language_v1 import EncodingType, LanguageServiceClient
 from google.cloud.language_v1.types import (
@@ -37,6 +35,9 @@ from google.cloud.language_v1.types import (
     Document,
 )
 
+from airflow.providers.google.common.consts import CLIENT_INFO
+from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
+
 if TYPE_CHECKING:
     from google.api_core.retry import Retry
 

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

@@ -27,11 +27,12 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
-from airflow.providers.google.common.consts import CLIENT_INFO
-from airflow.providers.google.common.hooks.base_google import PROVIDE_PROJECT_ID, GoogleBaseHook
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
 from google.cloud.oslogin_v1 import ImportSshPublicKeyResponse, OsLoginServiceClient
 
+from airflow.providers.google.common.consts import CLIENT_INFO
+from airflow.providers.google.common.hooks.base_google import PROVIDE_PROJECT_ID, GoogleBaseHook
+
 if TYPE_CHECKING:
     from google.api_core.retry import Retry
 

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

@@ -33,6 +33,12 @@ from functools import cached_property
 from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
+from google.api_core.exceptions import AlreadyExists, GoogleAPICallError
+from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
+from google.cloud.exceptions import NotFound
+from google.cloud.pubsub_v1 import PublisherClient, SubscriberClient
+from google.cloud.pubsub_v1.types import PublisherOptions
+from google.pubsub_v1.services.subscriber.async_client import SubscriberAsyncClient
 from googleapiclient.errors import HttpError
 
 from airflow.exceptions import AirflowProviderDeprecationWarning
@@ -43,12 +49,6 @@ from airflow.providers.google.common.hooks.base_google import (
     GoogleBaseHook,
 )
 from airflow.version import version
-from google.api_core.exceptions import AlreadyExists, GoogleAPICallError
-from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
-from google.cloud.exceptions import NotFound
-from google.cloud.pubsub_v1 import PublisherClient, SubscriberClient
-from google.cloud.pubsub_v1.types import PublisherOptions
-from google.pubsub_v1.services.subscriber.async_client import SubscriberAsyncClient
 
 if TYPE_CHECKING:
     from google.api_core.retry import Retry

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

@@ -23,8 +23,6 @@ from collections.abc import Sequence
 from functools import cached_property
 from typing import TYPE_CHECKING
 
-from airflow.providers.google.common.consts import CLIENT_INFO
-from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
 from google.cloud.secretmanager_v1 import (
     AccessSecretVersionResponse,
@@ -34,6 +32,9 @@ from google.cloud.secretmanager_v1 import (
     SecretVersion,
 )
 
+from airflow.providers.google.common.consts import CLIENT_INFO
+from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
+
 if TYPE_CHECKING:
     from google.api_core.retry import Retry
     from google.cloud.secretmanager_v1.services.secret_manager_service.pagers import ListSecretsPager
@@ -46,6 +47,10 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
     See https://cloud.google.com/secret-manager
     """
 
+    def __init__(self, location: str | None = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.location = location
+
     @cached_property
     def client(self):
         """
@@ -53,7 +58,16 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
 
         :return: Secret Manager client.
         """
-        return SecretManagerServiceClient(credentials=self.get_credentials(), client_info=CLIENT_INFO)
+        if self.location is not None:
+            return SecretManagerServiceClient(
+                credentials=self.get_credentials(),
+                client_info=CLIENT_INFO,
+                client_options={"api_endpoint": f"secretmanager.{self.location}.rep.googleapis.com"},
+            )
+        return SecretManagerServiceClient(
+            credentials=self.get_credentials(),
+            client_info=CLIENT_INFO,
+        )
 
     def get_conn(self) -> SecretManagerServiceClient:
         """
@@ -63,6 +77,60 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         """
         return self.client
 
+    def _get_parent(self, project_id: str, location: str | None = None) -> str:
+        """
+        Return parent path.
+
+        :param project_id: Required. ID of the GCP project that owns the job.
+        :param location: Optional. Target location.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
+
+        :return: Parent path.
+        """
+        _location = location or self.location
+        if _location is not None:
+            return self.client.common_location_path(project_id, _location)
+        return self.client.common_project_path(project_id)
+
+    def _get_secret_path(self, project_id: str, secret_id: str, location: str | None = None) -> str:
+        """
+        Return secret path.
+
+        :param project_id: Required. ID of the GCP project that owns the job.
+        :param secret_id: Required. Secret ID for which path is required.
+        :param location: Optional. Target location.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
+
+        :return: Parent path.
+        """
+        _location = location or self.location
+        if _location is not None:
+            # Google's client library does not provide a method to construct regional secret paths, so constructing manually.
+            return f"projects/{project_id}/locations/{_location}/secrets/{secret_id}"
+        return self.client.secret_path(project_id, secret_id)
+
+    def _get_secret_version_path(
+        self, project_id: str, secret_id: str, secret_version: str, location: str | None = None
+    ) -> str:
+        """
+        Return secret version path.
+
+        :param project_id: Required. ID of the GCP project that owns the job.
+        :param secret_id: Required. Secret ID for which path is required.
+        :param secret_version: Required. Secret version for which path is required.
+        :param location: Optional. Target location.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
+
+        :return: Parent path.
+        """
+        _location = location or self.location
+        if _location is not None:
+            # Google's client library does not provide a method to construct regional secret version paths, so constructing manually.
+            return (
+                f"projects/{project_id}/locations/{_location}/secrets/{secret_id}/versions/{secret_version}"
+            )
+        return self.client.secret_version_path(project_id, secret_id, secret_version)
+
     @GoogleBaseHook.fallback_to_default_project_id
     def create_secret(
         self,
@@ -72,6 +140,7 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         retry: Retry | _MethodDefault = DEFAULT,
         timeout: float | None = None,
         metadata: Sequence[tuple[str, str]] = (),
+        location: str | None = None,
     ) -> Secret:
         """
         Create a secret.
@@ -87,12 +156,20 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         :param retry: Optional. Designation of what errors, if any, should be retried.
         :param timeout: Optional. The timeout for this request.
         :param metadata: Optional. Strings which should be sent along with the request as metadata.
+        :param location: Optional. Location where secret should be created. Used for creating regional secret.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
         :return: Secret object.
         """
-        _secret = secret or {"replication": {"automatic": {}}}
+        if not secret:
+            _secret: dict | Secret = {}
+            if (location or self.location) is None:
+                _secret["replication"] = {"automatic": {}}
+        else:
+            _secret = secret
+
         response = self.client.create_secret(
             request={
-                "parent": f"projects/{project_id}",
+                "parent": self._get_parent(project_id, location),
                 "secret_id": secret_id,
                 "secret": _secret,
             },
@@ -112,6 +189,7 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         retry: Retry | _MethodDefault = DEFAULT,
         timeout: float | None = None,
         metadata: Sequence[tuple[str, str]] = (),
+        location: str | None = None,
     ) -> SecretVersion:
         """
         Add a version to the secret.
@@ -127,11 +205,13 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         :param retry: Optional. Designation of what errors, if any, should be retried.
         :param timeout: Optional. The timeout for this request.
         :param metadata: Optional. Strings which should be sent along with the request as metadata.
+        :param location: Optional. Location where secret is located. Used for adding version to regional secret.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
         :return: Secret version object.
         """
         response = self.client.add_secret_version(
             request={
-                "parent": f"projects/{project_id}/secrets/{secret_id}",
+                "parent": self._get_secret_path(project_id, secret_id, location),
                 "payload": secret_payload,
             },
             retry=retry,
@@ -151,6 +231,7 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         retry: Retry | _MethodDefault = DEFAULT,
         timeout: float | None = None,
         metadata: Sequence[tuple[str, str]] = (),
+        location: str | None = None,
     ) -> ListSecretsPager:
         """
         List secrets.
@@ -167,11 +248,13 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         :param retry: Optional. Designation of what errors, if any, should be retried.
         :param timeout: Optional. The timeout for this request.
         :param metadata: Optional. Strings which should be sent along with the request as metadata.
+        :param location: Optional. The regional secrets stored in the provided location will be listed.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
         :return: Secret List object.
         """
         response = self.client.list_secrets(
             request={
-                "parent": f"projects/{project_id}",
+                "parent": self._get_parent(project_id, location),
                 "page_size": page_size,
                 "page_token": page_token,
                 "filter": secret_filter,
@@ -184,18 +267,22 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         return response
 
     @GoogleBaseHook.fallback_to_default_project_id
-    def secret_exists(self, project_id: str, secret_id: str) -> bool:
+    def secret_exists(self, project_id: str, secret_id: str, location: str | None = None) -> bool:
         """
         Check whether secret exists.
 
         :param project_id: Required. ID of the GCP project that owns the job.
             If set to ``None`` or missing, the default project_id from the GCP connection is used.
         :param secret_id: Required. ID of the secret to find.
+        :param location: Optional. Location where secret is expected to be stored regionally.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
         :return: True if the secret exists, False otherwise.
         """
         secret_filter = f"name:{secret_id}"
-        secret_name = self.client.secret_path(project_id, secret_id)
-        for secret in self.list_secrets(project_id=project_id, page_size=100, secret_filter=secret_filter):
+        secret_name = self._get_secret_path(project_id, secret_id, location)
+        for secret in self.list_secrets(
+            project_id=project_id, page_size=100, secret_filter=secret_filter, location=location
+        ):
             if secret.name.split("/")[-1] == secret_id:
                 self.log.info("Secret %s exists.", secret_name)
                 return True
@@ -211,6 +298,7 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         retry: Retry | _MethodDefault = DEFAULT,
         timeout: float | None = None,
         metadata: Sequence[tuple[str, str]] = (),
+        location: str | None = None,
     ) -> AccessSecretVersionResponse:
         """
         Access a secret version.
@@ -226,11 +314,13 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         :param retry: Optional. Designation of what errors, if any, should be retried.
         :param timeout: Optional. The timeout for this request.
         :param metadata: Optional. Strings which should be sent along with the request as metadata.
+        :param location: Optional. Location where secret is stored regionally.  If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used
+            For more details : https://cloud.google.com/secret-manager/docs/locations
         :return: Access secret version response object.
         """
         response = self.client.access_secret_version(
             request={
-                "name": self.client.secret_version_path(project_id, secret_id, secret_version),
+                "name": self._get_secret_version_path(project_id, secret_id, secret_version, location),
             },
             retry=retry,
             timeout=timeout,
@@ -247,6 +337,7 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         retry: Retry | _MethodDefault = DEFAULT,
         timeout: float | None = None,
         metadata: Sequence[tuple[str, str]] = (),
+        location: str | None = None,
     ) -> None:
         """
         Delete a secret.
@@ -261,9 +352,11 @@ class GoogleCloudSecretManagerHook(GoogleBaseHook):
         :param retry: Optional. Designation of what errors, if any, should be retried.
         :param timeout: Optional. The timeout for this request.
         :param metadata: Optional. Strings which should be sent along with the request as metadata.
+        :param location: Optional. Location where secret is stored regionally. If set to ``None`` or missing, the location provided for GoogleCloudSecretHook instantiation is used.
+            For more details : https://cloud.google.com/secret-manager/docs/locations
         :return: Access secret version response object.
         """
-        name = self.client.secret_path(project_id, secret_id)
+        name = self._get_secret_path(project_id, secret_id, location)
         self.client.delete_secret(
             request={"name": name},
             retry=retry,