cangling-broker 0.1.11__tar.gz

cangling_broker-0.1.11/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: cangling-broker
+Version: 0.1.11
+Summary: Python producer and consumer for cangling-broker
+Author-email: zhangjianshe <zhangjianshe@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/zhangjianshe/cangling-broker
+Project-URL: Repository, https://github.com/zhangjianshe/cangling-broker
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: grpcio>=1.83.0
+Requires-Dist: protobuf>=5.28.0
+Provides-Extra: dev
+Requires-Dist: grpcio-tools>=1.83.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# cangling-broker (Python)
+
+Producer and consumer for cangling-broker. Same contract as the Java client: `AcceptMessages` to publish, `Subscribe` to consume, optional `Register` metadata, `CL_BROKER_AUTH_TOKEN` on every RPC.
+
+## Install
+
+```bash
+pip install cangling-broker
+```
+
+From this tree:
+
+```bash
+pip install -e python
+```
+
+## Use
+
+```python
+from cangling_broker import SatwayClient, SubscribeOptions
+
+with SatwayClient.connect("127.0.0.1:7500", "change-me") as client:
+    client.send("cangling-test", "hello")
+    with client.subscribe(
+        SubscribeOptions(topic="cangling-test", name="worker-1"),
+        lambda message: print(message.id, message.payload),
+    ):
+        ...
+```
+
+`SatwayClient.connect(broker)` also reads `CL_BROKER_AUTH_TOKEN` from the environment.
+
+Batch-set topic delivery (`single` = one consumer, `broadcast` = every live stream):
+
+```python
+from cangling_broker import TopicConfig
+
+client.configure_topics([
+    TopicConfig("jobs", "single"),
+    TopicConfig("alerts", "broadcast"),
+])
+print(client.list_topics())
+```
+
+Existing Kafka senders can keep ``send(topic, value)`` / ``flush()``:
+
+```python
+# from kafka import KafkaProducer
+from cangling_broker import KafkaProducer
+
+producer = KafkaProducer(bootstrap_servers="127.0.0.1:7500")
+producer.send(topic, msg)
+producer.flush()
+```
+
+```bash
+# consume
+python python/examples/consumer.py --broker 127.0.0.1:7500 --topic cangling-test --name py-s0 --token change-me
+
+# produce
+python python/examples/producer.py --broker 127.0.0.1:7500 --topic cangling-test --text hello --count 1 --token change-me
+```
+
+## Publish to PyPI
+
+CI on tag `v*` builds the package and uploads with `pypa/gh-action-pypi-publish`. Set repository secret `PYPI_API_TOKEN`.
+
+```bash
+cd python
+python generate_proto.py
+python -m build
+```

cangling_broker-0.1.11/README.md

@@ -0,0 +1,72 @@
+# cangling-broker (Python)
+
+Producer and consumer for cangling-broker. Same contract as the Java client: `AcceptMessages` to publish, `Subscribe` to consume, optional `Register` metadata, `CL_BROKER_AUTH_TOKEN` on every RPC.
+
+## Install
+
+```bash
+pip install cangling-broker
+```
+
+From this tree:
+
+```bash
+pip install -e python
+```
+
+## Use
+
+```python
+from cangling_broker import SatwayClient, SubscribeOptions
+
+with SatwayClient.connect("127.0.0.1:7500", "change-me") as client:
+    client.send("cangling-test", "hello")
+    with client.subscribe(
+        SubscribeOptions(topic="cangling-test", name="worker-1"),
+        lambda message: print(message.id, message.payload),
+    ):
+        ...
+```
+
+`SatwayClient.connect(broker)` also reads `CL_BROKER_AUTH_TOKEN` from the environment.
+
+Batch-set topic delivery (`single` = one consumer, `broadcast` = every live stream):
+
+```python
+from cangling_broker import TopicConfig
+
+client.configure_topics([
+    TopicConfig("jobs", "single"),
+    TopicConfig("alerts", "broadcast"),
+])
+print(client.list_topics())
+```
+
+Existing Kafka senders can keep ``send(topic, value)`` / ``flush()``:
+
+```python
+# from kafka import KafkaProducer
+from cangling_broker import KafkaProducer
+
+producer = KafkaProducer(bootstrap_servers="127.0.0.1:7500")
+producer.send(topic, msg)
+producer.flush()
+```
+
+```bash
+# consume
+python python/examples/consumer.py --broker 127.0.0.1:7500 --topic cangling-test --name py-s0 --token change-me
+
+# produce
+python python/examples/producer.py --broker 127.0.0.1:7500 --topic cangling-test --text hello --count 1 --token change-me
+```
+
+## Publish to PyPI
+
+CI on tag `v*` builds the package and uploads with `pypa/gh-action-pypi-publish`. Set repository secret `PYPI_API_TOKEN`.
+
+```bash
+cd python
+python generate_proto.py
+python -m build
+```

cangling_broker-0.1.11/cangling_broker/__init__.py

@@ -0,0 +1,12 @@
+from .client import SatwayClient
+from .compat import KafkaProducer
+from .models import SatwayMessage, SendResult, SubscribeOptions, TopicConfig
+
+__all__ = [
+    "KafkaProducer",
+    "SatwayClient",
+    "SatwayMessage",
+    "SendResult",
+    "SubscribeOptions",
+    "TopicConfig",
+]

cangling_broker-0.1.11/cangling_broker/client.py

@@ -0,0 +1,354 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+import logging
+import threading
+import time
+import uuid
+
+import grpc
+
+from .models import SatwayMessage, SendResult, SubscribeOptions, TopicConfig, auth_token_from_env
+from .proto import queue_pb2, queue_pb2_grpc
+
+LOG = logging.getLogger("cangling_broker")
+
+INITIAL_BACKOFF_SECS = 0.2
+MAX_BACKOFF_SECS = 5.0
+RPC_DEADLINE_SECS = 15
+RETRYABLE = {
+    grpc.StatusCode.UNAVAILABLE,
+    grpc.StatusCode.DEADLINE_EXCEEDED,
+    grpc.StatusCode.ABORTED,
+    grpc.StatusCode.UNKNOWN,
+}
+
+Handler = Callable[[SatwayMessage], None]
+
+
+def _broker_target(broker: str) -> str:
+    broker = broker.strip()
+    if broker.startswith("http://"):
+        return broker[len("http://") :]
+    if broker.startswith("https://"):
+        return broker[len("https://") :]
+    return broker
+
+
+def _auth_metadata(token: str | None) -> list[tuple[str, str]] | None:
+    token = (token or "").strip()
+    if not token:
+        return None
+    if not token.lower().startswith("bearer "):
+        token = "Bearer " + token
+    return [("authorization", token)]
+
+
+class SatwayClient:
+    """Broker client. Owns the gRPC channel and retries unary RPCs.
+
+    Each :meth:`subscribe` stream reopens on the same ``consumer_id`` after a drop.
+    """
+
+    def __init__(self, channel: grpc.Channel, metadata: list[tuple[str, str]] | None):
+        self._channel = channel
+        self._stub = queue_pb2_grpc.MessageQueueStub(channel)
+        self._metadata = metadata
+        self._open = True
+        self._consumers: list[Consumer] = []
+        self._lock = threading.Lock()
+
+    @classmethod
+    def connect(cls, broker: str, token: str | None = None) -> SatwayClient:
+        if not broker or not broker.strip():
+            raise ValueError("broker is required")
+        if token is None:
+            token = auth_token_from_env()
+        channel = grpc.insecure_channel(_broker_target(broker))
+        return cls(channel, _auth_metadata(token))
+
+    def send(
+        self,
+        topic: str,
+        payload: str | bytes,
+        idempotency_key: str = "",
+        attributes: dict[str, str] | None = None,
+    ) -> SendResult:
+        if not topic or not topic.strip():
+            raise ValueError("topic is required")
+        if payload is None or payload == "" or payload == b"":
+            raise ValueError("payload is required")
+        body = payload.encode("utf-8") if isinstance(payload, str) else payload
+        key = idempotency_key.strip() if idempotency_key else str(uuid.uuid4())
+        attrs = attributes or {}
+
+        def once() -> SendResult:
+            request = queue_pb2.AcceptMessageRequest(
+                idempotency_key=key,
+                topic=topic,
+                payload=body,
+                attributes=attrs,
+            )
+            for response in self._stub.AcceptMessages(
+                iter([request]),
+                timeout=RPC_DEADLINE_SECS,
+                metadata=self._metadata,
+            ):
+                return SendResult(response.message_id, response.duplicate)
+            raise RuntimeError("publish stream closed without a response")
+
+        return self._call_with_reconnect("publish", once)
+
+    def register(
+        self,
+        topic: str,
+        name: str = "",
+        attributes: dict[str, str] | None = None,
+        consumer_id: str = "",
+    ) -> str:
+        def once() -> str:
+            return self._stub.Register(
+                queue_pb2.RegisterRequest(
+                    topic=topic,
+                    consumer_id=consumer_id or "",
+                    name=name or "",
+                    attributes=attributes or {},
+                ),
+                timeout=RPC_DEADLINE_SECS,
+                metadata=self._metadata,
+            ).consumer_id
+
+        return self._call_with_reconnect("register", once)
+
+    def configure_topics(self, topics: list[TopicConfig]) -> list[TopicConfig]:
+        if not topics:
+            raise ValueError("topics is required")
+
+        def once() -> list[TopicConfig]:
+            response = self._stub.ConfigureTopics(
+                queue_pb2.ConfigureTopicsRequest(
+                    topics=[
+                        queue_pb2.TopicConfig(topic=item.topic, delivery=item.delivery)
+                        for item in topics
+                    ]
+                ),
+                timeout=RPC_DEADLINE_SECS,
+                metadata=self._metadata,
+            )
+            return [TopicConfig(topic=item.topic, delivery=item.delivery) for item in response.topics]
+
+        return self._call_with_reconnect("configure_topics", once)
+
+    def list_topics(self) -> list[TopicConfig]:
+        def once() -> list[TopicConfig]:
+            response = self._stub.ListTopics(
+                queue_pb2.ListTopicsRequest(),
+                timeout=RPC_DEADLINE_SECS,
+                metadata=self._metadata,
+            )
+            return [TopicConfig(topic=item.topic, delivery=item.delivery) for item in response.topics]
+
+        return self._call_with_reconnect("list_topics", once)
+
+    def unregister(self, consumer_id: str) -> None:
+        if not consumer_id:
+            return
+
+        def once() -> None:
+            self._stub.Unregister(
+                queue_pb2.UnregisterRequest(consumer_id=consumer_id),
+                timeout=RPC_DEADLINE_SECS,
+                metadata=self._metadata,
+            )
+
+        self._call_with_reconnect("unregister", once)
+
+    def subscribe(
+        self,
+        topic: str | SubscribeOptions,
+        handler: Handler,
+        *,
+        name: str = "",
+        consumer_id: str = "",
+        attributes: dict[str, str] | None = None,
+    ) -> Consumer:
+        if handler is None:
+            raise ValueError("handler is required")
+        if isinstance(topic, SubscribeOptions):
+            options = topic
+        else:
+            options = SubscribeOptions(
+                topic=topic,
+                name=name,
+                consumer_id=consumer_id,
+                attributes=attributes or {},
+            )
+        cid = options.consumer_id
+        if options.name or options.attributes or options.consumer_id:
+            cid = self.register(
+                options.topic,
+                name=options.name,
+                attributes=dict(options.attributes),
+                consumer_id=options.consumer_id,
+            )
+        consumer = Consumer(self, options, cid, handler)
+        with self._lock:
+            self._consumers.append(consumer)
+        return consumer
+
+    def close(self) -> None:
+        with self._lock:
+            if not self._open:
+                return
+            self._open = False
+            consumers = list(self._consumers)
+        for consumer in consumers:
+            consumer.close()
+        self._channel.close()
+
+    def __enter__(self) -> SatwayClient:
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    def _is_open(self) -> bool:
+        return self._open
+
+    def _ack(self, message_id: str, lease: str, success: bool, error: str = "") -> None:
+        def once() -> None:
+            self._stub.AckMessage(
+                queue_pb2.AckMessageRequest(
+                    message_id=message_id,
+                    lease=lease,
+                    success=success,
+                    error=error or "",
+                ),
+                timeout=RPC_DEADLINE_SECS,
+                metadata=self._metadata,
+            )
+
+        self._call_with_reconnect("ack", once)
+
+    def _ensure_registered(self, options: SubscribeOptions, consumer_id: str) -> None:
+        if not consumer_id:
+            return
+        self.register(
+            options.topic,
+            name=options.name,
+            attributes=dict(options.attributes),
+            consumer_id=consumer_id,
+        )
+
+    def _subscribe_stream(self, topic: str, consumer_id: str):
+        return self._stub.Subscribe(
+            queue_pb2.SubscribeRequest(topic=topic, consumer_id=consumer_id or ""),
+            metadata=self._metadata,
+        )
+
+    def _call_with_reconnect(self, op: str, call):
+        backoff = INITIAL_BACKOFF_SECS
+        while True:
+            if not self._open:
+                raise RuntimeError("client closed")
+            try:
+                return call()
+            except grpc.RpcError as error:
+                if not self._open:
+                    raise RuntimeError("client closed") from error
+                if error.code() not in RETRYABLE:
+                    raise RuntimeError(f"{op} failed: {error.code()}: {error.details()}") from error
+                LOG.warning("%s failed, reconnecting: %s", op, error.details() or error.code())
+                time.sleep(backoff)
+                backoff = min(backoff * 2, MAX_BACKOFF_SECS)
+
+
+class Consumer:
+    def __init__(
+        self,
+        client: SatwayClient,
+        options: SubscribeOptions,
+        consumer_id: str,
+        handler: Handler,
+    ):
+        self._client = client
+        self._closed = False
+        self.consumer_id = consumer_id
+        self._thread = threading.Thread(
+            target=self._run,
+            args=(options, handler),
+            name="cangling-subscribe",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def close(self) -> None:
+        self._closed = True
+
+    def __enter__(self) -> Consumer:
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    def _running(self) -> bool:
+        return not self._closed and self._client._is_open()
+
+    def _run(self, options: SubscribeOptions, handler: Handler) -> None:
+        backoff = INITIAL_BACKOFF_SECS
+        while self._running():
+            try:
+                self._client._ensure_registered(options, self.consumer_id)
+                stream = self._client._subscribe_stream(options.topic, self.consumer_id)
+                backoff = INITIAL_BACKOFF_SECS
+                for incoming in stream:
+                    if not self._running():
+                        return
+                    message = _to_message(incoming)
+                    try:
+                        handler(message)
+                        self._client._ack(incoming.message_id, incoming.lease, True, "")
+                    except Exception as error:
+                        LOG.warning("handler failed", exc_info=error)
+                        self._client._ack(
+                            incoming.message_id,
+                            incoming.lease,
+                            False,
+                            str(error) or "handler failed",
+                        )
+                if self._running():
+                    LOG.info("subscribe stream ended, reconnecting")
+            except grpc.RpcError as error:
+                if self._running():
+                    LOG.warning("subscribe stream closed, reconnecting: %s", error.details() or error.code())
+                else:
+                    return
+            except Exception as error:
+                if self._running():
+                    LOG.warning("subscribe failed, reconnecting: %s", error)
+                else:
+                    return
+            if self._running():
+                time.sleep(backoff)
+                backoff = min(backoff * 2, MAX_BACKOFF_SECS)
+
+
+def _to_message(incoming: queue_pb2.SatwayMessage) -> SatwayMessage:
+    raw = incoming.payload
+    try:
+        payload = raw.decode("utf-8")
+        encoding = "utf-8"
+    except UnicodeDecodeError:
+        import base64
+
+        payload = base64.b64encode(raw).decode("ascii")
+        encoding = "base64"
+    return SatwayMessage(
+        id=incoming.message_id,
+        topic=incoming.topic,
+        payload=payload,
+        payload_encoding=encoding,
+        attributes=dict(incoming.attributes),
+        created_at=incoming.created_at,
+        lease=incoming.lease,
+    )

cangling_broker-0.1.11/cangling_broker/compat.py

@@ -0,0 +1,37 @@
+"""kafka-python shaped helpers so existing senders can target this broker."""
+
+from __future__ import annotations
+
+from .client import SatwayClient
+
+
+class KafkaProducer:
+    """Stand-in for ``kafka.KafkaProducer``.
+
+    Keep calling ``send(topic, value)`` and ``flush()``. ``bootstrap_servers``
+    is the cangling-broker (``host:port``). Extra Kafka kwargs are ignored.
+    """
+
+    def __init__(
+        self,
+        bootstrap_servers="",
+        token=None,
+        value_serializer=None,
+        **_ignored,
+    ):
+        if isinstance(bootstrap_servers, (list, tuple)):
+            if not bootstrap_servers:
+                raise ValueError("bootstrap_servers is required")
+            bootstrap_servers = bootstrap_servers[0]
+        self._client = SatwayClient.connect(str(bootstrap_servers), token)
+        self._value_serializer = value_serializer
+
+    def send(self, topic, value=None, key=None, headers=None, partition=None, timestamp_ms=None):
+        payload = self._value_serializer(value) if self._value_serializer is not None else value
+        return self._client.send(topic, payload)
+
+    def flush(self, timeout=None):
+        return None
+
+    def close(self, timeout=None):
+        self._client.close()

cangling_broker-0.1.11/cangling_broker/models.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import os
+from typing import Mapping
+
+
+def auth_token_from_env() -> str:
+    return (os.environ.get("CL_BROKER_AUTH_TOKEN") or "").strip()
+
+
+@dataclass(frozen=True)
+class SendResult:
+    message_id: str
+    duplicate: bool = False
+
+
+@dataclass
+class SatwayMessage:
+    id: str
+    topic: str
+    payload: str
+    payload_encoding: str = "utf-8"
+    attributes: Mapping[str, str] = field(default_factory=dict)
+    created_at: str = ""
+    lease: str = ""
+
+
+@dataclass(frozen=True)
+class TopicConfig:
+    topic: str
+    delivery: str = "single"
+
+    def __post_init__(self) -> None:
+        if not self.topic or not self.topic.strip():
+            raise ValueError("topic is required")
+        delivery = (self.delivery or "single").strip().lower()
+        if delivery not in {"single", "broadcast", "queue", "competing", "fanout", "pubsub"}:
+            raise ValueError("delivery must be single or broadcast")
+        if delivery in {"queue", "competing"}:
+            delivery = "single"
+        if delivery in {"fanout", "pubsub"}:
+            delivery = "broadcast"
+        object.__setattr__(self, "topic", self.topic.strip())
+        object.__setattr__(self, "delivery", delivery)
+
+
+@dataclass(frozen=True)
+class SubscribeOptions:
+    topic: str
+    consumer_id: str = ""
+    name: str = ""
+    attributes: Mapping[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not self.topic or not self.topic.strip():
+            raise ValueError("topic is required")
+        object.__setattr__(self, "topic", self.topic.strip())
+        object.__setattr__(self, "consumer_id", self.consumer_id or "")
+        object.__setattr__(self, "name", self.name or "")
+        object.__setattr__(self, "attributes", dict(self.attributes or {}))

cangling_broker-0.1.11/cangling_broker/proto/__init__.py

@@ -0,0 +1 @@
+# Generated gRPC stubs live in this package.

cangling_broker-0.1.11/cangling_broker/proto/queue_pb2.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: queue.proto
+# Protobuf Python Version: 7.35.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    7,
+    35,
+    1,
+    '',
+    'queue.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0bqueue.proto\x12\rdispatcher.v1\"\xcb\x01\n\x14\x41\x63\x63\x65ptMessageRequest\x12\x17\n\x0fidempotency_key\x18\x01 \x01(\t\x12\r\n\x05topic\x18\x02 \x01(\t\x12\x0f\n\x07payload\x18\x03 \x01(\x0c\x12G\n\nattributes\x18\x04 \x03(\x0b\x32\x33.dispatcher.v1.AcceptMessageRequest.AttributesEntry\x1a\x31\n\x0f\x41ttributesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\">\n\x15\x41\x63\x63\x65ptMessageResponse\x12\x12\n\nmessage_id\x18\x01 \x01(\t\x12\x11\n\tduplicate\x18\x02 \x01(\x08\"\xba\x01\n\x0fRegisterRequest\x12\r\n\x05topic\x18\x01 \x01(\t\x12\x13\n\x0b\x63onsumer_id\x18\x02 \x01(\t\x12\x0c\n\x04name\x18\x03 \x01(\t\x12\x42\n\nattributes\x18\x04 \x03(\x0b\x32..dispatcher.v1.RegisterRequest.AttributesEntry\x1a\x31\n\x0f\x41ttributesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\'\n\x10RegisterResponse\x12\x13\n\x0b\x63onsumer_id\x18\x01 \x01(\t\"(\n\x11UnregisterRequest\x12\x13\n\x0b\x63onsumer_id\x18\x01 \x01(\t\"\x14\n\x12UnregisterResponse\"6\n\x10SubscribeRequest\x12\r\n\x05topic\x18\x01 \x01(\t\x12\x13\n\x0b\x63onsumer_id\x18\x02 \x01(\t\"\xdb\x01\n\rSatwayMessage\x12\x12\n\nmessage_id\x18\x01 \x01(\t\x12\r\n\x05topic\x18\x02 \x01(\t\x12\x0f\n\x07payload\x18\x03 \x01(\x0c\x12@\n\nattributes\x18\x04 \x03(\x0b\x32,.dispatcher.v1.SatwayMessage.AttributesEntry\x12\x12\n\ncreated_at\x18\x05 \x01(\t\x12\r\n\x05lease\x18\x06 \x01(\t\x1a\x31\n\x0f\x41ttributesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"V\n\x11\x41\x63kMessageRequest\x12\x12\n\nmessage_id\x18\x01 \x01(\t\x12\r\n\x05lease\x18\x02 \x01(\t\x12\x0f\n\x07success\x18\x03 \x01(\x08\x12\r\n\x05\x65rror\x18\x04 \x01(\t\"&\n\x12\x41\x63kMessageResponse\x12\x10\n\x08\x61\x63\x63\x65pted\x18\x01 \x01(\x08\".\n\x0bTopicConfig\x12\r\n\x05topic\x18\x01 \x01(\t\x12\x10\n\x08\x64\x65livery\x18\x02 \x01(\t\"D\n\x16\x43onfigureTopicsRequest\x12*\n\x06topics\x18\x01 \x03(\x0b\x32\x1a.dispatcher.v1.TopicConfig\"E\n\x17\x43onfigureTopicsResponse\x12*\n\x06topics\x18\x01 \x03(\x0b\x32\x1a.dispatcher.v1.TopicConfig\"\x13\n\x11ListTopicsRequest\"@\n\x12ListTopicsResponse\x12*\n\x06topics\x18\x01 \x03(\x0b\x32\x1a.dispatcher.v1.TopicConfig2\xe5\x04\n\x0cMessageQueue\x12_\n\x0e\x41\x63\x63\x65ptMessages\x12#.dispatcher.v1.AcceptMessageRequest\x1a$.dispatcher.v1.AcceptMessageResponse(\x01\x30\x01\x12K\n\x08Register\x12\x1e.dispatcher.v1.RegisterRequest\x1a\x1f.dispatcher.v1.RegisterResponse\x12Q\n\nUnregister\x12 .dispatcher.v1.UnregisterRequest\x1a!.dispatcher.v1.UnregisterResponse\x12L\n\tSubscribe\x12\x1f.dispatcher.v1.SubscribeRequest\x1a\x1c.dispatcher.v1.SatwayMessage0\x01\x12Q\n\nAckMessage\x12 .dispatcher.v1.AckMessageRequest\x1a!.dispatcher.v1.AckMessageResponse\x12`\n\x0f\x43onfigureTopics\x12%.dispatcher.v1.ConfigureTopicsRequest\x1a&.dispatcher.v1.ConfigureTopicsResponse\x12Q\n\nListTopics\x12 .dispatcher.v1.ListTopicsRequest\x1a!.dispatcher.v1.ListTopicsResponseB&\n\x16\x63n.mapway.broker.protoB\nQueueProtoP\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'queue_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\026cn.mapway.broker.protoB\nQueueProtoP\001'
+  _globals['_ACCEPTMESSAGEREQUEST_ATTRIBUTESENTRY']._loaded_options = None
+  _globals['_ACCEPTMESSAGEREQUEST_ATTRIBUTESENTRY']._serialized_options = b'8\001'
+  _globals['_REGISTERREQUEST_ATTRIBUTESENTRY']._loaded_options = None
+  _globals['_REGISTERREQUEST_ATTRIBUTESENTRY']._serialized_options = b'8\001'
+  _globals['_SATWAYMESSAGE_ATTRIBUTESENTRY']._loaded_options = None
+  _globals['_SATWAYMESSAGE_ATTRIBUTESENTRY']._serialized_options = b'8\001'
+  _globals['_ACCEPTMESSAGEREQUEST']._serialized_start=31
+  _globals['_ACCEPTMESSAGEREQUEST']._serialized_end=234
+  _globals['_ACCEPTMESSAGEREQUEST_ATTRIBUTESENTRY']._serialized_start=185
+  _globals['_ACCEPTMESSAGEREQUEST_ATTRIBUTESENTRY']._serialized_end=234
+  _globals['_ACCEPTMESSAGERESPONSE']._serialized_start=236
+  _globals['_ACCEPTMESSAGERESPONSE']._serialized_end=298
+  _globals['_REGISTERREQUEST']._serialized_start=301
+  _globals['_REGISTERREQUEST']._serialized_end=487
+  _globals['_REGISTERREQUEST_ATTRIBUTESENTRY']._serialized_start=185
+  _globals['_REGISTERREQUEST_ATTRIBUTESENTRY']._serialized_end=234
+  _globals['_REGISTERRESPONSE']._serialized_start=489
+  _globals['_REGISTERRESPONSE']._serialized_end=528
+  _globals['_UNREGISTERREQUEST']._serialized_start=530
+  _globals['_UNREGISTERREQUEST']._serialized_end=570
+  _globals['_UNREGISTERRESPONSE']._serialized_start=572
+  _globals['_UNREGISTERRESPONSE']._serialized_end=592
+  _globals['_SUBSCRIBEREQUEST']._serialized_start=594
+  _globals['_SUBSCRIBEREQUEST']._serialized_end=648
+  _globals['_SATWAYMESSAGE']._serialized_start=651
+  _globals['_SATWAYMESSAGE']._serialized_end=870
+  _globals['_SATWAYMESSAGE_ATTRIBUTESENTRY']._serialized_start=185
+  _globals['_SATWAYMESSAGE_ATTRIBUTESENTRY']._serialized_end=234
+  _globals['_ACKMESSAGEREQUEST']._serialized_start=872
+  _globals['_ACKMESSAGEREQUEST']._serialized_end=958
+  _globals['_ACKMESSAGERESPONSE']._serialized_start=960
+  _globals['_ACKMESSAGERESPONSE']._serialized_end=998
+  _globals['_TOPICCONFIG']._serialized_start=1000
+  _globals['_TOPICCONFIG']._serialized_end=1046
+  _globals['_CONFIGURETOPICSREQUEST']._serialized_start=1048
+  _globals['_CONFIGURETOPICSREQUEST']._serialized_end=1116
+  _globals['_CONFIGURETOPICSRESPONSE']._serialized_start=1118
+  _globals['_CONFIGURETOPICSRESPONSE']._serialized_end=1187
+  _globals['_LISTTOPICSREQUEST']._serialized_start=1189
+  _globals['_LISTTOPICSREQUEST']._serialized_end=1208
+  _globals['_LISTTOPICSRESPONSE']._serialized_start=1210
+  _globals['_LISTTOPICSRESPONSE']._serialized_end=1274
+  _globals['_MESSAGEQUEUE']._serialized_start=1277
+  _globals['_MESSAGEQUEUE']._serialized_end=1890
+# @@protoc_insertion_point(module_scope)

cangling_broker-0.1.11/cangling_broker/proto/queue_pb2_grpc.py

@@ -0,0 +1,364 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import queue_pb2 as queue__pb2
+
+GRPC_GENERATED_VERSION = '1.83.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in queue_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class MessageQueueStub:
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.AcceptMessages = channel.stream_stream(
+                '/dispatcher.v1.MessageQueue/AcceptMessages',
+                request_serializer=queue__pb2.AcceptMessageRequest.SerializeToString,
+                response_deserializer=queue__pb2.AcceptMessageResponse.FromString,
+                _registered_method=True)
+        self.Register = channel.unary_unary(
+                '/dispatcher.v1.MessageQueue/Register',
+                request_serializer=queue__pb2.RegisterRequest.SerializeToString,
+                response_deserializer=queue__pb2.RegisterResponse.FromString,
+                _registered_method=True)
+        self.Unregister = channel.unary_unary(
+                '/dispatcher.v1.MessageQueue/Unregister',
+                request_serializer=queue__pb2.UnregisterRequest.SerializeToString,
+                response_deserializer=queue__pb2.UnregisterResponse.FromString,
+                _registered_method=True)
+        self.Subscribe = channel.unary_stream(
+                '/dispatcher.v1.MessageQueue/Subscribe',
+                request_serializer=queue__pb2.SubscribeRequest.SerializeToString,
+                response_deserializer=queue__pb2.SatwayMessage.FromString,
+                _registered_method=True)
+        self.AckMessage = channel.unary_unary(
+                '/dispatcher.v1.MessageQueue/AckMessage',
+                request_serializer=queue__pb2.AckMessageRequest.SerializeToString,
+                response_deserializer=queue__pb2.AckMessageResponse.FromString,
+                _registered_method=True)
+        self.ConfigureTopics = channel.unary_unary(
+                '/dispatcher.v1.MessageQueue/ConfigureTopics',
+                request_serializer=queue__pb2.ConfigureTopicsRequest.SerializeToString,
+                response_deserializer=queue__pb2.ConfigureTopicsResponse.FromString,
+                _registered_method=True)
+        self.ListTopics = channel.unary_unary(
+                '/dispatcher.v1.MessageQueue/ListTopics',
+                request_serializer=queue__pb2.ListTopicsRequest.SerializeToString,
+                response_deserializer=queue__pb2.ListTopicsResponse.FromString,
+                _registered_method=True)
+
+
+class MessageQueueServicer:
+    """Missing associated documentation comment in .proto file."""
+
+    def AcceptMessages(self, request_iterator, context):
+        """Client streams publishes; server streams one response per request after SQLite commit.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Register(self, request, context):
+        """Optional metadata about a consumer. Delivery is on Subscribe, not this call.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Unregister(self, request, context):
+        """Unregister drops stored consumer metadata.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Subscribe(self, request, context):
+        """Open a consume stream. Multiple subscribers on one topic compete:
+        each message is sent to exactly one of them.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def AckMessage(self, request, context):
+        """Confirm or reject a message received from Subscribe.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ConfigureTopics(self, request, context):
+        """Create or replace delivery mode for many topics at once.
+        delivery is "single" (competing consumers, default) or "broadcast" (every live stream).
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListTopics(self, request, context):
+        """List stored topic delivery configs.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_MessageQueueServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'AcceptMessages': grpc.stream_stream_rpc_method_handler(
+                    servicer.AcceptMessages,
+                    request_deserializer=queue__pb2.AcceptMessageRequest.FromString,
+                    response_serializer=queue__pb2.AcceptMessageResponse.SerializeToString,
+            ),
+            'Register': grpc.unary_unary_rpc_method_handler(
+                    servicer.Register,
+                    request_deserializer=queue__pb2.RegisterRequest.FromString,
+                    response_serializer=queue__pb2.RegisterResponse.SerializeToString,
+            ),
+            'Unregister': grpc.unary_unary_rpc_method_handler(
+                    servicer.Unregister,
+                    request_deserializer=queue__pb2.UnregisterRequest.FromString,
+                    response_serializer=queue__pb2.UnregisterResponse.SerializeToString,
+            ),
+            'Subscribe': grpc.unary_stream_rpc_method_handler(
+                    servicer.Subscribe,
+                    request_deserializer=queue__pb2.SubscribeRequest.FromString,
+                    response_serializer=queue__pb2.SatwayMessage.SerializeToString,
+            ),
+            'AckMessage': grpc.unary_unary_rpc_method_handler(
+                    servicer.AckMessage,
+                    request_deserializer=queue__pb2.AckMessageRequest.FromString,
+                    response_serializer=queue__pb2.AckMessageResponse.SerializeToString,
+            ),
+            'ConfigureTopics': grpc.unary_unary_rpc_method_handler(
+                    servicer.ConfigureTopics,
+                    request_deserializer=queue__pb2.ConfigureTopicsRequest.FromString,
+                    response_serializer=queue__pb2.ConfigureTopicsResponse.SerializeToString,
+            ),
+            'ListTopics': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListTopics,
+                    request_deserializer=queue__pb2.ListTopicsRequest.FromString,
+                    response_serializer=queue__pb2.ListTopicsResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dispatcher.v1.MessageQueue', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dispatcher.v1.MessageQueue', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class MessageQueue:
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def AcceptMessages(request_iterator,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.stream_stream(
+            request_iterator,
+            target,
+            '/dispatcher.v1.MessageQueue/AcceptMessages',
+            queue__pb2.AcceptMessageRequest.SerializeToString,
+            queue__pb2.AcceptMessageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def Register(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dispatcher.v1.MessageQueue/Register',
+            queue__pb2.RegisterRequest.SerializeToString,
+            queue__pb2.RegisterResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def Unregister(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dispatcher.v1.MessageQueue/Unregister',
+            queue__pb2.UnregisterRequest.SerializeToString,
+            queue__pb2.UnregisterResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def Subscribe(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/dispatcher.v1.MessageQueue/Subscribe',
+            queue__pb2.SubscribeRequest.SerializeToString,
+            queue__pb2.SatwayMessage.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def AckMessage(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dispatcher.v1.MessageQueue/AckMessage',
+            queue__pb2.AckMessageRequest.SerializeToString,
+            queue__pb2.AckMessageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ConfigureTopics(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dispatcher.v1.MessageQueue/ConfigureTopics',
+            queue__pb2.ConfigureTopicsRequest.SerializeToString,
+            queue__pb2.ConfigureTopicsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ListTopics(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dispatcher.v1.MessageQueue/ListTopics',
+            queue__pb2.ListTopicsRequest.SerializeToString,
+            queue__pb2.ListTopicsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

cangling_broker-0.1.11/cangling_broker.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: cangling-broker
+Version: 0.1.11
+Summary: Python producer and consumer for cangling-broker
+Author-email: zhangjianshe <zhangjianshe@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/zhangjianshe/cangling-broker
+Project-URL: Repository, https://github.com/zhangjianshe/cangling-broker
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: grpcio>=1.83.0
+Requires-Dist: protobuf>=5.28.0
+Provides-Extra: dev
+Requires-Dist: grpcio-tools>=1.83.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# cangling-broker (Python)
+
+Producer and consumer for cangling-broker. Same contract as the Java client: `AcceptMessages` to publish, `Subscribe` to consume, optional `Register` metadata, `CL_BROKER_AUTH_TOKEN` on every RPC.
+
+## Install
+
+```bash
+pip install cangling-broker
+```
+
+From this tree:
+
+```bash
+pip install -e python
+```
+
+## Use
+
+```python
+from cangling_broker import SatwayClient, SubscribeOptions
+
+with SatwayClient.connect("127.0.0.1:7500", "change-me") as client:
+    client.send("cangling-test", "hello")
+    with client.subscribe(
+        SubscribeOptions(topic="cangling-test", name="worker-1"),
+        lambda message: print(message.id, message.payload),
+    ):
+        ...
+```
+
+`SatwayClient.connect(broker)` also reads `CL_BROKER_AUTH_TOKEN` from the environment.
+
+Batch-set topic delivery (`single` = one consumer, `broadcast` = every live stream):
+
+```python
+from cangling_broker import TopicConfig
+
+client.configure_topics([
+    TopicConfig("jobs", "single"),
+    TopicConfig("alerts", "broadcast"),
+])
+print(client.list_topics())
+```
+
+Existing Kafka senders can keep ``send(topic, value)`` / ``flush()``:
+
+```python
+# from kafka import KafkaProducer
+from cangling_broker import KafkaProducer
+
+producer = KafkaProducer(bootstrap_servers="127.0.0.1:7500")
+producer.send(topic, msg)
+producer.flush()
+```
+
+```bash
+# consume
+python python/examples/consumer.py --broker 127.0.0.1:7500 --topic cangling-test --name py-s0 --token change-me
+
+# produce
+python python/examples/producer.py --broker 127.0.0.1:7500 --topic cangling-test --text hello --count 1 --token change-me
+```
+
+## Publish to PyPI
+
+CI on tag `v*` builds the package and uploads with `pypa/gh-action-pypi-publish`. Set repository secret `PYPI_API_TOKEN`.
+
+```bash
+cd python
+python generate_proto.py
+python -m build
+```

cangling_broker-0.1.11/cangling_broker.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+cangling_broker/__init__.py
+cangling_broker/client.py
+cangling_broker/compat.py
+cangling_broker/models.py
+cangling_broker.egg-info/PKG-INFO
+cangling_broker.egg-info/SOURCES.txt
+cangling_broker.egg-info/dependency_links.txt
+cangling_broker.egg-info/requires.txt
+cangling_broker.egg-info/top_level.txt
+cangling_broker/proto/__init__.py
+cangling_broker/proto/queue_pb2.py
+cangling_broker/proto/queue_pb2_grpc.py

cangling_broker-0.1.11/cangling_broker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cangling_broker-0.1.11/cangling_broker.egg-info/requires.txt

@@ -0,0 +1,7 @@
+grpcio>=1.83.0
+protobuf>=5.28.0
+
+[dev]
+grpcio-tools>=1.83.0
+build
+twine

cangling_broker-0.1.11/cangling_broker.egg-info/top_level.txt

@@ -0,0 +1 @@
+cangling_broker

cangling_broker-0.1.11/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "cangling-broker"
+version = "0.1.11"
+description = "Python producer and consumer for cangling-broker"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "zhangjianshe", email = "zhangjianshe@gmail.com" }]
+license = { text = "Apache-2.0" }
+dependencies = [
+    "grpcio>=1.83.0",
+    "protobuf>=5.28.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+]
+urls.Homepage = "https://github.com/zhangjianshe/cangling-broker"
+urls.Repository = "https://github.com/zhangjianshe/cangling-broker"
+
+[project.optional-dependencies]
+dev = ["grpcio-tools>=1.83.0", "build", "twine"]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cangling_broker", "cangling_broker.*"]

cangling_broker-0.1.11/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+