patchwork-client-redis 1.0.0__py3-none-any.whl

patchwork/client/redis/__init__.py

@@ -0,0 +1,2 @@
+from .publisher import AsyncRedisPublisher
+from .subscriber import AsyncRedisSubscriber, RedisReceipt

patchwork/client/redis/common.py

@@ -0,0 +1,24 @@
+from datetime import UTC, datetime
+
+from redis.asyncio import Redis
+
+#: stream entry field holding encoded message, the source of truth
+DATA_FIELD = b'data'
+
+#: stream entry fields copied from the message, for filtering and debugging without decoding
+HEADER_FIELDS = (b'id', b'type', b'queue', b'not_before', b'expires')
+
+
+def encode_timestamp(value: datetime) -> bytes:
+    return str(int(value.timestamp() * 1000)).encode()
+
+
+def decode_timestamp(value: bytes) -> datetime:
+    return datetime.fromtimestamp(int(value) / 1000, tz=UTC)
+
+
+def create_client(url: str, **options) -> Redis:
+    """
+    Creates Redis client from URL, eg. `redis://localhost:6379/0`. Responses are not decoded (bytes).
+    """
+    return Redis.from_url(url, decode_responses=False, **options)

patchwork/client/redis/publisher.py

@@ -0,0 +1,129 @@
+import asyncio
+
+from patchwork.core import AsyncPublisher, Capabilities, Component, Message
+from patchwork.core.client.publisher import DEFAULT_MAX_MSG_SIZE
+from patchwork.core.serializers import Serializer
+
+from redis.asyncio import Redis
+from redis.exceptions import ConnectionError as RedisConnectionError
+from redis.exceptions import TimeoutError as RedisTimeoutError
+
+from .common import DATA_FIELD, create_client, encode_timestamp
+
+
+def message_fields(data: bytes, message: Message) -> dict[bytes, bytes]:
+    """
+    Builds stream entry fields: encoded message and a copy of selected message fields.
+    """
+    fields = {
+        DATA_FIELD: data,
+        b'id': str(message.id).encode(),
+        b'type': message.type.encode(),
+        b'queue': message.queue.encode(),
+    }
+    if message.not_before is not None:
+        fields[b'not_before'] = encode_timestamp(message.not_before)
+    if message.expires is not None:
+        fields[b'expires'] = encode_timestamp(message.expires)
+    return fields
+
+
+class AsyncRedisPublisher(AsyncPublisher):
+    """
+    Redis Streams publisher, each queue is a stream. Messages are appended with `XADD`.
+
+    Redis streams don't support delayed delivery, configure `postpone_queue` and run patchwork-postponer to support
+    messages with `not_before` in the future.
+    """
+
+    capabilities = Capabilities(delayed_delivery=False, native_headers=True, redelivery_count=False)
+
+    def __init__(
+            self,
+            *,
+            url: str | None = None,
+            client: Redis | None = None,
+            parent: Component | None = None,
+            enabled: bool = True,
+            serializer: Serializer | None = None,
+            max_message_size: int = DEFAULT_MAX_MSG_SIZE,
+            postpone_queue: str | None = None,
+            maxlen: int | None = None,
+            stream_prefix: str = '',
+            send_timeout: float = 10.0,
+            retry_attempts: int = 3,
+            retry_time_s: float = 1.0,
+    ):
+        """
+        :param url: Redis URL, eg. `redis://localhost:6379/0`, required if `client` is not given
+        :param client: Redis client (`redis.asyncio.Redis` with `decode_responses=False`), if given it's not closed
+            by the publisher
+        :param postpone_queue: queue for messages with `not_before` in the future
+        :param maxlen: approximate max length of streams (`XADD MAXLEN ~`), None means no trimming.
+
+            !!! danger
+                Trimming removes entries regardless of consumer groups, messages not consumed yet are lost.
+
+        :param stream_prefix: prefix of stream keys, stream key is `prefix + queue name`
+        :param send_timeout: default send timeout in seconds
+        :param retry_attempts: number of retries on connection errors
+        :param retry_time_s: time between retries in seconds
+        """
+        super().__init__(
+            parent=parent,
+            enabled=enabled,
+            serializer=serializer,
+            max_message_size=max_message_size,
+            postpone_queue=postpone_queue,
+        )
+        if url is None and client is None:
+            raise ValueError("either `url` or `client` must be given")
+
+        self._url = url
+        self._client = client
+        self._owns_client = client is None
+        self._maxlen = maxlen
+        self._stream_prefix = stream_prefix
+        self._send_timeout = send_timeout
+        self._retry_attempts = retry_attempts
+        self._retry_time_s = retry_time_s
+
+    def __repr__(self):
+        res = super().__repr__()
+        return f"<{res[1:-1]} [{self._url or self._client}]>"
+
+    @property
+    def client(self) -> Redis:
+        return self._client
+
+    def stream_key(self, queue: str) -> str:
+        return f'{self._stream_prefix}{queue}'
+
+    async def _start(self):
+        if self._client is None:
+            self._client = create_client(self._url)
+        await self._client.ping()
+
+    async def _stop(self):
+        if self._owns_client and self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def _send(self, data: bytes, message: Message, *, queue: str, timeout: float | None = None):
+        fields = message_fields(data, message)
+        timeout = self._send_timeout if timeout is None else timeout
+        kwargs = {'maxlen': self._maxlen, 'approximate': True} if self._maxlen else {}
+
+        for attempt in range(self._retry_attempts + 1):
+            try:
+                entry_id = await asyncio.wait_for(
+                    self._client.xadd(self.stream_key(queue), fields, **kwargs), timeout
+                )
+            except (RedisConnectionError, RedisTimeoutError) as exc:
+                self.logger.warning(f"can't send message to {queue}: {exc.__class__.__name__}({exc})")
+                if attempt == self._retry_attempts:
+                    raise TimeoutError(f"can't send message to {queue}") from exc
+                await asyncio.sleep(self._retry_time_s)
+            else:
+                self.logger.debug(f"message {message.id} appended to {queue} as {entry_id!r}")
+                return

patchwork/client/redis/subscriber.py

@@ -0,0 +1,398 @@
+import asyncio
+import os
+import socket
+import time
+import uuid
+from collections import deque
+from collections.abc import Awaitable, Callable, Iterable
+from typing import Any, NamedTuple, TypeVar
+
+from patchwork.core import (
+    AsyncSubscriber,
+    Capabilities,
+    CommitLost,
+    Component,
+    Delivery,
+    SubscriberClosed,
+)
+from patchwork.core.serializers import Serializer
+
+from redis.asyncio import Redis
+from redis.exceptions import ConnectionError as RedisConnectionError
+from redis.exceptions import ResponseError
+from redis.exceptions import TimeoutError as RedisTimeoutError
+
+from .common import DATA_FIELD, create_client, decode_timestamp
+
+T = TypeVar('T')
+
+_RETRYABLE = (RedisConnectionError, RedisTimeoutError, OSError)
+
+
+class RedisReceipt(NamedTuple):
+    #: stream key
+    stream: str
+    #: stream entry ID
+    entry_id: bytes
+    #: number of deliveries of the entry including this one
+    deliveries: int
+
+
+class _Entry(NamedTuple):
+    stream: str
+    entry_id: bytes
+    fields: dict[bytes, bytes]
+    deliveries: int
+
+
+def default_consumer_name() -> str:
+    return f'{socket.gethostname()}-{os.getpid()}-{uuid.uuid4().hex[:8]}'
+
+
+class AsyncRedisSubscriber(AsyncSubscriber):
+    """
+    Redis Streams subscriber working in a consumer group.
+
+    - messages are read with `XREADGROUP`, each message is pending (in the group PEL) until committed (`XACK`),
+      commits may come in any order
+    - rollback claims the message back (`XCLAIM`), it's delivered again by the next `get()` call and broker
+      delivery counter is increased (`Delivery.redelivered`)
+    - messages pending on consumers which went away are claimed (`XAUTOCLAIM`) after `claim_idle_ms`,
+      so `claim_idle_ms` works like a visibility timeout: processing of a message must not take longer
+    - with a stable `consumer` name (eg. pod name), messages pending on the consumer are delivered again
+      immediately after restart
+    """
+
+    capabilities = Capabilities(delayed_delivery=False, native_headers=True, redelivery_count=True)
+
+    def __init__(
+            self,
+            *,
+            queues: Iterable[str],
+            group: str,
+            url: str | None = None,
+            client: Redis | None = None,
+            consumer: str | None = None,
+            parent: Component | None = None,
+            enabled: bool = True,
+            serializer: Serializer | None = None,
+            stream_prefix: str = '',
+            start_id: str = '0',
+            create_group: bool = True,
+            block_ms: int = 1000,
+            claim_idle_ms: int | None = 60_000,
+            claim_interval_s: float | None = None,
+            claim_batch: int = 10,
+            retry_attempts: int = 5,
+            retry_time_s: float = 1.0,
+    ):
+        """
+        :param queues: queues (streams) to read
+        :param group: consumer group name, each group receives all messages
+        :param url: Redis URL, eg. `redis://localhost:6379/0`, required if `client` is not given
+        :param client: Redis client (`redis.asyncio.Redis` with `decode_responses=False`), if given it's not closed
+            by the subscriber. Subscriber blocks one connection while waiting for messages.
+        :param consumer: consumer name, unique random name by default. Use a stable name (eg. pod name) to get
+            messages pending on the consumer immediately after restart.
+        :param stream_prefix: prefix of stream keys, stream key is `prefix + queue name`
+        :param start_id: where a new consumer group starts reading the stream: `0` (all messages) or `$`
+            (only new messages)
+        :param create_group: create missing consumer groups (and streams)
+        :param block_ms: max time of a single blocking read in milliseconds
+        :param claim_idle_ms: messages pending longer than this on other consumers are claimed and delivered again,
+            None disables claiming (messages of dead consumers are never delivered again!)
+        :param claim_interval_s: how often to check for messages to claim, half of `claim_idle_ms` by default
+        :param claim_batch: max number of messages claimed at once
+        :param retry_attempts: number of retries on connection errors, then subscriber fails
+        :param retry_time_s: time between retries in seconds
+        """
+        super().__init__(parent=parent, enabled=enabled, serializer=serializer)
+        if url is None and client is None:
+            raise ValueError("either `url` or `client` must be given")
+
+        self._queues = list(queues)
+        if not self._queues:
+            raise ValueError("no queues to listen on")
+
+        self._group = group
+        self._url = url
+        self._client = client
+        self._owns_client = client is None
+        self._consumer = consumer or default_consumer_name()
+        self._stream_prefix = stream_prefix
+        self._start_id = start_id
+        self._create_group = create_group
+        self._block_ms = block_ms
+        self._claim_idle_ms = claim_idle_ms
+        if claim_interval_s is None and claim_idle_ms is not None:
+            claim_interval_s = claim_idle_ms / 1000 / 2
+        self._claim_interval_s = claim_interval_s
+        self._claim_batch = claim_batch
+        self._retry_attempts = retry_attempts
+        self._retry_time_s = retry_time_s
+
+        self._ready: deque[_Entry] = deque()
+        self._next_claim = 0.0
+        self._claim_cursors: dict[str, bytes] = {}
+        self._recover_own = True
+
+    def __repr__(self):
+        res = super().__repr__()
+        return f"<{res[1:-1]} [{self._group}/{self._consumer}]>"
+
+    @property
+    def queues(self) -> list[str]:
+        return list(self._queues)
+
+    @property
+    def group(self) -> str:
+        return self._group
+
+    @property
+    def consumer(self) -> str:
+        return self._consumer
+
+    @property
+    def client(self) -> Redis:
+        return self._client
+
+    def stream_key(self, queue: str) -> str:
+        return f'{self._stream_prefix}{queue}'
+
+    def _queue_name(self, stream: str) -> str:
+        return stream[len(self._stream_prefix):]
+
+    @property
+    def _streams(self) -> list[str]:
+        return [self.stream_key(q) for q in self._queues]
+
+    # --- lifecycle ---
+
+    async def _start(self):
+        if self._client is None:
+            self._client = create_client(self._url)
+
+        try:
+            await self._client.ping()
+            if self._create_group:
+                for stream in self._streams:
+                    await self._ensure_group(stream)
+        except BaseException:
+            await self._close_client()
+            raise
+
+        self._ready.clear()
+        self._claim_cursors.clear()
+        self._next_claim = 0.0
+        self._recover_own = True
+
+    async def _stop(self):
+        # messages pending on this consumer stay in the group PEL, they are claimed by other consumers after
+        # `claim_idle_ms` or delivered again when consumer with the same name starts
+        self._ready.clear()
+        await self._close_client()
+
+    async def _close_client(self):
+        if self._owns_client and self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def _ensure_group(self, stream: str):
+        try:
+            await self._client.xgroup_create(stream, self._group, id=self._start_id, mkstream=True)
+            self.logger.info(f"consumer group {self._group} created on {stream}")
+        except ResponseError as exc:
+            if 'BUSYGROUP' not in str(exc):
+                raise
+
+    # --- redis calls ---
+
+    async def _call(self, fn: Callable[[], Awaitable[T]]) -> T:
+        """
+        Calls Redis, retries on connection errors and missing consumer group. If retries are exhausted subscriber
+        fails.
+        """
+        for attempt in range(self._retry_attempts + 1):
+            try:
+                return await fn()
+            except ResponseError as exc:
+                if 'NOGROUP' in str(exc) and self._create_group and attempt < self._retry_attempts:
+                    # stream or group has been deleted, create it again
+                    self.logger.warning(f"consumer group missing, recreating: {exc}")
+                    for stream in self._streams:
+                        await self._ensure_group(stream)
+                    continue
+                self._fail(exc)
+                raise SubscriberClosed(f"{self!r} failed") from exc
+            except _RETRYABLE as exc:
+                if attempt == self._retry_attempts:
+                    self._fail(exc)
+                    raise SubscriberClosed(f"{self!r} failed") from exc
+                self.logger.warning(f"redis call failed ({exc.__class__.__name__}: {exc}), retrying")
+                await asyncio.sleep(self._retry_time_s)
+
+        raise AssertionError('unreachable')
+
+    # --- fetching ---
+
+    @staticmethod
+    def _parse_read(response: Any) -> dict[str, list]:
+        """
+        Converts `XREADGROUP` response to `{stream: [(entry_id, fields), ...]}`.
+        """
+        if not response:
+            return {}
+        items = response.items() if isinstance(response, dict) else response
+        result: dict[str, list] = {}
+        for stream, entries in items:
+            stream = stream.decode() if isinstance(stream, bytes) else stream
+            result.setdefault(stream, []).extend(entries)
+        return result
+
+    async def _delivery_counts(self, stream: str, ids: list[bytes]) -> dict[bytes, int]:
+        pending = await self._call(lambda: self._client.xpending_range(
+            stream, self._group, min=ids[0], max=ids[-1], count=len(ids) * 2 + 10, consumername=self._consumer
+        ))
+        return {p['message_id']: p['times_delivered'] for p in pending}
+
+    async def _with_counts(self, stream: str, items: list) -> list[_Entry]:
+        entries = [(entry_id, fields) for entry_id, fields in items if entry_id is not None]
+        if not entries:
+            return []
+        ids = sorted((e[0] for e in entries), key=_entry_sort_key)
+        counts = await self._delivery_counts(stream, ids)
+        return [_Entry(stream, entry_id, fields or {}, counts.get(entry_id, 1)) for entry_id, fields in entries]
+
+    async def _recover_own_pending(self):
+        """
+        Reads messages pending on this consumer (eg. after restart with the same consumer name).
+        """
+        self._recover_own = False
+        for stream in self._streams:
+            response = await self._call(lambda s=stream: self._client.xreadgroup(
+                self._group, self._consumer, {s: '0'}, count=self._claim_batch * 10
+            ))
+            for _, items in self._parse_read(response).items():
+                # reading consumer history increments delivery counters too
+                self._ready.extend(await self._with_counts(stream, items))
+        if self._ready:
+            self.logger.info(f"{len(self._ready)} messages pending on consumer {self._consumer} recovered")
+
+    async def _claim(self):
+        """
+        Claims messages pending too long on other consumers.
+        """
+        if self._claim_idle_ms is None or time.monotonic() < self._next_claim:
+            return
+        self._next_claim = time.monotonic() + self._claim_interval_s
+
+        for stream in self._streams:
+            cursor = self._claim_cursors.get(stream, b'0-0')
+            response = await self._call(lambda s=stream, c=cursor: self._client.xautoclaim(
+                s, self._group, self._consumer, min_idle_time=self._claim_idle_ms, start_id=c,
+                count=self._claim_batch,
+            ))
+            next_cursor, items = response[0], response[1]
+            self._claim_cursors[stream] = next_cursor
+            claimed = await self._with_counts(stream, items)
+            if claimed:
+                self.logger.info(f"{len(claimed)} messages claimed from {stream}")
+            self._ready.extend(claimed)
+
+    async def _next_entry(self, timeout: float | None) -> _Entry:
+        deadline = None if timeout is None else time.monotonic() + timeout
+
+        while True:
+            if self._recover_own:
+                await self._recover_own_pending()
+            await self._claim()
+
+            while self._ready:
+                entry = self._ready.popleft()
+                if DATA_FIELD in entry.fields:
+                    return entry
+                # entry has been deleted from the stream (eg. trimmed), nothing to deliver
+                self.logger.warning(f"message {entry.entry_id!r} deleted from {entry.stream}, skipped")
+                await self._call(lambda e=entry: self._client.xack(e.stream, self._group, e.entry_id))
+
+            if deadline is None:
+                block = self._block_ms
+            else:
+                remaining_ms = int((deadline - time.monotonic()) * 1000)
+                if remaining_ms <= 0:
+                    block = None
+                else:
+                    block = min(self._block_ms, remaining_ms)
+            if self._claim_idle_ms is not None:
+                # wake up for the next claim check
+                until_claim_ms = int((self._next_claim - time.monotonic()) * 1000)
+                block = max(1, min(block, until_claim_ms)) if block is not None else block
+
+            started = time.monotonic()
+            response = await self._call(lambda: self._client.xreadgroup(
+                self._group, self._consumer, {s: '>' for s in self._streams}, count=1, block=block
+            ))
+            if not response and block and time.monotonic() - started < block / 1000:
+                # server returned earlier than requested (eg. BLOCK not supported by a proxy),
+                # don't spin in a busy loop
+                await asyncio.sleep(min(0.01, block / 1000))
+            for stream, items in self._parse_read(response).items():
+                self._ready.extend(_Entry(stream, entry_id, fields or {}, 1) for entry_id, fields in items)
+
+            if not self._ready and deadline is not None and time.monotonic() >= deadline:
+                raise TimeoutError('no messages')
+
+    async def _fetch(self, *, timeout: float | None = None) -> Delivery:
+        entry = await self._next_entry(timeout)
+        fields = entry.fields
+        headers = {k.decode(errors='replace'): v for k, v in fields.items() if k != DATA_FIELD}
+
+        return self._make_delivery(
+            fields[DATA_FIELD],
+            queue=self._queue_name(entry.stream),
+            receipt=RedisReceipt(stream=entry.stream, entry_id=entry.entry_id, deliveries=entry.deliveries),
+            headers=headers,
+            hints=self._hints(headers),
+            redelivered=max(0, entry.deliveries - 1),
+        )
+
+    @staticmethod
+    def _hints(headers: dict[str, bytes]) -> dict[str, Any]:
+        hints: dict[str, Any] = {}
+        try:
+            if 'type' in headers:
+                hints['type'] = headers['type'].decode()
+            for name in ('not_before', 'expires'):
+                if name in headers:
+                    hints[name] = decode_timestamp(headers[name])
+        except (UnicodeDecodeError, ValueError, OverflowError):
+            # invalid headers are not critical, message is the source of truth
+            return {}
+        return hints
+
+    # --- settlement ---
+
+    async def _commit(self, delivery: Delivery, *, timeout: float | None = None):
+        receipt: RedisReceipt = delivery.receipt
+        acked = await asyncio.wait_for(
+            self._call(lambda: self._client.xack(receipt.stream, self._group, receipt.entry_id)), timeout
+        )
+        if not acked:
+            raise CommitLost(f"message {receipt.entry_id!r} is not pending anymore")
+
+    async def _rollback(self, delivery: Delivery, *, timeout: float | None = None):
+        receipt: RedisReceipt = delivery.receipt
+        # claim the message back: resets idle time and increments delivery counter
+        claimed = await asyncio.wait_for(self._call(lambda: self._client.xclaim(
+            receipt.stream, self._group, self._consumer, min_idle_time=0, message_ids=[receipt.entry_id]
+        )), timeout)
+        if not claimed:
+            raise CommitLost(f"message {receipt.entry_id!r} is not pending anymore")
+
+        entry_id, fields = claimed[0]
+        self._ready.append(_Entry(receipt.stream, entry_id, fields or {}, receipt.deliveries + 1))
+
+
+def _entry_sort_key(entry_id: bytes) -> tuple[int, int]:
+    ms, _, seq = entry_id.partition(b'-')
+    return int(ms), int(seq or 0)

patchwork_client_redis-1.0.0.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: patchwork-client-redis
+Version: 1.0.0
+Summary: Redis Streams client for Patchwork - The distributed asynchronous microframework
+Author: Paweł Pecio
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.11.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: patchwork-core<3,>=2.0.0
+Requires-Dist: redis>=5.0
+Provides-Extra: docs
+Requires-Dist: mkdocs<2,==1.6.1; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Dynamic: license-file
+
+# Patchwork Client Redis
+
+Redis Streams client for Patchwork - an asynchronous distributed microframework.
+
+## Requirements
+
+* Python 3.11+
+* Redis 7.0+
+* `patchwork-core` 2.0+
+
+## Installation
+
+``pip install patchwork-client-redis``
+
+## Development
+
+```bash
+uv sync --all-extras --dev
+uv run pytest tests
+REDIS_URL=redis://127.0.0.1:6379/0 uv run pytest int
+```
+
+## Documentation
+
+https://patchwork-framework.gitlab.io/redis-client

patchwork_client_redis-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+patchwork/client/redis/__init__.py,sha256=IMkmFtvMcmixeMoKFZafPuhknTHaK9-4R7tZdyu5Czo,102
+patchwork/client/redis/common.py,sha256=ibqlMuWqzbYHaBp2GPFkm7H5XhuZeeviDqNiPa5w9lI,772
+patchwork/client/redis/publisher.py,sha256=K5_2GVaeTNfYB-OvBtG4o3NRfBUuSDGy3OBbNwpqKZY,5112
+patchwork/client/redis/subscriber.py,sha256=9LuwF-bVUeCBC4LogWtYLGE5uVHY5-XVwXxorroUy3s,16449
+patchwork_client_redis-1.0.0.dist-info/licenses/LICENSE,sha256=2j7OLS2vXIEshgbSkiCU9RgYJY1M4OBBtO6ECbo7OB8,1056
+patchwork_client_redis-1.0.0.dist-info/METADATA,sha256=qqcKZdaqmO2TY7VKyK-J5HRLl5vhc2c_dO-47HLWIOo,1431
+patchwork_client_redis-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+patchwork_client_redis-1.0.0.dist-info/top_level.txt,sha256=aLF4R1vFf2HfqmKmZHlBkLny_-8Ye5nT-Pi8pKL2vE8,10
+patchwork_client_redis-1.0.0.dist-info/RECORD,,

patchwork_client_redis-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

patchwork_client_redis-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

patchwork_client_redis-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+patchwork