class SubscriberClient(SubscriberClientInterface, ConstructableFromServiceAccount):
"""
A SubscriberClient reads messages similar to Google Pub/Sub.
Any subscribe failures are unlikely to succeed if retried.
Must be used in a `with` block or have __enter__() called before use.
"""
_impl: SubscriberClientInterface
_require_started: RequireStarted
def __init__(
self,
executor: Optional[ThreadPoolExecutor] = None,
nack_handler: Optional[NackHandler] = None,
message_transformer: Optional[MessageTransformer] = None,
credentials: Optional[Credentials] = None,
transport: str = "grpc_asyncio",
client_options: Optional[ClientOptions] = None,
):
"""
Create a new SubscriberClient.
Args:
executor: A ThreadPoolExecutor to use. The client will shut it down on __exit__. If provided a single threaded executor, messages will be ordered per-partition, but take care that the callback does not block for too long as it will impede forward progress on all subscriptions.
nack_handler: A handler for when `nack()` is called. The default NackHandler raises an exception and fails the subscribe stream.
message_transformer: A transformer from Pub/Sub Lite messages to Cloud Pub/Sub messages. This may not return a message with "message_id" set.
credentials: If provided, the credentials to use when connecting.
transport: The transport to use. Must correspond to an asyncio transport.
client_options: The client options to use when connecting. If used, must explicitly set `api_endpoint`.
"""
if executor is None:
executor = ThreadPoolExecutor()
self._impl = MultiplexedSubscriberClient(
executor,
lambda subscription, partitions, settings: make_async_subscriber(
subscription=subscription,
transport=transport,
per_partition_flow_control_settings=settings,
nack_handler=nack_handler,
message_transformer=message_transformer,
fixed_partitions=partitions,
credentials=credentials,
client_options=client_options,
),
)
self._require_started = RequireStarted()
@overrides
def subscribe(
self,
subscription: Union[SubscriptionPath, str],
callback: MessageCallback,
per_partition_flow_control_settings: FlowControlSettings,
fixed_partitions: Optional[Set[Partition]] = None,
) -> StreamingPullFuture:
self._require_started.require_started()
return self._impl.subscribe(
subscription,
callback,
per_partition_flow_control_settings,
fixed_partitions,
)
@overrides
def __enter__(self):
self._require_started.__enter__()
self._impl.__enter__()
return self
@overrides
def __exit__(self, exc_type, exc_value, traceback):
self._impl.__exit__(exc_type, exc_value, traceback)
self._require_started.__exit__(exc_type, exc_value, traceback)
class PublisherClient(PublisherClientInterface,
ConstructableFromServiceAccount):
"""
A PublisherClient publishes messages similar to Google Pub/Sub.
Any publish failures are unlikely to succeed if retried.
Must be used in a `with` block or have __enter__() called before use.
"""
_impl: PublisherClientInterface
_require_stared: RequireStarted
DEFAULT_BATCHING_SETTINGS = WIRE_DEFAULT_BATCHING
"""
The default batching settings for a publisher client.
"""
def __init__(
self,
per_partition_batching_settings: Optional[BatchSettings] = None,
credentials: Optional[Credentials] = None,
transport: str = "grpc_asyncio",
client_options: Optional[ClientOptions] = None,
):
"""
Create a new PublisherClient.
Args:
per_partition_batching_settings: The settings for publish batching. Apply on a per-partition basis.
credentials: If provided, the credentials to use when connecting.
transport: The transport to use. Must correspond to an asyncio transport.
client_options: The client options to use when connecting. If used, must explicitly set `api_endpoint`.
"""
self._impl = MultiplexedPublisherClient(lambda topic: make_publisher(
topic=topic,
per_partition_batching_settings=per_partition_batching_settings,
credentials=credentials,
client_options=client_options,
transport=transport,
))
self._require_stared = RequireStarted()
@overrides
def publish(self,
topic: Union[TopicPath, str],
data: bytes,
ordering_key: str = "",
**attrs: Mapping[str, str]) -> "Future[str]":
self._require_stared.require_started()
return self._impl.publish(topic=topic,
data=data,
ordering_key=ordering_key,
**attrs)
@overrides
def __enter__(self):
self._require_stared.__enter__()
self._impl.__enter__()
return self
@overrides
def __exit__(self, exc_type, exc_value, traceback):
self._impl.__exit__(exc_type, exc_value, traceback)
self._require_stared.__exit__(exc_type, exc_value, traceback)
class AsyncSubscriberClient(
AsyncSubscriberClientInterface, ConstructableFromServiceAccount
):
"""
An AsyncSubscriberClient reads messages similar to Google Pub/Sub, but must be used in an
async context.
Any subscribe failures are unlikely to succeed if retried.
Must be used in an `async with` block or have __aenter__() awaited before use.
"""
_impl: AsyncSubscriberClientInterface
_require_started: RequireStarted
def __init__(
self,
nack_handler: Optional[NackHandler] = None,
message_transformer: Optional[MessageTransformer] = None,
credentials: Optional[Credentials] = None,
transport: str = "grpc_asyncio",
client_options: Optional[ClientOptions] = None,
):
"""
Create a new AsyncSubscriberClient.
Args:
nack_handler: A handler for when `nack()` is called. The default NackHandler raises an exception and fails the subscribe stream.
message_transformer: A transformer from Pub/Sub Lite messages to Cloud Pub/Sub messages. This may not return a message with "message_id" set.
credentials: If provided, the credentials to use when connecting.
transport: The transport to use. Must correspond to an asyncio transport.
client_options: The client options to use when connecting. If used, must explicitly set `api_endpoint`.
"""
self._impl = MultiplexedAsyncSubscriberClient(
lambda subscription, partitions, settings: make_async_subscriber(
subscription=subscription,
transport=transport,
per_partition_flow_control_settings=settings,
nack_handler=nack_handler,
message_transformer=message_transformer,
fixed_partitions=partitions,
credentials=credentials,
client_options=client_options,
)
)
self._require_started = RequireStarted()
@overrides
async def subscribe(
self,
subscription: Union[SubscriptionPath, str],
per_partition_flow_control_settings: FlowControlSettings,
fixed_partitions: Optional[Set[Partition]] = None,
) -> AsyncIterator[Message]:
self._require_started.require_started()
return await self._impl.subscribe(
subscription, per_partition_flow_control_settings, fixed_partitions
)
@overrides
async def __aenter__(self):
self._require_started.__enter__()
await self._impl.__aenter__()
return self
@overrides
async def __aexit__(self, exc_type, exc_value, traceback):
await self._impl.__aexit__(exc_type, exc_value, traceback)
self._require_started.__exit__(exc_type, exc_value, traceback)