dapr-dev 1.17.0.dev76__tar.gz → 1.17.0.dev77__tar.gz

{dapr_dev-1.17.0.dev76/dapr_dev.egg-info → dapr_dev-1.17.0.dev77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dapr-dev
-Version: 1.17.0.dev76
+Version: 1.17.0.dev77
 Summary: The developmental release for Dapr Python SDK.
 Home-page: https://dapr.io/
 Author: Dapr Authors

{dapr_dev-1.17.0.dev76 → dapr_dev-1.17.0.dev77}/dapr/aio/clients/grpc/client.py

@@ -27,6 +27,7 @@ import grpc.aio  # type: ignore
 from google.protobuf.any_pb2 import Any as GrpcAny
 from google.protobuf.empty_pb2 import Empty as GrpcEmpty
 from google.protobuf.message import Message as GrpcMessage
+from grpc import StatusCode  # type: ignore
 from grpc.aio import (  # type: ignore
     AioRpcError,
     StreamStreamClientInterceptor,
@@ -69,6 +70,8 @@ from dapr.clients.grpc._request import (
 )
 from dapr.clients.grpc._response import (
     BindingResponse,
+    BulkPublishResponse,
+    BulkPublishResponseFailedEntry,
     BulkStateItem,
     BulkStatesResponse,
     ConfigurationResponse,
@@ -484,6 +487,96 @@ class DaprGrpcClientAsync:
 
         return DaprResponse(await call.initial_metadata())
 
+    async def publish_events(
+        self,
+        pubsub_name: str,
+        topic_name: str,
+        data: Sequence[Union[bytes, str]],
+        publish_metadata: Dict[str, str] = {},
+        data_content_type: Optional[str] = None,
+    ) -> BulkPublishResponse:
+        """Bulk publish multiple events to a given topic.
+        This publishes multiple events to a specified topic and pubsub component.
+        Each event can be bytes or str. The str data is encoded into bytes with
+        default charset of utf-8.
+
+        The example publishes multiple string events to a topic:
+
+            from dapr.aio.clients import DaprClient
+            async with DaprClient() as d:
+                resp = await d.publish_events(
+                    pubsub_name='pubsub_1',
+                    topic_name='TOPIC_A',
+                    data=['message1', 'message2', 'message3'],
+                    data_content_type='text/plain',
+                )
+                # resp.failed_entries includes any entries that failed to publish.
+
+        Args:
+            pubsub_name (str): the name of the pubsub component
+            topic_name (str): the topic name to publish to
+            data (Sequence[Union[bytes, str]]): sequence of events to publish;
+                each event must be bytes or str
+            publish_metadata (Dict[str, str], optional): Dapr metadata for the
+                bulk publish request
+            data_content_type (str, optional): content type of the event data
+
+        Returns:
+            :class:`BulkPublishResponse` with any failed entries
+        """
+        entries = []
+        for event in data:
+            entry_id = str(uuid.uuid4())
+            if isinstance(event, bytes):
+                event_data = event
+                content_type = data_content_type or 'application/octet-stream'
+            elif isinstance(event, str):
+                event_data = event.encode('utf-8')
+                content_type = data_content_type or 'text/plain'
+            else:
+                raise ValueError(f'invalid type for event {type(event)}')
+
+            entries.append(
+                api_v1.BulkPublishRequestEntry(
+                    entry_id=entry_id,
+                    event=event_data,
+                    content_type=content_type,
+                )
+            )
+
+        req = api_v1.BulkPublishRequest(
+            pubsub_name=pubsub_name,
+            topic=topic_name,
+            entries=entries,
+            metadata=publish_metadata,
+        )
+
+        try:
+            call = self._stub.BulkPublishEvent(req)
+            response = await call
+        except AioRpcError as err:
+            if err.code() == StatusCode.UNIMPLEMENTED:
+                try:
+                    call = self._stub.BulkPublishEventAlpha1(req)
+                    response = await call
+                except AioRpcError as err2:
+                    raise DaprGrpcError(err2) from err2
+            else:
+                raise DaprGrpcError(err) from err
+
+        failed_entries = [
+            BulkPublishResponseFailedEntry(
+                entry_id=entry.entry_id,
+                error=entry.error,
+            )
+            for entry in response.failedEntries
+        ]
+
+        return BulkPublishResponse(
+            failed_entries=failed_entries,
+            headers=await call.initial_metadata(),
+        )
+
     async def subscribe(
         self,
         pubsub_name: str,

{dapr_dev-1.17.0.dev76 → dapr_dev-1.17.0.dev77}/dapr/clients/grpc/_response.py

@@ -723,6 +723,64 @@ class ConfigurationWatcher:
             pass
 
 
+class BulkPublishResponseFailedEntry:
+    """A failed entry from the bulk publish response.
+
+    Attributes:
+        entry_id (str): the entry ID that failed.
+        error (str): the error message for the failure.
+    """
+
+    def __init__(self, entry_id: str, error: str):
+        """Initializes BulkPublishResponseFailedEntry.
+
+        Args:
+            entry_id (str): the entry ID that failed.
+            error (str): the error message for the failure.
+        """
+        self._entry_id = entry_id
+        self._error = error
+
+    @property
+    def entry_id(self) -> str:
+        """Gets the entry ID."""
+        return self._entry_id
+
+    @property
+    def error(self) -> str:
+        """Gets the error message."""
+        return self._error
+
+
+class BulkPublishResponse(DaprResponse):
+    """The response of publish_events (bulk publish) API.
+
+    This inherits from DaprResponse
+
+    Attributes:
+        failed_entries (List[BulkPublishResponseFailedEntry]): the entries that failed to publish.
+    """
+
+    def __init__(
+        self,
+        failed_entries: List[BulkPublishResponseFailedEntry] = [],
+        headers: MetadataTuple = (),
+    ):
+        """Initializes BulkPublishResponse from :obj:`runtime_v1.BulkPublishResponse`.
+
+        Args:
+            failed_entries (List[BulkPublishResponseFailedEntry]): the entries that failed.
+            headers (Tuple, optional): the headers from Dapr gRPC response.
+        """
+        super(BulkPublishResponse, self).__init__(headers)
+        self._failed_entries = failed_entries
+
+    @property
+    def failed_entries(self) -> List[BulkPublishResponseFailedEntry]:
+        """Gets the failed entries."""
+        return self._failed_entries
+
+
 class TopicEventResponseStatus(Enum):
     # success is the default behavior: message is acknowledged and not retried
     success = appcallback_v1.TopicEventResponse.TopicEventResponseStatus.SUCCESS

{dapr_dev-1.17.0.dev76 → dapr_dev-1.17.0.dev77}/dapr/clients/grpc/client.py

@@ -31,6 +31,7 @@ from google.protobuf.message import Message as GrpcMessage
 from google.protobuf.struct_pb2 import Struct as GrpcStruct
 from grpc import (  # type: ignore
     RpcError,
+    StatusCode,
     StreamStreamClientInterceptor,
     StreamUnaryClientInterceptor,
     UnaryStreamClientInterceptor,
@@ -60,6 +61,8 @@ from dapr.clients.grpc._request import (
 )
 from dapr.clients.grpc._response import (
     BindingResponse,
+    BulkPublishResponse,
+    BulkPublishResponseFailedEntry,
     BulkStateItem,
     BulkStatesResponse,
     ConfigurationResponse,
@@ -487,6 +490,96 @@ class DaprGrpcClient:
 
         return DaprResponse(call.initial_metadata())
 
+    def publish_events(
+        self,
+        pubsub_name: str,
+        topic_name: str,
+        data: Sequence[Union[bytes, str]],
+        publish_metadata: Dict[str, str] = {},
+        data_content_type: Optional[str] = None,
+    ) -> BulkPublishResponse:
+        """Bulk publish multiple events to a given topic.
+        This publishes multiple events to a specified topic and pubsub component.
+        Each event can be bytes or str. The str data is encoded into bytes with
+        default charset of utf-8.
+
+        The example publishes multiple string events to a topic:
+
+            from dapr.clients import DaprClient
+            with DaprClient() as d:
+                resp = d.publish_events(
+                    pubsub_name='pubsub_1',
+                    topic_name='TOPIC_A',
+                    data=['message1', 'message2', 'message3'],
+                    data_content_type='text/plain',
+                )
+                # resp.failed_entries includes any entries that failed to publish.
+
+        Args:
+            pubsub_name (str): the name of the pubsub component
+            topic_name (str): the topic name to publish to
+            data (Sequence[Union[bytes, str]]): sequence of events to publish;
+                each event must be bytes or str
+            publish_metadata (Dict[str, str], optional): Dapr metadata for the
+                bulk publish request
+            data_content_type (str, optional): content type of the event data
+
+        Returns:
+            :class:`BulkPublishResponse` with any failed entries
+        """
+        entries = []
+        for event in data:
+            entry_id = str(uuid.uuid4())
+            if isinstance(event, bytes):
+                event_data = event
+                content_type = data_content_type or 'application/octet-stream'
+            elif isinstance(event, str):
+                event_data = event.encode('utf-8')
+                content_type = data_content_type or 'text/plain'
+            else:
+                raise ValueError(f'invalid type for event {type(event)}')
+
+            entries.append(
+                api_v1.BulkPublishRequestEntry(
+                    entry_id=entry_id,
+                    event=event_data,
+                    content_type=content_type,
+                )
+            )
+
+        req = api_v1.BulkPublishRequest(
+            pubsub_name=pubsub_name,
+            topic=topic_name,
+            entries=entries,
+            metadata=publish_metadata,
+        )
+
+        try:
+            response, call = self.retry_policy.run_rpc(self._stub.BulkPublishEvent.with_call, req)
+        except RpcError as err:
+            if err.code() == StatusCode.UNIMPLEMENTED:
+                try:
+                    response, call = self.retry_policy.run_rpc(
+                        self._stub.BulkPublishEventAlpha1.with_call, req
+                    )
+                except RpcError as err2:
+                    raise DaprGrpcError(err2) from err2
+            else:
+                raise DaprGrpcError(err) from err
+
+        failed_entries = [
+            BulkPublishResponseFailedEntry(
+                entry_id=entry.entry_id,
+                error=entry.error,
+            )
+            for entry in response.failedEntries
+        ]
+
+        return BulkPublishResponse(
+            failed_entries=failed_entries,
+            headers=call.initial_metadata(),
+        )
+
     def subscribe(
         self,
         pubsub_name: str,

{dapr_dev-1.17.0.dev76 → dapr_dev-1.17.0.dev77/dapr_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dapr-dev
-Version: 1.17.0.dev76
+Version: 1.17.0.dev77
 Summary: The developmental release for Dapr Python SDK.
 Home-page: https://dapr.io/
 Author: Dapr Authors