rillkit 0.2.0__tar.gz → 0.3.0__tar.gz

{rillkit-0.2.0 → rillkit-0.3.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.5
 Name: rillkit
-Version: 0.2.0
+Version: 0.3.0
 Summary: Simple publish and consume for Redis Streams: consumer groups, retries, DLQ, ack policies and middleware.
-Project-URL: Homepage, https://nimzymaina.github.io/rillkit/
-Project-URL: Documentation, https://nimzymaina.github.io/rillkit/
-Project-URL: Repository, https://github.com/NimzyMaina/rillkit
-Project-URL: Issues, https://github.com/NimzyMaina/rillkit/issues
+Project-URL: Homepage, https://nimzymaina.github.io/RillKit/
+Project-URL: Documentation, https://nimzymaina.github.io/RillKit/
+Project-URL: Repository, https://github.com/NimzyMaina/RillKit
+Project-URL: Issues, https://github.com/NimzyMaina/RillKit/issues
 Author: Nimrod Maina
 License: MIT
 License-File: LICENSE
@@ -35,7 +35,7 @@ Simple publish and consume for Redis and Valkey streams, standalone or cluster.
 retries with backoff, a dead-letter queue, ack policies, middleware and lifecycle hooks, without the
 boilerplate.
 
-**Docs:** https://nimzymaina.github.io/rillkit/
+**Docs:** https://nimzymaina.github.io/RillKit/
 
 ```bash
 pip install rillkit             # plain dict bodies
@@ -47,7 +47,7 @@ pip install "rillkit[valkey]"   # optional valkey-py client
 from rillkit import Broker, Stream
 
 orders = Stream("orders", group="workers")
-broker = Broker.from_env()  # REDIS_URL, or REDIS_HOST / REDIS_PORT / REDIS_PASSWORD / REDIS_SSL
+broker = Broker.from_env()  # RILLKIT_URL, or RILLKIT_HOST/PORT/...; REDIS_* still work
 
 
 @broker.subscribe(orders, max_retries=3)
@@ -72,9 +72,11 @@ if __name__ == "__main__":
 - `on_startup`, `after_startup`, `on_shutdown`, `after_shutdown` hooks and graceful SIGTERM shutdown
 - Worker heartbeats: `broker.active_workers(stream)` includes idle workers
 - Stack `@broker.publisher(...)` under `@broker.subscribe(...)` to publish a handler's return value
-- The wire format is a single `data` field holding JSON, so plain redis-py producers interoperate
-- Redis or Valkey (`RILLKIT_BACKEND=valkey`), standalone or Cluster (`RILLKIT_MODE=cluster`), with
-  the stream and its DLQ in one hash slot so the move to the DLQ stays a transaction
+- The wire format is a single `data` field holding JSON, so plain redis-py or valkey-py producers interoperate
+- Redis or Valkey (`RILLKIT_BACKEND=valkey`), standalone or Cluster (`RILLKIT_MODE=cluster`)
+- Key builders map stream names to keys: the original names on one server, hash-tagged keys on a
+  cluster so a stream and its DLQ share a slot and the move to the DLQ stays a transaction, plus
+  prefixes and tenant ids (`HashTagKeys(prefix="billing", tenant="t-42")`)
 
 ## Development
 

{rillkit-0.2.0 → rillkit-0.3.0}/README.md

@@ -4,7 +4,7 @@ Simple publish and consume for Redis and Valkey streams, standalone or cluster.
 retries with backoff, a dead-letter queue, ack policies, middleware and lifecycle hooks, without the
 boilerplate.
 
-**Docs:** https://nimzymaina.github.io/rillkit/
+**Docs:** https://nimzymaina.github.io/RillKit/
 
 ```bash
 pip install rillkit             # plain dict bodies
@@ -16,7 +16,7 @@ pip install "rillkit[valkey]"   # optional valkey-py client
 from rillkit import Broker, Stream
 
 orders = Stream("orders", group="workers")
-broker = Broker.from_env()  # REDIS_URL, or REDIS_HOST / REDIS_PORT / REDIS_PASSWORD / REDIS_SSL
+broker = Broker.from_env()  # RILLKIT_URL, or RILLKIT_HOST/PORT/...; REDIS_* still work
 
 
 @broker.subscribe(orders, max_retries=3)
@@ -41,9 +41,11 @@ if __name__ == "__main__":
 - `on_startup`, `after_startup`, `on_shutdown`, `after_shutdown` hooks and graceful SIGTERM shutdown
 - Worker heartbeats: `broker.active_workers(stream)` includes idle workers
 - Stack `@broker.publisher(...)` under `@broker.subscribe(...)` to publish a handler's return value
-- The wire format is a single `data` field holding JSON, so plain redis-py producers interoperate
-- Redis or Valkey (`RILLKIT_BACKEND=valkey`), standalone or Cluster (`RILLKIT_MODE=cluster`), with
-  the stream and its DLQ in one hash slot so the move to the DLQ stays a transaction
+- The wire format is a single `data` field holding JSON, so plain redis-py or valkey-py producers interoperate
+- Redis or Valkey (`RILLKIT_BACKEND=valkey`), standalone or Cluster (`RILLKIT_MODE=cluster`)
+- Key builders map stream names to keys: the original names on one server, hash-tagged keys on a
+  cluster so a stream and its DLQ share a slot and the move to the DLQ stays a transaction, plus
+  prefixes and tenant ids (`HashTagKeys(prefix="billing", tenant="t-42")`)
 
 ## Development
 

{rillkit-0.2.0 → rillkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rillkit"
-version = "0.2.0"
+version = "0.3.0"
 description = "Simple publish and consume for Redis Streams: consumer groups, retries, DLQ, ack policies and middleware."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -31,10 +31,10 @@ pydantic = ["pydantic>=2.0"]
 valkey = ["valkey>=6.1.1,<6.3"]
 
 [project.urls]
-Homepage = "https://nimzymaina.github.io/rillkit/"
-Documentation = "https://nimzymaina.github.io/rillkit/"
-Repository = "https://github.com/NimzyMaina/rillkit"
-Issues = "https://github.com/NimzyMaina/rillkit/issues"
+Homepage = "https://nimzymaina.github.io/RillKit/"
+Documentation = "https://nimzymaina.github.io/RillKit/"
+Repository = "https://github.com/NimzyMaina/RillKit"
+Issues = "https://github.com/NimzyMaina/RillKit/issues"
 
 [dependency-groups]
 dev = [

{rillkit-0.2.0 → rillkit-0.3.0}/src/rillkit/__init__.py

@@ -18,7 +18,7 @@ from .middleware import BaseMiddleware, Idempotent, PublishCommand
 from .settings import Settings
 from .stream import Stream
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "AckMessage", "AckPolicy", "BaseMiddleware", "Broker", "Codec", "ConfigurationError",

{rillkit-0.2.0 → rillkit-0.3.0}/src/rillkit/broker.py

@@ -2,6 +2,7 @@ import logging
 import signal
 import sys
 import threading
+import time
 from collections.abc import Sequence
 from functools import partial
 from typing import Any, Callable, Optional
@@ -10,7 +11,7 @@ from .ack import AckPolicy
 from .clients import CLIENT_ERRORS, Client, is_cluster, run_together
 from .consumer import Subscriber, _text
 from .exceptions import PublishError
-from .keys import HashTagKeys, KeyBuilder, PlainKeys, glob_escape
+from .keys import HashTagKeys, KeyBuilder, PlainKeys
 from .middleware import BaseMiddleware, PublishCommand
 from .settings import Settings
 from .stream import Stream, StreamLike, as_stream
@@ -265,13 +266,14 @@ class Broker:
         """Consumer names with a live heartbeat. Unlike XINFO CONSUMERS this includes idle workers
         that have not received a message yet.
 
-        On a cluster every primary is scanned, and a key seen twice (during a slot migration) is
-        counted once. If a node cannot be reached the client error is raised rather than
-        returning a partial list."""
+        Reads the consumer registry (``broker.keys.consumers``), one sorted set per stream and
+        group, so it needs no ``SCAN`` and works for ACL users that may not list keys. Expiry is
+        judged by the workers' and caller's clocks, which should agree within the heartbeat TTL.
+        Workers older than 0.3, which write no registry entry, are not listed."""
         s = as_stream(stream)
-        prefix = self.keys.heartbeat_prefix(s, str(group or s.group))
-        found = {_text(k) for k in self.client.scan_iter(match=f"{glob_escape(prefix)}*")}
-        return sorted(k[len(prefix):] for k in found)
+        key = self.keys.consumers(s, str(group or s.group))
+        members: Any = self.client.zrangebyscore(key, int(time.time() * 1000), "+inf")
+        return sorted(_text(m) for m in members)
 
     def replay_dlq(self, stream: StreamLike, count: int = 100) -> int:
         """Move up to ``count`` entries from the DLQ back onto the stream. Returns how many.

{rillkit-0.2.0 → rillkit-0.3.0}/src/rillkit/consumer.py

@@ -135,6 +135,11 @@ class Subscriber:
     def heartbeat_key(self) -> str:
         return self.broker.keys.heartbeat(self.stream, self.group, self.consumer)
 
+    @property
+    def registry_key(self) -> str:
+        """The sorted set of live consumers of this stream and group (``active_workers``)."""
+        return self.broker.keys.consumers(self.stream, self.group)
+
     # lifecycle
 
     def setup(self) -> None:
@@ -196,7 +201,10 @@ class Subscriber:
         finally:
             if self.heartbeat:
                 try:
-                    self.client.delete(self.heartbeat_key)
+                    pipe = self.client.pipeline(transaction=False)
+                    pipe.delete(self.heartbeat_key)
+                    pipe.zrem(self.registry_key, self.consumer)
+                    pipe.execute()
                 except Exception as e:
                     log.error("could not remove heartbeat key: %s", e)
             log.info(
@@ -210,8 +218,14 @@ class Subscriber:
     def _beat(self) -> None:
         if not self.heartbeat:
             return
+        now = time.time()
         try:
-            self.client.set(self.heartbeat_key, int(time.time()), ex=self.heartbeat_ttl)
+            pipe = self.client.pipeline(transaction=False)
+            pipe.set(self.heartbeat_key, int(now), ex=self.heartbeat_ttl)
+            # the registry: this consumer is alive until now + ttl; drop entries already expired
+            pipe.zadd(self.registry_key, {self.consumer: int((now + self.heartbeat_ttl) * 1000)})
+            pipe.zremrangebyscore(self.registry_key, "-inf", int(now * 1000))
+            pipe.execute()
         except Exception as e:
             log.error("heartbeat failed: %s", e)
 

{rillkit-0.2.0 → rillkit-0.3.0}/src/rillkit/keys.py

@@ -6,6 +6,17 @@ and written. Every command rillkit sends goes through the broker's key builder.
 ``PlainKeys`` (the default outside a cluster) keeps the names rillkit has always used, so an
 existing deployment sees the same keys. ``HashTagKeys`` (the default on a cluster) puts a stream,
 its DLQ and its heartbeats in one hash slot so the move to the DLQ can stay a transaction.
+
+Reserved for planned control-plane keys (worker state, directive dedup, node heartbeats, logs and
+producer cordons), so that adding them never moves or collides with existing keys:
+
+- ``PlainKeys``: names under ``rillkit:`` other than ``rillkit:workers:``, ``rillkit:done:`` and
+  ``rillkit:consumers:``,
+  namely ``rillkit:state:``, ``rillkit:dedup:``, ``rillkit:nodes:``, ``rillkit:ctl:``,
+  ``rillkit:logs:`` and ``rillkit:cordon:``.
+- ``HashTagKeys``: the control tag ``{<tenant>:}`` (``{:}`` without a tenant) inside each
+  prefix, and the suffixes ``logs`` and ``cordon`` after a stream's tag. No stream can produce
+  the control tag: stream names are non-empty and their colons are percent-encoded.
 """
 
 from typing import Optional
@@ -14,6 +25,8 @@ from .exceptions import ConfigurationError
 from .stream import Stream
 
 HEARTBEAT_PREFIX = "rillkit:workers:"
+IDEMPOTENCY_PREFIX = "rillkit:done:"
+CONSUMERS_PREFIX = "rillkit:consumers:"
 _GLOB_SPECIAL = str.maketrans({c: f"\\{c}" for c in "*?[]\\"})
 
 
@@ -42,6 +55,19 @@ class KeyBuilder:
     def heartbeat(self, stream: Stream, group: str, consumer: str) -> str:
         return f"{self.heartbeat_prefix(stream, group)}{consumer}"
 
+    def idempotency(self, stream: Stream, key: str) -> str:
+        """Where ``Idempotent`` records that ``key`` was processed for ``stream``.
+
+        The default is the key rillkit has always used, so custom builders that do not override
+        it keep their existing markers."""
+        return f"{IDEMPOTENCY_PREFIX}{stream.name}:{key}"
+
+    def consumers(self, stream: Stream, group: str) -> str:
+        """The registry of live consumers of ``stream`` in ``group``: a sorted set of consumer
+        names scored by when their heartbeat expires (milliseconds). ``active_workers`` reads it,
+        so finding workers never needs ``SCAN``."""
+        return f"{CONSUMERS_PREFIX}{_escape_plain(stream.name)}:{group}"
+
 
 class PlainKeys(KeyBuilder):
     """The stream name is the key; the DLQ is ``dlq`` or ``<name>-dlq``. rillkit's original layout.
@@ -63,6 +89,11 @@ class PlainKeys(KeyBuilder):
         return "PlainKeys()"
 
 
+def _escape_plain(text: str) -> str:
+    """Encode ``%`` and ``:`` so a stream name never runs into the group name after it."""
+    return text.replace("%", "%25").replace(":", "%3A")
+
+
 def _escape(text: str, colon: bool = False) -> str:
     """Percent-encode the characters that would end or split a hash tag."""
     out = text.replace("%", "%25").replace("{", "%7B").replace("}", "%7D")
@@ -75,11 +106,17 @@ class HashTagKeys(KeyBuilder):
         rk:{orders}:stream
         rk:{orders}:dlq                 (or rk:{orders}:dlq:<custom name>)
         rk:{orders}:workers:<group>:<consumer>
+        rk:{orders}:done:<idempotency key>
+        rk:{orders}:consumers:<group>   (registry of live consumers)
 
     ``tenant`` adds an opaque id inside the tag (``rk:{t-42:orders}:stream``) so tenants' keys
     never collide. It is for placement and naming only, not access control: take it from trusted
-    server-side context, never from a message. Braces, ``%`` and (in the tenant) ``:`` are
-    percent-encoded, so no name can escape or split the tag.
+    server-side context, never from a message.
+
+    Inside the tag, ``%``, ``{``, ``}`` and ``:`` are percent-encoded in both the stream name and
+    the tenant. A tag therefore holds exactly one unencoded ``:`` when there is a tenant and none
+    when there is not, so no name can escape the tag, and no stream name can produce another
+    tenant's keys or a tenant-scoped key.
 
     A custom ``Stream(dlq=...)`` becomes a suffix of the stream's own tag, so two streams that
     share a DLQ name on a single server get one DLQ each here.
@@ -94,7 +131,10 @@ class HashTagKeys(KeyBuilder):
         self.tenant = tenant
 
     def tag(self, stream: Stream) -> str:
-        name = _escape(stream.name)
+        if not stream.name:
+            # "{}" is not a hash tag, so the stream's keys would land in different slots
+            raise ConfigurationError("hash-tagged keys need a non-empty stream name")
+        name = _escape(stream.name, colon=True)
         if self.tenant is not None:
             name = f"{_escape(self.tenant, colon=True)}:{name}"
         return f"{{{name}}}"
@@ -112,6 +152,12 @@ class HashTagKeys(KeyBuilder):
     def heartbeat_prefix(self, stream: Stream, group: str) -> str:
         return f"{self._base(stream)}:workers:{group}:"
 
+    def idempotency(self, stream: Stream, key: str) -> str:
+        return f"{self._base(stream)}:done:{key}"
+
+    def consumers(self, stream: Stream, group: str) -> str:
+        return f"{self._base(stream)}:consumers:{group}"
+
     def __repr__(self) -> str:
         return f"HashTagKeys(prefix={self.prefix!r}, tenant={self.tenant!r})"
 

{rillkit-0.2.0 → rillkit-0.3.0}/src/rillkit/middleware.py

@@ -47,23 +47,30 @@ class BaseMiddleware:
 class Idempotent(BaseMiddleware):
     """Skip messages whose key was already processed successfully.
 
-    Redis delivers at least once, so a crash after the handler finished but before the ack means a
-    redelivery. The key is stored with ``ttl`` seconds once the handler returns without raising.
+    Streams deliver at least once, so a crash after the handler finished but before the ack means
+    a redelivery. The key is stored with ``ttl`` seconds once the handler returns without raising.
 
         broker = Broker(middlewares=[Idempotent(key=lambda m: m.body["request_id"])])
+
+    By default the marker's key comes from the broker's key builder (``broker.keys.idempotency``):
+    ``rillkit:done:<stream>:<key>`` with plain keys, ``rk:{<stream>}:done:<key>`` with hash-tagged
+    keys, so markers follow the stream's prefix and tenant. Pass ``prefix`` to use
+    ``<prefix><stream>:<key>`` instead.
     """
 
     def __init__(
         self,
         key: Callable[[Message], str],
         ttl: int = 7 * 24 * 3600,
-        prefix: str = "rillkit:done:",
+        prefix: Optional[str] = None,
     ):
         self.key = key
         self.ttl = ttl
         self.prefix = prefix
 
     def _redis_key(self, msg: Message) -> str:
+        if self.prefix is None:
+            return self.broker.keys.idempotency(msg.stream, self.key(msg))
         return f"{self.prefix}{msg.stream.name}:{self.key(msg)}"
 
     def consume_scope(self, call_next: Callable[[Message], Any], msg: Message) -> Any:

{rillkit-0.2.0 → rillkit-0.3.0}/src/rillkit/settings.py

@@ -1,3 +1,4 @@
+import logging
 import os
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field, fields
@@ -8,7 +9,11 @@ from .clients import BACKENDS, MODES, Client, create_client, parse_node
 from .exceptions import ConfigurationError
 from .keys import KEY_LAYOUTS, HashTagKeys, KeyBuilder, PlainKeys, key_builder
 
+log = logging.getLogger("rillkit")
+
 _SECRET_WORDS = ("password", "secret", "token", "credential")
+# Fields a url replaces, so their variables are not used when one is set.
+_URL_REPLACES = ("HOST", "PORT", "DB", "USERNAME", "PASSWORD", "SSL")
 
 
 def _seconds(value: Optional[str], default: Optional[float]) -> Optional[float]:
@@ -44,9 +49,10 @@ def redact_url(url: str) -> str:
 class Settings:
     """Connection settings: which server, which client library, and how to connect.
 
-    ``Settings.from_env()`` reads REDIS_URL, or REDIS_HOST/PORT/DB/USERNAME/PASSWORD/SSL, plus
-    REDIS_SOCKET_TIMEOUT (seconds, or ``none``), and the RILLKIT_URL, RILLKIT_BACKEND,
-    RILLKIT_MODE, RILLKIT_CLUSTER_NODES and RILLKIT_KEY_LAYOUT variables.
+    ``Settings.from_env()`` reads RILLKIT_URL, or RILLKIT_HOST/PORT/DB/USERNAME/PASSWORD/SSL,
+    plus RILLKIT_SOCKET_TIMEOUT (seconds, or ``none``), RILLKIT_BACKEND, RILLKIT_MODE,
+    RILLKIT_CLUSTER_NODES and RILLKIT_KEY_LAYOUT. Each connection variable falls back to its
+    REDIS_ name (REDIS_URL, REDIS_HOST, ...), so 0.1 configurations keep working.
 
     ``socket_timeout`` is set explicitly because consumers block in ``XREADGROUP`` for up to
     ``block_ms`` and the client must wait longer than that. redis-py 8 changed its own default to
@@ -94,21 +100,34 @@ class Settings:
     def from_env(cls, prefix: str = "REDIS_", **overrides: Any) -> "Settings":
         """Settings from environment variables. Keyword arguments override what the env says.
 
-        ``RILLKIT_URL`` wins over ``<prefix>URL``. Without either, the host/port/db/password
-        variables are used. When a url is found, ``<prefix>USERNAME`` and ``<prefix>PASSWORD`` are
-        not read, as before: put credentials in the url.
+        Every connection variable has a ``RILLKIT_`` name and an older ``<prefix>`` name
+        (``REDIS_`` by default); a non-empty ``RILLKIT_`` value wins. A url (``RILLKIT_URL``, else
+        ``<prefix>URL``) wins over the separate host, port, db, username, password and ssl
+        variables, which are then not read; setting one of their ``RILLKIT_`` names alongside a
+        url logs a warning.
         """
         env = os.environ
-        url = env.get("RILLKIT_URL") or env.get(f"{prefix}URL") or None
+
+        def get(name: str, default: Optional[str] = None) -> Optional[str]:
+            value = env.get(f"RILLKIT_{name}")
+            if value:
+                return value
+            return env.get(f"{prefix}{name}", default)
+
+        url = get("URL") or None
+        if url:
+            ignored = [f"RILLKIT_{n}" for n in _URL_REPLACES if env.get(f"RILLKIT_{n}")]
+            if ignored:
+                log.warning("%s ignored: a url is set and provides them", ", ".join(ignored))
         values: dict[str, Any] = {
             "url": url,
-            "host": env.get(f"{prefix}HOST", "localhost"),
-            "port": int(env.get(f"{prefix}PORT", 6379)),
-            "db": int(env.get(f"{prefix}DB", 0)),
-            "password": None if url else env.get(f"{prefix}PASSWORD"),
-            "username": None if url else env.get(f"{prefix}USERNAME"),
-            "ssl": env.get(f"{prefix}SSL", "").lower() in ("1", "true", "yes"),
-            "socket_timeout": _seconds(env.get(f"{prefix}SOCKET_TIMEOUT"), 15.0),
+            "host": get("HOST", "localhost"),
+            "port": int(get("PORT", "6379") or 6379),
+            "db": int(get("DB", "0") or 0),
+            "password": None if url else get("PASSWORD"),
+            "username": None if url else get("USERNAME"),
+            "ssl": (get("SSL", "") or "").lower() in ("1", "true", "yes"),
+            "socket_timeout": _seconds(get("SOCKET_TIMEOUT"), 15.0),
             "backend": env.get("RILLKIT_BACKEND") or "redis",
             "mode": env.get("RILLKIT_MODE") or "standalone",
             "cluster_nodes": _nodes(env.get("RILLKIT_CLUSTER_NODES")),

{rillkit-0.2.0 → rillkit-0.3.0}/tests/helpers.py

@@ -34,6 +34,16 @@ def hk(stream: StreamLike, group: str, consumer: str) -> str:
     return KEYS.heartbeat(as_stream(stream), group, consumer)
 
 
+def ck(stream: StreamLike, group: str) -> str:
+    """Physical key of the consumer registry of a stream and group."""
+    return KEYS.consumers(as_stream(stream), group)
+
+
+def ik(stream: StreamLike, key: str) -> str:
+    """Physical key of an Idempotent marker."""
+    return KEYS.idempotency(as_stream(stream), key)
+
+
 def wait_until(cond: Callable[[], Any], timeout: float = 10.0, interval: float = 0.02) -> bool:
     """Poll ``cond`` until it is truthy. Returns the final truthiness instead of raising."""
     deadline = time.monotonic() + timeout

rillkit-0.3.0/tests/test_acl.py

@@ -0,0 +1,115 @@
+"""A whole worker running as a tenant ACL user that may touch only its own keys and not list any.
+
+This is the isolation model for several tenants on one server or cluster: hash-tagged keys with a
+tenant, and an allowlist ACL user per tenant. It proves the allowlist is enough for everything
+rillkit does, and that it hides other tenants' keys, including their names.
+"""
+
+import logging
+import uuid
+from collections.abc import Iterator
+from typing import Any, Callable
+
+import pytest
+
+from helpers import MODE, fast, wait_until
+from rillkit import Broker, HashTagKeys, Idempotent, Message, Settings, Stream
+from rillkit.clients import CLIENT_ERRORS
+
+PREFIX = "acl"
+
+
+def tenant_rule(tenant: str, password: str) -> list[str]:
+    """The per-tenant ACL rule documented in the Keys guide."""
+    scope = f"{PREFIX}:{{{tenant}:*"
+    return [
+        "on", f">{password}", "resetkeys", "resetchannels", f"~{scope}", f"&{scope}",
+        "-@all", "+@connection", "+@stream", "+@string", "+@hash", "+@sortedset", "+@transaction",
+        "+del", "+exists",
+        "+ssubscribe", "+sunsubscribe", "+spublish", "+subscribe", "+unsubscribe", "+publish",
+        "+cluster|slots", "+cluster|shards", "+cluster|nodes", "+readonly", "+readwrite",
+    ]
+
+
+def _every_node(r: Any) -> list[Any]:
+    """ACL users are per server: on a cluster every node, replicas included, needs the user."""
+    if MODE != "cluster":
+        return [r]
+    return [
+        getattr(n, "redis_connection", None) or n.valkey_connection
+        for n in r.get_nodes()
+    ]
+
+
+@pytest.fixture
+def tenant_user(r: Any) -> Iterator[Callable[[str], tuple[str, str]]]:
+    created: list[str] = []
+
+    def make(tenant: str) -> tuple[str, str]:
+        user, password = f"rk-{tenant}-{uuid.uuid4().hex[:6]}", uuid.uuid4().hex
+        for node in _every_node(r):
+            node.execute_command("ACL", "SETUSER", user, *tenant_rule(tenant, password))
+        created.append(user)
+        return user, password
+
+    yield make
+    for user in created:
+        for node in _every_node(r):
+            node.execute_command("ACL", "DELUSER", user)
+
+
+def test_a_full_worker_runs_as_a_tenant_acl_user(server_settings, tenant_user, r, caplog):
+    tenant = f"t-{uuid.uuid4().hex[:6]}"
+    user, password = tenant_user(tenant)
+    keys = HashTagKeys(prefix=PREFIX, tenant=tenant)
+    settings: Settings = server_settings(username=user, password=password)
+    broker = Broker(settings=settings, keys=keys,
+                    middlewares=[Idempotent(key=lambda m: m.body["rid"])])
+    orders = Stream("orders", group="billing")
+    handled: list = []
+    attempts: list = []
+
+    @broker.subscribe(orders, consumer="worker-7", max_retries=1, **fast())
+    def handle(order: dict, msg: Message):
+        attempts.append(order["rid"])
+        if order.get("fail"):
+            raise ValueError("bad order")
+        handled.append(order["rid"])
+
+    with caplog.at_level(logging.ERROR, logger="rillkit"):
+        broker.start()
+        broker.publish(orders, {"rid": "a"})
+        broker.publish(orders, {"rid": "a"})  # duplicate, skipped by Idempotent
+        broker.publish(orders, {"rid": "b", "fail": True})  # retried once, then dead-lettered
+        assert wait_until(lambda: broker.client.xlen(keys.dlq(orders)) == 1, 15)
+        assert wait_until(lambda: broker.active_workers(orders) == ["worker-7"])
+        assert handled == ["a"]
+        assert attempts.count("b") == 2
+        assert broker.client.exists(keys.idempotency(orders, "a"))
+        broker.stop(5)
+    unexpected = [rec.getMessage() for rec in caplog.records
+                  if "bad order" not in rec.getMessage()]
+    assert unexpected == []  # no permission errors in the loop, heartbeats or DLQ moves
+
+    replayer = Broker(settings=server_settings(username=user, password=password), keys=keys)
+    try:
+        assert replayer.replay_dlq(orders) == 1
+        assert replayer.active_workers(orders) == []  # removed from the registry on stop
+    finally:
+        replayer.client.close()
+
+
+def test_a_tenant_user_cannot_see_other_tenants(server_settings, tenant_user, r):
+    other = HashTagKeys(prefix=PREFIX, tenant="other-tenant")
+    secret = other.stream(Stream("payroll"))
+    r.xadd(secret, {"data": "{}"})
+    user, password = tenant_user(f"t-{uuid.uuid4().hex[:6]}")
+    client = server_settings(username=user, password=password).client()
+    try:
+        for attempt in (lambda: client.xlen(secret), lambda: list(client.scan_iter("*")),
+                        lambda: client.randomkey()):
+            with pytest.raises(CLIENT_ERRORS, match="(?i)noperm|permission"):
+                attempt()
+    finally:
+        client.close()
+        r.delete(secret)

{rillkit-0.2.0 → rillkit-0.3.0}/tests/test_cluster.py

@@ -76,7 +76,7 @@ def test_plain_keys_on_a_cluster_dead_letter_in_two_ordered_steps(
         broker.stop(5)
 
 
-def test_active_workers_scans_every_primary(server_settings, r, name):
+def test_active_workers_finds_consumers_on_every_primary(server_settings, r, name):
     broker = Broker(settings=server_settings(key_layout="plain"))
     consumers = [f"c{i}" for i in range(12)]
     for c in consumers:
@@ -89,7 +89,7 @@ def test_active_workers_scans_every_primary(server_settings, r, name):
         assert len(owners) > 1  # the keys really are spread over several primaries
     finally:
         broker.stop(5)
-    assert broker.active_workers(name, "g") == []
+    assert Broker(client=r, keys=PlainKeys()).active_workers(name, "g") == []
 
 
 def test_active_workers_on_an_empty_cluster_stream(broker, name):

rillkit-0.3.0/tests/test_keys.py

@@ -0,0 +1,135 @@
+import pytest
+from redis.crc import key_slot
+
+from rillkit import ConfigurationError, HashTagKeys, PlainKeys, Stream
+from rillkit.keys import glob_escape
+
+
+def slot(key: str) -> int:
+    return key_slot(key.encode())
+
+
+def test_plain_keys_are_the_original_names():
+    keys = PlainKeys()
+    s = Stream("orders", group="g")
+    assert keys.stream(s) == "orders"
+    assert keys.dlq(s) == "orders-dlq"
+    assert keys.dlq(Stream("orders", dlq="dead")) == "dead"
+    assert keys.heartbeat(s, "g", "w1") == "rillkit:workers:orders:g:w1"
+
+
+def test_hash_tag_layout():
+    keys = HashTagKeys()
+    s = Stream("orders")
+    assert keys.stream(s) == "rk:{orders}:stream"
+    assert keys.dlq(s) == "rk:{orders}:dlq"
+    assert keys.dlq(Stream("orders", dlq="dead")) == "rk:{orders}:dlq:dead"
+    assert keys.heartbeat(s, "g", "w1") == "rk:{orders}:workers:g:w1"
+
+
+@pytest.mark.parametrize("name", ["orders", "a}b", "{x}", "a{b", "x:y", "100%", "}"])
+def test_stream_dlq_and_heartbeats_share_a_slot(name):
+    keys = HashTagKeys(tenant="t-1")
+    for s in (Stream(name), Stream(name, dlq="custom}{")):
+        slots = {slot(keys.stream(s)), slot(keys.dlq(s)), slot(keys.heartbeat(s, "g", "c{1}"))}
+        assert len(slots) == 1, name
+
+
+def test_idempotency_keys():
+    s = Stream("orders")
+    assert PlainKeys().idempotency(s, "req-1") == "rillkit:done:orders:req-1"
+    assert HashTagKeys().idempotency(s, "req-1") == "rk:{orders}:done:req-1"
+    assert (HashTagKeys(prefix="shop", tenant="t-42").idempotency(s, "req-1")
+            == "shop:{t-42:orders}:done:req-1")
+
+
+def test_consumer_registry_keys():
+    s = Stream("orders:eu")
+    assert PlainKeys().consumers(s, "billing") == "rillkit:consumers:orders%3Aeu:billing"
+    assert HashTagKeys().consumers(Stream("orders"), "billing") == "rk:{orders}:consumers:billing"
+    assert (HashTagKeys(prefix="shop", tenant="t-42").consumers(Stream("orders"), "billing")
+            == "shop:{t-42:orders}:consumers:billing")
+    # a stream name with a colon can't run into the group name
+    assert (PlainKeys().consumers(Stream("a:b"), "c")
+            != PlainKeys().consumers(Stream("a"), "b:c"))
+
+
+def test_custom_builders_keep_the_original_idempotency_key():
+    from rillkit import KeyBuilder
+
+    class Mine(KeyBuilder):
+        def stream(self, stream):
+            return f"x:{stream.name}"
+
+    assert Mine().idempotency(Stream("orders"), "k") == "rillkit:done:orders:k"
+
+
+def test_colons_in_stream_names_are_encoded_inside_the_tag():
+    assert HashTagKeys().stream(Stream("orders:eu")) == "rk:{orders%3Aeu}:stream"
+    assert HashTagKeys(tenant="t-42").stream(Stream("orders:eu")) == "rk:{t-42:orders%3Aeu}:stream"
+    assert HashTagKeys().stream(Stream("orders")) == "rk:{orders}:stream"  # unchanged
+
+
+def test_no_stream_name_can_produce_a_tenant_key():
+    # the 0.2.0 collision: no tenant + "t-42:orders" == tenant "t-42" + "orders"
+    assert (HashTagKeys().stream(Stream("t-42:orders"))
+            != HashTagKeys(tenant="t-42").stream(Stream("orders")))
+
+
+def test_keys_are_unique_across_tenants_and_names():
+    import itertools
+
+    parts = ["a", "b", ":", "a:b", "b:", ":a", "%", "%3A", "{", "}", "{a}", "a}b"]
+    tenants = [None, *parts]
+    seen = {}
+    for tenant, name in itertools.product(tenants, parts):
+        keys = HashTagKeys(tenant=tenant)
+        s = Stream(name, dlq="d")
+        for kind, key in (("stream", keys.stream(s)), ("dlq", keys.dlq(s)),
+                          ("hb", keys.heartbeat(s, "g", "c")), ("done", keys.idempotency(s, "k")),
+                          ("consumers", keys.consumers(s, "g"))):
+            assert seen.setdefault(key, (tenant, name, kind)) == (tenant, name, kind), key
+        assert len({slot(keys.stream(s)), slot(keys.dlq(s)), slot(keys.idempotency(s, "k")),
+                    slot(keys.consumers(s, "g"))}) == 1
+
+
+def test_no_stream_tag_can_equal_the_reserved_control_tag():
+    # Control-plane keys will live under {<tenant>:} ({:} without a tenant). A stream tag is
+    # {name} or {tenant:name} with a non-empty, colon-encoded name, so it never ends with ":".
+    import itertools
+
+    parts = ["a", ":", "a:", ":a", "%3A", "{", "}", "%", "t-42"]
+    for tenant, name in itertools.product([None, *parts], parts):
+        tag = HashTagKeys(tenant=tenant).tag(Stream(name))
+        assert not tag.endswith(":}"), (tenant, name, tag)
+        assert tag != "{:}"
+
+
+def test_empty_stream_name_is_refused():
+    with pytest.raises(ConfigurationError, match="non-empty stream name"):
+        HashTagKeys().stream(Stream(""))
+
+
+def test_braces_cannot_merge_two_streams():
+    keys = HashTagKeys()
+    assert keys.stream(Stream("a}b")) != keys.stream(Stream("a"))
+    assert keys.tag(Stream("a}b")) == "{a%7Db}"
+
+
+def test_tenants_never_collide():
+    a = HashTagKeys(tenant="t:x").stream(Stream("y"))
+    b = HashTagKeys(tenant="t").stream(Stream("x:y"))
+    assert a != b
+    assert HashTagKeys(tenant="t-42").stream(Stream("orders")) == "rk:{t-42:orders}:stream"
+
+
+def test_prefix_and_tenant_validation():
+    with pytest.raises(ConfigurationError):
+        HashTagKeys(prefix="a{b")
+    with pytest.raises(ConfigurationError):
+        HashTagKeys(tenant="")
+    assert HashTagKeys(prefix="").stream(Stream("o")) == "{o}:stream"
+
+
+def test_glob_escape():
+    assert glob_escape("a*b?[c]\\") == "a\\*b\\?\\[c\\]\\\\"

{rillkit-0.2.0 → rillkit-0.3.0}/tests/test_lifecycle.py

@@ -212,7 +212,7 @@ def test_heartbeat_registered_while_running_and_removed_after_stop(broker: Broke
     assert 0 < r.ttl(key) <= 60
     broker.stop(timeout=5)
     assert not r.exists(key)
-    assert broker.active_workers(name, "g") == []
+    assert Broker(client=r).active_workers(name, "g") == []  # a stopped broker's client is closed
 
 
 def test_active_workers_uses_stream_group_by_default(broker: Broker, name):
@@ -319,3 +319,41 @@ def test_injected_client_is_used_as_is(server_settings):
         assert broker.keys.stream(Stream("o")) == "app:{o}:stream"
     finally:
         client.close()
+
+
+def test_registry_lists_live_consumers_without_scan(broker: Broker, r, name, monkeypatch):
+    import time as _time
+
+    from helpers import ck
+
+    @broker.subscribe(name, group="g", consumer="worker-7", heartbeat_ttl=30, **fast())
+    def handle(body): ...
+
+    def no_scan(*args, **kwargs):
+        raise AssertionError("active_workers must not SCAN")
+
+    monkeypatch.setattr(broker.client, "scan_iter", no_scan)
+    broker.start()
+    assert wait_until(lambda: broker.active_workers(name, "g") == ["worker-7"])
+    expires = r.zscore(ck(name, "g"), "worker-7")
+    assert 25_000 < expires - _time.time() * 1000 <= 30_000  # alive until now + heartbeat_ttl
+    broker.stop(timeout=5)
+    assert r.zscore(ck(name, "g"), "worker-7") is None  # removed on a clean stop
+    assert Broker(client=r).active_workers(name, "g") == []
+
+
+def test_registry_ignores_expired_entries_and_beats_prune_them(broker: Broker, r, name):
+    import time as _time
+
+    from helpers import ck
+
+    now_ms = int(_time.time() * 1000)
+    r.zadd(ck(name, "g"), {"crashed": now_ms - 1000, "alive-elsewhere": now_ms + 60_000})
+    assert broker.active_workers(name, "g") == ["alive-elsewhere"]
+
+    @broker.subscribe(name, group="g", consumer="worker-7", **fast())
+    def handle(body): ...
+
+    broker.start()
+    assert wait_until(lambda: r.zscore(ck(name, "g"), "crashed") is None)  # pruned by a beat
+    assert broker.active_workers(name, "g") == ["alive-elsewhere", "worker-7"]

{rillkit-0.2.0 → rillkit-0.3.0}/tests/test_middleware.py

@@ -1,8 +1,17 @@
 import json
 from typing import Optional
 
-from helpers import dk, entries, fast, pending, read_count, settle, sk, wait_until
-from rillkit import AckMessage, BaseMiddleware, Idempotent, Message, PublishCommand, Stream
+from helpers import dk, entries, fast, ik, pending, read_count, settle, sk, wait_until
+from rillkit import (
+    AckMessage,
+    BaseMiddleware,
+    HashTagKeys,
+    Idempotent,
+    Message,
+    PlainKeys,
+    PublishCommand,
+    Stream,
+)
 
 
 class Recorder(BaseMiddleware):
@@ -320,8 +329,8 @@ def test_idempotent_skips_duplicates(make_broker, r, name):
         broker.publish(name, {"rid": rid})
     assert wait_until(lambda: len(processed) == 5 and pending(r, name) == 0)
     assert handled == ["a", "b"]
-    assert r.exists(f"rillkit:done:{name}:a")
-    assert 0 < r.ttl(f"rillkit:done:{name}:a") <= 7 * 24 * 3600
+    assert r.exists(ik(name, "a"))
+    assert 0 < r.ttl(ik(name, "a")) <= 7 * 24 * 3600
 
 
 def test_idempotent_does_not_record_failed_attempts(make_broker, r, name):
@@ -340,3 +349,50 @@ def test_idempotent_does_not_record_failed_attempts(make_broker, r, name):
     assert wait_until(lambda: len(attempts) == 2 and pending(r, name) == 0)
     assert r.exists(f"idem:{name}:x")
     assert r.ttl(f"idem:{name}:x") <= 60
+
+
+def test_idempotent_markers_follow_the_broker_key_builder(make_broker, r, name):
+    done = []
+    broker = make_broker(
+        keys=HashTagKeys(prefix="app", tenant="t-1"),
+        middlewares=[Idempotent(key=lambda m: m.body["rid"])],
+    )
+
+    @broker.subscribe(name, group="g", **fast())
+    def handle(body):
+        done.append(body["rid"])
+
+    broker.start()
+    broker.publish(name, {"rid": "a"})
+    assert wait_until(lambda: done == ["a"])
+    marker = f"app:{{t-1:{name}}}:done:a"
+    assert wait_until(lambda: r.exists(marker))
+    assert not r.exists(f"rillkit:done:{name}:a")
+
+
+def test_tenants_do_not_share_idempotent_markers(make_broker, r, name):
+    handled = {"t-1": [], "t-2": []}
+    brokers = []
+    for tenant in handled:
+        b = make_broker(keys=HashTagKeys(tenant=tenant),
+                        middlewares=[Idempotent(key=lambda m: m.body["rid"])])
+        def make_handler(t):
+            def handle(body):
+                handled[t].append(body["rid"])
+            return handle
+
+        b.subscribe(name, group="g", consumer=tenant, **fast())(make_handler(tenant))
+        b.start()
+        brokers.append(b)
+    for b in brokers:
+        b.publish(name, {"rid": "same-request"})  # same stream name and key, per tenant
+    assert wait_until(lambda: handled == {"t-1": ["same-request"], "t-2": ["same-request"]})
+
+
+def test_idempotent_with_plain_keys_keeps_the_original_marker(make_broker, r, name):
+    broker = make_broker(keys=PlainKeys(), middlewares=[Idempotent(key=lambda m: m.body["rid"])])
+    done = []
+    broker.subscribe(name, group="g", **fast())(lambda body: done.append(1))
+    broker.start()
+    broker.publish(name, {"rid": "a"})
+    assert wait_until(lambda: done and r.exists(f"rillkit:done:{name}:a"))

{rillkit-0.2.0 → rillkit-0.3.0}/tests/test_settings.py

@@ -6,7 +6,7 @@ from helpers import BACKEND
 from rillkit import Broker, ConfigurationError, HashTagKeys, PlainKeys, Settings
 
 KEYS = ["URL", "HOST", "PORT", "DB", "USERNAME", "PASSWORD", "SSL", "SOCKET_TIMEOUT"]
-RILLKIT_KEYS = ["URL", "BACKEND", "MODE", "CLUSTER_NODES", "KEY_LAYOUT"]
+RILLKIT_KEYS = ["URL", "BACKEND", "MODE", "CLUSTER_NODES", "KEY_LAYOUT"] + KEYS[1:]
 
 
 @pytest.fixture(autouse=True)
@@ -143,6 +143,66 @@ def test_keyword_arguments_override_the_environment(monkeypatch):
     assert (s.backend, s.host, s.client_kwargs) == ("redis", "explicit", {"client_name": "x"})
 
 
+def test_rillkit_connection_variables(monkeypatch):
+    for key, value in {"HOST": "rk.internal", "PORT": "6390", "DB": "4", "USERNAME": "app",
+                       "PASSWORD": "pw", "SSL": "yes", "SOCKET_TIMEOUT": "30"}.items():
+        monkeypatch.setenv(f"RILLKIT_{key}", value)
+    s = Settings.from_env()
+    assert (s.url, s.host, s.port, s.db) == (None, "rk.internal", 6390, 4)
+    assert (s.username, s.password, s.ssl, s.socket_timeout) == ("app", "pw", True, 30.0)
+    kwargs = kwargs_of(s)
+    assert (kwargs["host"], kwargs["port"], kwargs["db"]) == ("rk.internal", 6390, 4)
+    assert (kwargs["username"], kwargs["password"]) == ("app", "pw")
+
+
+@pytest.mark.parametrize("key,rillkit,legacy,field,expected", [
+    ("HOST", "new", "old", "host", "new"),
+    ("PORT", "7000", "6000", "port", 7000),
+    ("DB", "2", "1", "db", 2),
+    ("USERNAME", "new", "old", "username", "new"),
+    ("PASSWORD", "new", "old", "password", "new"),
+    ("SSL", "true", "false", "ssl", True),
+    ("SSL", "false", "true", "ssl", False),
+    ("SOCKET_TIMEOUT", "none", "30", "socket_timeout", None),
+])
+def test_rillkit_variable_wins_over_its_redis_name(monkeypatch, key, rillkit, legacy, field,
+                                                    expected):
+    monkeypatch.setenv(f"RILLKIT_{key}", rillkit)
+    monkeypatch.setenv(f"REDIS_{key}", legacy)
+    assert getattr(Settings.from_env(), field) == expected
+    monkeypatch.setenv(f"MYAPP_{key}", legacy)
+    assert getattr(Settings.from_env("MYAPP_"), field) == expected
+
+
+def test_empty_rillkit_variable_falls_back_to_the_redis_name(monkeypatch):
+    monkeypatch.setenv("RILLKIT_HOST", "")
+    monkeypatch.setenv("REDIS_HOST", "legacy")
+    assert Settings.from_env().host == "legacy"
+
+
+def test_redis_variables_still_work_without_rillkit_ones(monkeypatch):
+    monkeypatch.setenv("REDIS_HOST", "legacy")
+    monkeypatch.setenv("REDIS_SOCKET_TIMEOUT", "none")
+    s = Settings.from_env()
+    assert (s.host, s.socket_timeout) == ("legacy", None)
+
+
+def test_rillkit_fields_next_to_a_url_are_ignored_with_a_warning(monkeypatch, caplog):
+    import logging
+
+    monkeypatch.setenv("REDIS_URL", "redis://from-url:1234/0")
+    monkeypatch.setenv("RILLKIT_HOST", "ignored")
+    monkeypatch.setenv("RILLKIT_PASSWORD", "ignored-secret")
+    monkeypatch.setenv("RILLKIT_SOCKET_TIMEOUT", "30")  # not replaced by a url, so used
+    with caplog.at_level(logging.WARNING, logger="rillkit"):
+        s = Settings.from_env()
+    assert (s.url, s.password, s.socket_timeout) == ("redis://from-url:1234/0", None, 30.0)
+    assert kwargs_of(s)["host"] == "from-url"
+    [record] = caplog.records
+    assert "RILLKIT_HOST" in record.getMessage() and "RILLKIT_PASSWORD" in record.getMessage()
+    assert "ignored-secret" not in record.getMessage()
+
+
 def test_username_from_env_without_url(monkeypatch):
     monkeypatch.setenv("REDIS_USERNAME", "app")
     monkeypatch.setenv("REDIS_PASSWORD", "pw")

rillkit-0.2.0/tests/test_keys.py

@@ -1,60 +0,0 @@
-import pytest
-from redis.crc import key_slot
-
-from rillkit import ConfigurationError, HashTagKeys, PlainKeys, Stream
-from rillkit.keys import glob_escape
-
-
-def slot(key: str) -> int:
-    return key_slot(key.encode())
-
-
-def test_plain_keys_are_the_original_names():
-    keys = PlainKeys()
-    s = Stream("orders", group="g")
-    assert keys.stream(s) == "orders"
-    assert keys.dlq(s) == "orders-dlq"
-    assert keys.dlq(Stream("orders", dlq="dead")) == "dead"
-    assert keys.heartbeat(s, "g", "w1") == "rillkit:workers:orders:g:w1"
-
-
-def test_hash_tag_layout():
-    keys = HashTagKeys()
-    s = Stream("orders")
-    assert keys.stream(s) == "rk:{orders}:stream"
-    assert keys.dlq(s) == "rk:{orders}:dlq"
-    assert keys.dlq(Stream("orders", dlq="dead")) == "rk:{orders}:dlq:dead"
-    assert keys.heartbeat(s, "g", "w1") == "rk:{orders}:workers:g:w1"
-
-
-@pytest.mark.parametrize("name", ["orders", "a}b", "{x}", "a{b", "x:y", "100%", "}", ""])
-def test_stream_dlq_and_heartbeats_share_a_slot(name):
-    keys = HashTagKeys(tenant="t-1")
-    for s in (Stream(name), Stream(name, dlq="custom}{")):
-        slots = {slot(keys.stream(s)), slot(keys.dlq(s)), slot(keys.heartbeat(s, "g", "c{1}"))}
-        assert len(slots) == 1, name
-
-
-def test_braces_cannot_merge_two_streams():
-    keys = HashTagKeys()
-    assert keys.stream(Stream("a}b")) != keys.stream(Stream("a"))
-    assert keys.tag(Stream("a}b")) == "{a%7Db}"
-
-
-def test_tenants_never_collide():
-    a = HashTagKeys(tenant="t:x").stream(Stream("y"))
-    b = HashTagKeys(tenant="t").stream(Stream("x:y"))
-    assert a != b
-    assert HashTagKeys(tenant="t-42").stream(Stream("orders")) == "rk:{t-42:orders}:stream"
-
-
-def test_prefix_and_tenant_validation():
-    with pytest.raises(ConfigurationError):
-        HashTagKeys(prefix="a{b")
-    with pytest.raises(ConfigurationError):
-        HashTagKeys(tenant="")
-    assert HashTagKeys(prefix="").stream(Stream("o")) == "{o}:stream"
-
-
-def test_glob_escape():
-    assert glob_escape("a*b?[c]\\") == "a\\*b\\?\\[c\\]\\\\"