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

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

@@ -21,25 +21,28 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 from functools import cached_property
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
+
+from google.api_core.exceptions import AlreadyExists, NotFound
+from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
+from google.cloud.managedkafka_v1 import types
 
 from airflow.exceptions import AirflowException
 from airflow.providers.google.cloud.hooks.managed_kafka import ManagedKafkaHook
 from airflow.providers.google.cloud.links.managed_kafka import (
     ApacheKafkaClusterLink,
     ApacheKafkaClusterListLink,
+    ApacheKafkaConsumerGroupLink,
     ApacheKafkaTopicLink,
 )
 from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
-from google.api_core.exceptions import AlreadyExists, NotFound
-from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
-from google.cloud.managedkafka_v1 import types
 
 if TYPE_CHECKING:
-    from airflow.utils.context import Context
     from google.api_core.retry import Retry
     from google.protobuf.field_mask_pb2 import FieldMask
 
+    from airflow.providers.common.compat.sdk import Context
+
 
 class ManagedKafkaBaseOperator(GoogleCloudBaseOperator):
     """
@@ -147,9 +150,17 @@ class ManagedKafkaCreateClusterOperator(ManagedKafkaBaseOperator):
         self.cluster_id = cluster_id
         self.request_id = request_id
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
         self.log.info("Creating an Apache Kafka cluster.")
-        ApacheKafkaClusterLink.persist(context=context, task_instance=self, cluster_id=self.cluster_id)
+        ApacheKafkaClusterLink.persist(context=context)
         try:
             operation = self.hook.create_cluster(
                 project_id=self.project_id,
@@ -224,8 +235,14 @@ class ManagedKafkaListClustersOperator(ManagedKafkaBaseOperator):
         self.filter = filter
         self.order_by = order_by
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
-        ApacheKafkaClusterListLink.persist(context=context, task_instance=self)
+        ApacheKafkaClusterListLink.persist(context=context)
         self.log.info("Listing Clusters from location %s.", self.location)
         try:
             cluster_list_pager = self.hook.list_clusters(
@@ -239,8 +256,7 @@ class ManagedKafkaListClustersOperator(ManagedKafkaBaseOperator):
                 timeout=self.timeout,
                 metadata=self.metadata,
             )
-            self.xcom_push(
-                context=context,
+            context["ti"].xcom_push(
                 key="cluster_page",
                 value=types.ListClustersResponse.to_dict(cluster_list_pager._response),
             )
@@ -282,12 +298,16 @@ class ManagedKafkaGetClusterOperator(ManagedKafkaBaseOperator):
         super().__init__(*args, **kwargs)
         self.cluster_id = cluster_id
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
-        ApacheKafkaClusterLink.persist(
-            context=context,
-            task_instance=self,
-            cluster_id=self.cluster_id,
-        )
+        ApacheKafkaClusterLink.persist(context=context)
         self.log.info("Getting Cluster: %s", self.cluster_id)
         try:
             cluster = self.hook.get_cluster(
@@ -359,12 +379,16 @@ class ManagedKafkaUpdateClusterOperator(ManagedKafkaBaseOperator):
         self.update_mask = update_mask
         self.request_id = request_id
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
-        ApacheKafkaClusterLink.persist(
-            context=context,
-            task_instance=self,
-            cluster_id=self.cluster_id,
-        )
+        ApacheKafkaClusterLink.persist(context=context)
         self.log.info("Updating an Apache Kafka cluster.")
         try:
             operation = self.hook.update_cluster(
@@ -494,14 +518,18 @@ class ManagedKafkaCreateTopicOperator(ManagedKafkaBaseOperator):
         self.topic_id = topic_id
         self.topic = topic
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "topic_id": self.topic_id,
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
         self.log.info("Creating an Apache Kafka topic.")
-        ApacheKafkaTopicLink.persist(
-            context=context,
-            task_instance=self,
-            cluster_id=self.cluster_id,
-            topic_id=self.topic_id,
-        )
+        ApacheKafkaTopicLink.persist(context=context)
         try:
             topic_obj = self.hook.create_topic(
                 project_id=self.project_id,
@@ -571,8 +599,16 @@ class ManagedKafkaListTopicsOperator(ManagedKafkaBaseOperator):
         self.page_size = page_size
         self.page_token = page_token
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
-        ApacheKafkaClusterLink.persist(context=context, task_instance=self, cluster_id=self.cluster_id)
+        ApacheKafkaClusterLink.persist(context=context)
         self.log.info("Listing Topics for cluster %s.", self.cluster_id)
         try:
             topic_list_pager = self.hook.list_topics(
@@ -585,8 +621,7 @@ class ManagedKafkaListTopicsOperator(ManagedKafkaBaseOperator):
                 timeout=self.timeout,
                 metadata=self.metadata,
             )
-            self.xcom_push(
-                context=context,
+            context["ti"].xcom_push(
                 key="topic_page",
                 value=types.ListTopicsResponse.to_dict(topic_list_pager._response),
             )
@@ -633,13 +668,17 @@ class ManagedKafkaGetTopicOperator(ManagedKafkaBaseOperator):
         self.cluster_id = cluster_id
         self.topic_id = topic_id
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "topic_id": self.topic_id,
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
-        ApacheKafkaTopicLink.persist(
-            context=context,
-            task_instance=self,
-            cluster_id=self.cluster_id,
-            topic_id=self.topic_id,
-        )
+        ApacheKafkaTopicLink.persist(context=context)
         self.log.info("Getting Topic: %s", self.topic_id)
         try:
             topic = self.hook.get_topic(
@@ -704,13 +743,17 @@ class ManagedKafkaUpdateTopicOperator(ManagedKafkaBaseOperator):
         self.topic = topic
         self.update_mask = update_mask
 
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "topic_id": self.topic_id,
+            "project_id": self.project_id,
+        }
+
     def execute(self, context: Context):
-        ApacheKafkaTopicLink.persist(
-            context=context,
-            task_instance=self,
-            cluster_id=self.cluster_id,
-            topic_id=self.topic_id,
-        )
+        ApacheKafkaTopicLink.persist(context=context)
         self.log.info("Updating an Apache Kafka topic.")
         try:
             topic_obj = self.hook.update_topic(
@@ -786,3 +829,282 @@ class ManagedKafkaDeleteTopicOperator(ManagedKafkaBaseOperator):
         except NotFound as not_found_err:
             self.log.info("The Apache Kafka topic ID %s does not exist.", self.topic_id)
             raise AirflowException(not_found_err)
+
+
+class ManagedKafkaListConsumerGroupsOperator(ManagedKafkaBaseOperator):
+    """
+    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.
+    :param gcp_conn_id: The connection ID to use connecting to Google Cloud.
+    :param impersonation_chain: Optional service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple({"cluster_id"} | set(ManagedKafkaBaseOperator.template_fields))
+    operator_extra_links = (ApacheKafkaClusterLink(),)
+
+    def __init__(
+        self,
+        cluster_id: str,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.cluster_id = cluster_id
+        self.page_size = page_size
+        self.page_token = page_token
+
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "project_id": self.project_id,
+        }
+
+    def execute(self, context: Context):
+        ApacheKafkaClusterLink.persist(context=context)
+        self.log.info("Listing Consumer Groups for cluster %s.", self.cluster_id)
+        try:
+            consumer_group_list_pager = self.hook.list_consumer_groups(
+                project_id=self.project_id,
+                location=self.location,
+                cluster_id=self.cluster_id,
+                page_size=self.page_size,
+                page_token=self.page_token,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            context["ti"].xcom_push(
+                key="consumer_group_page",
+                value=types.ListConsumerGroupsResponse.to_dict(consumer_group_list_pager._response),
+            )
+        except Exception as error:
+            raise AirflowException(error)
+        return [types.ConsumerGroup.to_dict(consumer_group) for consumer_group in consumer_group_list_pager]
+
+
+class ManagedKafkaGetConsumerGroupOperator(ManagedKafkaBaseOperator):
+    """
+    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.
+    :param gcp_conn_id: The connection ID to use connecting to Google Cloud.
+    :param impersonation_chain: Optional service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"cluster_id", "consumer_group_id"} | set(ManagedKafkaBaseOperator.template_fields)
+    )
+    operator_extra_links = (ApacheKafkaConsumerGroupLink(),)
+
+    def __init__(
+        self,
+        cluster_id: str,
+        consumer_group_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.cluster_id = cluster_id
+        self.consumer_group_id = consumer_group_id
+
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "consumer_group_id": self.consumer_group_id,
+            "project_id": self.project_id,
+        }
+
+    def execute(self, context: Context):
+        ApacheKafkaConsumerGroupLink.persist(context=context)
+        self.log.info("Getting Consumer Group: %s", self.consumer_group_id)
+        try:
+            consumer_group = self.hook.get_consumer_group(
+                project_id=self.project_id,
+                location=self.location,
+                cluster_id=self.cluster_id,
+                consumer_group_id=self.consumer_group_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info(
+                "The consumer group %s from cluster %s was retrieved.",
+                self.consumer_group_id,
+                self.cluster_id,
+            )
+            return types.ConsumerGroup.to_dict(consumer_group)
+        except NotFound as not_found_err:
+            self.log.info("The Consumer Group %s does not exist.", self.consumer_group_id)
+            raise AirflowException(not_found_err)
+
+
+class ManagedKafkaUpdateConsumerGroupOperator(ManagedKafkaBaseOperator):
+    """
+    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.
+    :param gcp_conn_id: The connection ID to use connecting to Google Cloud.
+    :param impersonation_chain: Optional service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"cluster_id", "consumer_group_id", "consumer_group", "update_mask"}
+        | set(ManagedKafkaBaseOperator.template_fields)
+    )
+    operator_extra_links = (ApacheKafkaConsumerGroupLink(),)
+
+    def __init__(
+        self,
+        cluster_id: str,
+        consumer_group_id: str,
+        consumer_group: types.Topic | dict,
+        update_mask: FieldMask | dict,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.cluster_id = cluster_id
+        self.consumer_group_id = consumer_group_id
+        self.consumer_group = consumer_group
+        self.update_mask = update_mask
+
+    @property
+    def extra_links_params(self) -> dict[str, Any]:
+        return {
+            "location": self.location,
+            "cluster_id": self.cluster_id,
+            "consumer_group_id": self.consumer_group_id,
+            "project_id": self.project_id,
+        }
+
+    def execute(self, context: Context):
+        ApacheKafkaConsumerGroupLink.persist(context=context)
+        self.log.info("Updating an Apache Kafka consumer group.")
+        try:
+            consumer_group_obj = self.hook.update_consumer_group(
+                project_id=self.project_id,
+                location=self.location,
+                cluster_id=self.cluster_id,
+                consumer_group_id=self.consumer_group_id,
+                consumer_group=self.consumer_group,
+                update_mask=self.update_mask,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info("Apache Kafka consumer group %s was updated.", self.consumer_group_id)
+            return types.ConsumerGroup.to_dict(consumer_group_obj)
+        except NotFound as not_found_err:
+            self.log.info("The Consumer Group %s does not exist.", self.consumer_group_id)
+            raise AirflowException(not_found_err)
+        except Exception as error:
+            raise AirflowException(error)
+
+
+class ManagedKafkaDeleteConsumerGroupOperator(ManagedKafkaBaseOperator):
+    """
+    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.
+    :param gcp_conn_id: The connection ID to use connecting to Google Cloud.
+    :param impersonation_chain: Optional service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"cluster_id", "consumer_group_id"} | set(ManagedKafkaBaseOperator.template_fields)
+    )
+
+    def __init__(
+        self,
+        cluster_id: str,
+        consumer_group_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.cluster_id = cluster_id
+        self.consumer_group_id = consumer_group_id
+
+    def execute(self, context: Context):
+        try:
+            self.log.info("Deleting Apache Kafka consumer group: %s", self.consumer_group_id)
+            self.hook.delete_consumer_group(
+                project_id=self.project_id,
+                location=self.location,
+                cluster_id=self.cluster_id,
+                consumer_group_id=self.consumer_group_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info("Apache Kafka consumer group was deleted.")
+        except NotFound as not_found_err:
+            self.log.info("The Apache Kafka consumer group ID %s does not exist.", self.consumer_group_id)
+            raise AirflowException(not_found_err)

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

@@ -22,16 +22,18 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
-from airflow.providers.google.cloud.hooks.natural_language import CloudNaturalLanguageHook
-from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
 from google.protobuf.json_format import MessageToDict
 
+from airflow.providers.google.cloud.hooks.natural_language import CloudNaturalLanguageHook
+from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
+
 if TYPE_CHECKING:
-    from airflow.utils.context import Context
     from google.api_core.retry import Retry
     from google.cloud.language_v1.types import Document, EncodingType
 
+    from airflow.providers.common.compat.sdk import Context
+
 
 MetaData = Sequence[tuple[str, str]]
 

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

@@ -25,16 +25,10 @@ This module contains Google PubSub operators.
 
 from __future__ import annotations
 
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Callable
+from collections.abc import Callable, Sequence
+from functools import cached_property
+from typing import TYPE_CHECKING, Any
 
-from airflow.exceptions import AirflowException
-from airflow.providers.google.cloud.hooks.pubsub import PubSubHook
-from airflow.providers.google.cloud.links.pubsub import PubSubSubscriptionLink, PubSubTopicLink
-from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
-from airflow.providers.google.cloud.triggers.pubsub import PubsubPullTrigger
-from airflow.providers.google.common.consts import GOOGLE_DEFAULT_DEFERRABLE_METHOD_NAME
-from airflow.providers.google.common.hooks.base_google import PROVIDE_PROJECT_ID
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
 from google.cloud.pubsub_v1.types import (
     DeadLetterPolicy,
@@ -47,10 +41,21 @@ from google.cloud.pubsub_v1.types import (
     SchemaSettings,
 )
 
+from airflow.configuration import conf
+from airflow.exceptions import AirflowException
+from airflow.providers.google.cloud.hooks.pubsub import PubSubHook
+from airflow.providers.google.cloud.links.pubsub import PubSubSubscriptionLink, PubSubTopicLink
+from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
+from airflow.providers.google.cloud.triggers.pubsub import PubsubPullTrigger
+from airflow.providers.google.common.consts import GOOGLE_DEFAULT_DEFERRABLE_METHOD_NAME
+from airflow.providers.google.common.hooks.base_google import PROVIDE_PROJECT_ID
+
 if TYPE_CHECKING:
-    from airflow.utils.context import Context
     from google.api_core.retry import Retry
 
+    from airflow.providers.common.compat.sdk import Context
+    from airflow.providers.openlineage.extractors import OperatorLineage
+
 
 class PubSubCreateTopicOperator(GoogleCloudBaseOperator):
     """
@@ -180,7 +185,6 @@ class PubSubCreateTopicOperator(GoogleCloudBaseOperator):
         self.log.info("Created topic %s", self.topic)
         PubSubTopicLink.persist(
             context=context,
-            task_instance=self,
             topic_id=self.topic,
             project_id=self.project_id or hook.project_id,
         )
@@ -357,15 +361,18 @@ class PubSubCreateSubscriptionOperator(GoogleCloudBaseOperator):
         self.timeout = timeout
         self.metadata = metadata
         self.impersonation_chain = impersonation_chain
+        self._resolved_subscription_name: str | None = None
 
-    def execute(self, context: Context) -> str:
-        hook = PubSubHook(
+    @cached_property
+    def pubsub_hook(self):
+        return PubSubHook(
             gcp_conn_id=self.gcp_conn_id,
             impersonation_chain=self.impersonation_chain,
         )
 
+    def execute(self, context: Context) -> str:
         self.log.info("Creating subscription for topic %s", self.topic)
-        result = hook.create_subscription(
+        result = self.pubsub_hook.create_subscription(
             project_id=self.project_id,
             topic=self.topic,
             subscription=self.subscription,
@@ -387,14 +394,34 @@ class PubSubCreateSubscriptionOperator(GoogleCloudBaseOperator):
         )
 
         self.log.info("Created subscription for topic %s", self.topic)
+
+        # Store resolved subscription for Open Lineage
+        self._resolved_subscription_name = self.subscription or result
+
         PubSubSubscriptionLink.persist(
             context=context,
-            task_instance=self,
-            subscription_id=self.subscription or result,  # result returns subscription name
-            project_id=self.project_id or hook.project_id,
+            subscription_id=self._resolved_subscription_name,  # result returns subscription name
+            project_id=self.project_id or self.pubsub_hook.project_id,
         )
         return result
 
+    def get_openlineage_facets_on_complete(self, _) -> OperatorLineage:
+        from airflow.providers.common.compat.openlineage.facet import Dataset
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        topic_project_id = self.project_id or self.pubsub_hook.project_id
+        subscription_project_id = self.subscription_project_id or topic_project_id
+
+        return OperatorLineage(
+            inputs=[Dataset(namespace="pubsub", name=f"topic:{topic_project_id}:{self.topic}")],
+            outputs=[
+                Dataset(
+                    namespace="pubsub",
+                    name=f"subscription:{subscription_project_id}:{self._resolved_subscription_name}",
+                )
+            ],
+        )
+
 
 class PubSubDeleteTopicOperator(GoogleCloudBaseOperator):
     """
@@ -691,17 +718,28 @@ class PubSubPublishMessageOperator(GoogleCloudBaseOperator):
         self.enable_message_ordering = enable_message_ordering
         self.impersonation_chain = impersonation_chain
 
-    def execute(self, context: Context) -> None:
-        hook = PubSubHook(
+    @cached_property
+    def pubsub_hook(self):
+        return PubSubHook(
             gcp_conn_id=self.gcp_conn_id,
             impersonation_chain=self.impersonation_chain,
             enable_message_ordering=self.enable_message_ordering,
         )
 
+    def execute(self, context: Context) -> None:
         self.log.info("Publishing to topic %s", self.topic)
-        hook.publish(project_id=self.project_id, topic=self.topic, messages=self.messages)
+        self.pubsub_hook.publish(project_id=self.project_id, topic=self.topic, messages=self.messages)
         self.log.info("Published to topic %s", self.topic)
 
+    def get_openlineage_facets_on_complete(self, _) -> OperatorLineage:
+        from airflow.providers.common.compat.openlineage.facet import Dataset
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        project_id = self.project_id or self.pubsub_hook.project_id
+        output_dataset = [Dataset(namespace="pubsub", name=f"topic:{project_id}:{self.topic}")]
+
+        return OperatorLineage(outputs=output_dataset)
+
 
 class PubSubPullOperator(GoogleCloudBaseOperator):
     """
@@ -768,7 +806,7 @@ class PubSubPullOperator(GoogleCloudBaseOperator):
         messages_callback: Callable[[list[ReceivedMessage], Context], Any] | None = None,
         gcp_conn_id: str = "google_cloud_default",
         impersonation_chain: str | Sequence[str] | None = None,
-        deferrable: bool = False,
+        deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         poll_interval: int = 300,
         **kwargs,
     ) -> None:
@@ -852,3 +890,13 @@ class PubSubPullOperator(GoogleCloudBaseOperator):
         messages_json = [ReceivedMessage.to_dict(m) for m in pulled_messages]
 
         return messages_json
+
+    def get_openlineage_facets_on_complete(self, _) -> OperatorLineage:
+        from airflow.providers.common.compat.openlineage.facet import Dataset
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        output_dataset = [
+            Dataset(namespace="pubsub", name=f"subscription:{self.project_id}:{self.subscription}")
+        ]
+
+        return OperatorLineage(outputs=output_dataset)