Autarkia-Msgqueue 0.1.0__py3-none-any.whl

autarkia_msgqueue/__init__.py

@@ -0,0 +1,28 @@
+"""Autarkia-Msgqueue: reliable offline message queue for WebSocket reconnects."""
+
+from .queue import (
+    DEFAULT_OFFLINE_TTL,
+    PROACTIVE_OFFLINE_TTL,
+    FlushResult,
+    OfflineMessageQueue,
+    QueueConfig,
+)
+from .replay_guard import (
+    OFFLINE_REPLAY_MAX_AGE_SECONDS,
+    is_stale_offline_replay,
+    offline_replay_age,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "OfflineMessageQueue",
+    "QueueConfig",
+    "FlushResult",
+    "DEFAULT_OFFLINE_TTL",
+    "PROACTIVE_OFFLINE_TTL",
+    "OFFLINE_REPLAY_MAX_AGE_SECONDS",
+    "offline_replay_age",
+    "is_stale_offline_replay",
+]

autarkia_msgqueue/queue.py

@@ -0,0 +1,246 @@
+"""An in-memory offline message queue for WebSocket reconnects.
+
+Semantics worth keeping:
+
+- **Per-type TTL.** Proactive messages (goodnight, morning, status) are stale
+  within minutes; ordinary messages can wait a day.
+- **message_id dedupe.** Re-enqueuing the same outbound message never replays
+  it twice.
+- **Discard after delivery elsewhere.** If the same message reached the phone
+  app, it must not be replayed to the desktop client.
+- **Atomic replay.** Only successfully sent messages leave the queue; a failed
+  send is pushed back to the front and stops the flush so order is preserved.
+- **Per-user flush lock.** Two reconnect paths cannot pop the same deque.
+- **Routing filter.** With two personas sharing one user id, a connection only
+  takes messages addressed to it; others stay for the right connection.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import logging
+import time
+from collections import deque
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Deque, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+PROACTIVE_OFFLINE_TTL = 10 * 60
+DEFAULT_OFFLINE_TTL = 24 * 3600
+_PROACTIVE_MESSAGE_TYPES = frozenset({"proactive_message"})
+
+Sender = Callable[[Dict[str, Any]], Awaitable[bool]]
+Accepts = Callable[[Dict[str, Any]], bool]
+
+
+@dataclass
+class QueueConfig:
+    default_ttl_seconds: float = DEFAULT_OFFLINE_TTL
+    proactive_ttl_seconds: float = PROACTIVE_OFFLINE_TTL
+    proactive_types: frozenset[str] = _PROACTIVE_MESSAGE_TYPES
+
+
+@dataclass
+class FlushResult:
+    sent: int = 0
+    expired: int = 0
+    failed: int = 0
+    skipped: int = 0
+    remaining: int = 0
+
+    @property
+    def ok(self) -> bool:
+        return self.failed == 0
+
+
+class OfflineMessageQueue:
+    """Per-user offline queues with atomic replay."""
+
+    def __init__(
+        self,
+        config: Optional[QueueConfig] = None,
+        *,
+        clock: Optional[Callable[[], float]] = None,
+    ) -> None:
+        self.config = config or QueueConfig()
+        self._clock = clock or time.time
+        self._queues: Dict[str, Deque[Tuple[float, Dict[str, Any]]]] = {}
+        self._locks: Dict[str, asyncio.Lock] = {}
+        self._locks_loop: Optional[asyncio.AbstractEventLoop] = None
+
+    # -- storage -----------------------------------------------------------
+    def _ttl_for(self, message: Dict[str, Any]) -> float:
+        msg_type = str(message.get("type") or "").strip().lower()
+        is_proactive = msg_type in self.config.proactive_types or bool(
+            message.get("is_proactive")
+        )
+        return (
+            float(self.config.proactive_ttl_seconds)
+            if is_proactive
+            else float(self.config.default_ttl_seconds)
+        )
+
+    def store_offline_message(
+        self, user_id: str, message: Dict[str, Any], *, now: Optional[float] = None
+    ) -> bool:
+        """Deep-copy and enqueue one message. Returns whether it was stored."""
+        try:
+            message_id = str(message.get("message_id") or "").strip()
+            queue = self._queues.setdefault(user_id, deque())
+            if message_id and any(
+                str(queued.get("message_id") or "").strip() == message_id
+                for _, queued in queue
+            ):
+                logger.debug(
+                    "Duplicate offline message ignored for %s (message_id=%s)",
+                    user_id,
+                    message_id,
+                )
+                return False
+            queue.append((float(now if now is not None else self._clock()), copy.deepcopy(message)))
+            logger.info(
+                "Stored offline message for %s, queue size: %s", user_id, len(queue)
+            )
+            return True
+        except Exception as error:  # noqa: BLE001 - one bad payload must not break the queue
+            logger.error("Failed to store offline message: %s", error)
+            return False
+
+    def discard_offline_message(self, user_id: str, message_id: str) -> int:
+        """Remove every queued message with this id (delivered elsewhere)."""
+        target = str(message_id or "").strip()
+        queue = self._queues.get(user_id)
+        if not target or queue is None:
+            return 0
+        kept = [
+            (queued_at, message)
+            for queued_at, message in queue
+            if str(message.get("message_id") or "").strip() != target
+        ]
+        removed = len(queue) - len(kept)
+        if removed:
+            queue.clear()
+            queue.extend(kept)
+            if not queue:
+                self._queues.pop(user_id, None)
+            logger.info(
+                "Discarded %s offline message(s) for %s (message_id=%s)",
+                removed,
+                user_id,
+                target,
+            )
+        return removed
+
+    def pending_count(self, user_id: str) -> int:
+        return len(self._queues.get(user_id, ()))
+
+    def pending_users(self) -> List[str]:
+        return list(self._queues)
+
+    def clear(self) -> None:
+        self._queues.clear()
+
+    # -- replay ------------------------------------------------------------
+    def _get_lock(self, user_id: str) -> asyncio.Lock:
+        loop = asyncio.get_running_loop()
+        if self._locks_loop is not loop:
+            self._locks = {}
+            self._locks_loop = loop
+        lock = self._locks.get(user_id)
+        if lock is None:
+            lock = asyncio.Lock()
+            self._locks[user_id] = lock
+        return lock
+
+    async def flush(
+        self,
+        user_id: str,
+        sender: Sender,
+        *,
+        accepts: Optional[Accepts] = None,
+        now: Optional[float] = None,
+    ) -> FlushResult:
+        """Deliver queued messages in order until one fails or the queue empties.
+
+        Args:
+            user_id: Queue owner.
+            sender: ``async (payload) -> bool``; false means "retry later".
+            accepts: Optional routing predicate; false leaves the message for
+                another connection and continues scanning.
+            now: Timestamp override (tests).
+        """
+        queue = self._queues.get(user_id)
+        if not queue:
+            return FlushResult()
+
+        async with self._get_lock(user_id):
+            queue = self._queues.get(user_id)
+            if not queue:
+                return FlushResult()
+
+            result = FlushResult()
+            current_time = float(now if now is not None else self._clock())
+            scan_count = len(queue)
+
+            for _ in range(scan_count):
+                queued_at, message = queue.popleft()
+
+                if current_time - queued_at >= self._ttl_for(message):
+                    result.expired += 1
+                    logger.info(
+                        "Dropping expired offline message: type=%s age=%.1fmin",
+                        message.get("type"),
+                        (current_time - queued_at) / 60.0,
+                    )
+                    continue
+
+                if accepts is not None and not accepts(message):
+                    queue.append((queued_at, message))
+                    result.skipped += 1
+                    continue
+
+                payload = copy.deepcopy(message)
+                payload["is_offline_replay"] = True
+                payload["offline_queued_at"] = queued_at
+
+                try:
+                    sent = await sender(payload)
+                    if not sent:
+                        raise ConnectionError("offline send returned false")
+                except Exception as error:  # noqa: BLE001 - keep the message
+                    queue.appendleft((queued_at, message))
+                    result.failed += 1
+                    logger.warning(
+                        "Failed to flush offline message to %s: %s. Kept for retry.",
+                        user_id,
+                        error,
+                    )
+                    break
+
+                result.sent += 1
+
+            result.remaining = len(queue)
+            if not queue:
+                self._queues.pop(user_id, None)
+            logger.info(
+                "Offline flush done for %s: sent=%s expired=%s failed=%s "
+                "skipped=%s remaining=%s",
+                user_id,
+                result.sent,
+                result.expired,
+                result.failed,
+                result.skipped,
+                result.remaining,
+            )
+            return result
+
+
+__all__ = [
+    "OfflineMessageQueue",
+    "QueueConfig",
+    "FlushResult",
+    "PROACTIVE_OFFLINE_TTL",
+    "DEFAULT_OFFLINE_TTL",
+]

autarkia_msgqueue/replay_guard.py

@@ -0,0 +1,52 @@
+"""Receiver-side staleness guard for replayed messages.
+
+The sender already applies a TTL, but old payloads, manual flushes, a raised
+TTL, or mismatched client/server versions can still deliver a stale proactive
+message. The receiver checks the age independently — the second half of the
+two-sided TTL.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, Optional
+
+OFFLINE_REPLAY_MAX_AGE_SECONDS = 10 * 60
+
+
+def offline_replay_age(
+    data: Dict[str, Any],
+    *,
+    now: Optional[float] = None,
+    clock: Optional[Callable[[], float]] = None,
+) -> Optional[float]:
+    """Age in seconds for a replayed message; ``None`` when not a replay."""
+    if not isinstance(data, dict) or not data.get("is_offline_replay"):
+        return None
+    queued_at = data.get("offline_queued_at")
+    if queued_at is None:
+        queued_at = data.get("timestamp")
+    try:
+        current = float(now if now is not None else (clock or time.time)())
+        return max(0.0, current - float(queued_at))
+    except (TypeError, ValueError):
+        return None
+
+
+def is_stale_offline_replay(
+    data: Dict[str, Any],
+    *,
+    max_age_seconds: float = OFFLINE_REPLAY_MAX_AGE_SECONDS,
+    now: Optional[float] = None,
+    clock: Optional[Callable[[], float]] = None,
+) -> bool:
+    """Whether a replay is older than the accepted age (non-replays are fresh)."""
+    age = offline_replay_age(data, now=now, clock=clock)
+    return age is not None and age > float(max_age_seconds)
+
+
+__all__ = [
+    "OFFLINE_REPLAY_MAX_AGE_SECONDS",
+    "offline_replay_age",
+    "is_stale_offline_replay",
+]

autarkia_msgqueue-0.1.0.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.5
+Name: Autarkia-Msgqueue
+Version: 0.1.0
+Summary: Reliable offline message queue for WebSocket clients: per-type TTL, message-id dedupe, discard-after-elsewhere-delivery, atomic replay, per-user locks and a receiver-side staleness guard.
+Project-URL: Homepage, https://qishihao.icu/projects/autarkia
+Project-URL: Repository, https://github.com/hakituo/Autarkia-Msgqueue
+Project-URL: Roadmap, https://github.com/hakituo/Autarkia-tool/blob/main/ROADMAP.md
+Project-URL: Autarkia Runtime, https://github.com/hakituo/Autarkia
+Project-URL: Author, https://qishihao.icu
+Author-email: Shihao Qi <qishihao512@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: at-least-once,autarkia,message-replay,offline-queue,reconnect,ttl,websocket
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/hakituo/Autarkia-Msgqueue/main/autarkia-dark.svg">
+    <img src="https://raw.githubusercontent.com/hakituo/Autarkia-Msgqueue/main/autarkia.svg" alt="Autarkia" width="300">
+  </picture>
+</p>
+
+<p align="center">
+  <b>Autarkia-Msgqueue</b><br>
+  <sub>WebSocket 离线消息可靠性队列 · Reliable offline queues for WebSocket clients</sub>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/Autarkia-Msgqueue/"><img alt="PyPI" src="https://img.shields.io/pypi/v/autarkia-msgqueue.svg"></a>
+  <a href="https://pypi.org/project/Autarkia-Msgqueue/"><img alt="Python" src="https://img.shields.io/pypi/pyversions/autarkia-msgqueue.svg"></a>
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+</p>
+
+<p align="center">
+  <a href="#中文">简体中文</a> · <a href="#english">English</a>
+</p>
+
+---
+
+## 中文
+
+**按类型分档的 TTL、`message_id` 去重、已在别端投递后丢弃、原子重放、per-user flush 锁、接收端时效守卫**——把「客户端离线时暂存消息」这件小事做对。
+
+来自 [Autarkia](https://qishihao.icu/projects/autarkia) agent 运行时：手机 App 和桌面 bot 共用一个 user id，同一条「晚安」被反复投递。整个系列见[组件库路线图](https://github.com/hakituo/Autarkia-tool/blob/main/ROADMAP.md)。
+
+### 为什么
+
+存消息很容易，不烦人很难：
+
+- **已经投递过还会重放**：主动消息已经送到手机 App，队列里给桌面端留的那份就是重复打扰，必须能按 id 丢掉。
+- **隔夜重放**：「晚安」第二天早上九点再发毫无意义。主动消息要分钟级 TTL，普通消息要一天——一个 TTL 两边都不对。
+- **队列内重复**：同一个 `message_id` 入队两次就会重放两次。
+- **失败即丢**：先出队再发送，socket 一断消息就没了。
+- **并发 flush**：两条重连路径同时掏同一个 deque。
+- **投错人**：两个人设共用一个 user id 时，一条连接只能取走发给自己的消息。
+- **接收端也过期**：客户端 TTL 调大、手工重放、版本不一致，都可能让旧消息晚到，所以接收端独立再查一次年龄。
+
+### 安装
+
+```bash
+pip install autarkia-msgqueue
+```
+
+零依赖，Python 3.10+。
+
+### 快速开始
+
+```python
+import asyncio
+from autarkia_msgqueue import OfflineMessageQueue
+
+queue = OfflineMessageQueue()
+
+# 客户端离线：入队（深拷贝）
+queue.store_offline_message(
+    "user-1",
+    {"type": "proactive_message", "message_id": "evt-9", "text": "晚安"},
+)
+
+# 已在别处（手机 App）投递过：不要再重放给桌面端
+queue.discard_offline_message("user-1", "evt-9")
+
+async def on_reconnect(user_id):
+    async def send(payload) -> bool:
+        return await websocket_send(user_id, payload)   # 返回假值/抛异常 = 稍后重试
+
+    result = await queue.flush(user_id, send, accepts=lambda m: m.get("persona") == "a")
+    print(result)   # FlushResult(sent=0, expired=0, failed=0, skipped=0, remaining=0)
+```
+
+接收端守卫：
+
+```python
+from autarkia_msgqueue import is_stale_offline_replay
+
+if is_stale_offline_replay(payload, max_age_seconds=600):
+    return  # 太旧的重放直接丢
+```
+
+### 接口一览
+
+| API | 保证 |
+| --- | --- |
+| `store_offline_message` | 深拷贝入队；重复或非法载荷返回 `False` |
+| `discard_offline_message` | 删掉该 `message_id` 的全部副本，返回删除条数 |
+| `flush` | FIFO 重放；遇到第一条失败即停止，其余保留 |
+| `QueueConfig` | `default_ttl_seconds`、`proactive_ttl_seconds`、`proactive_types` |
+| `FlushResult` | `sent` / `expired` / `failed` / `skipped` / `remaining`，以及 `.ok` |
+| `offline_replay_age`、`is_stale_offline_replay` | 接收端对重放消息的年龄判断 |
+
+重放载荷会带 `is_offline_replay: True` 与 `offline_queued_at`（epoch 秒）；队列里的原始消息不会被改写。
+
+### 设计说明
+
+- **TTL 按消息类型**：`type == "proactive_message"` 或 `is_proactive` 走 `proactive_ttl_seconds`（默认 10 分钟），其余走 `default_ttl_seconds`（默认 24 小时）。过期判据是 `age >= ttl`。
+- **原子重放**：只有 `sender` 返回真值后消息才出队；失败则推回队首并停止本轮，顺序在 socket 抖动后仍然保持。
+- **扫描窗口**：`flush` 只遍历拿到锁时已存在的消息，重放期间新入队的留给下一轮。
+- **路由谓词**：`accepts(payload)` 返回 `False` 时消息留在队列继续扫描，一条连接不会偷走另一个人设的消息。
+- **锁按 user + 事件循环**：队列被另一个事件循环使用时锁会重建，模块级单例不会把锁漏到 `asyncio.run` 之间。
+- **刻意只在内存里**：它是重连缓冲，不是消息存储；进程重启即丢，要持久化请自己做。
+- **测试可确定性**：队列的 `clock=`、`store` / `flush` 的 `now=`、守卫的 `now=` 都能注入，不依赖墙钟。
+
+### 系列与链接
+
+- 项目页：<https://qishihao.icu/projects/autarkia>
+- 运行时仓库：<https://github.com/hakituo/Autarkia>
+- 本包：<https://github.com/hakituo/Autarkia-Msgqueue>
+- 组件库路线图：<https://github.com/hakituo/Autarkia-tool/blob/main/ROADMAP.md>
+- 作者：Shihao Qi — <https://qishihao.icu>
+
+### 许可
+
+MIT
+
+---
+
+## English
+
+**Per-type TTL, message-id dedupe, discard-after-elsewhere-delivery, atomic replay, per-user flush locks, and a receiver-side staleness guard** — the small "store messages while the client is offline" problem, done correctly.
+
+Extracted from the [Autarkia](https://qishihao.icu/projects/autarkia) agent runtime, where a phone app and a desktop bot shared one user id and kept re-delivering the same goodnight message. See the [component roadmap](https://github.com/hakituo/Autarkia-tool/blob/main/ROADMAP.md).
+
+### Why
+
+Storing messages for offline clients is easy. Not annoying the user is not:
+
+- **Replayed after delivery.** The same proactive message reached the phone app, so the queued copy for the desktop client is a duplicate. It has to be discarded by id.
+- **Overnight replays.** "Goodnight" is worthless at 9 a.m. Proactive messages need minutes-scale TTL, ordinary messages a day; one TTL for both is wrong either way.
+- **Duplicates in queue.** The same `message_id` enqueued twice replays twice.
+- **Lost on failure.** Popping before a successful send loses the message when the socket dies mid-flush.
+- **Concurrent flushes.** Two reconnect paths can empty the same deque under each other's feet.
+- **Wrong recipient.** With two personas sharing a user id, a connection must only take messages addressed to it.
+- **Stale receivers.** A client with an old TTL, a manual flush, or a mismatched version can still receive a replay hours later, so the receiver checks age independently.
+
+### Install
+
+```bash
+pip install autarkia-msgqueue
+```
+
+No dependencies. Python 3.10+.
+
+### Quick start
+
+```python
+import asyncio
+from autarkia_msgqueue import OfflineMessageQueue
+
+queue = OfflineMessageQueue()
+
+# The client is offline: park the message (deep-copied).
+queue.store_offline_message(
+    "user-1",
+    {"type": "proactive_message", "message_id": "evt-9", "text": "晚安"},
+)
+
+# Delivered elsewhere (phone app) — never replay it to the desktop client.
+queue.discard_offline_message("user-1", "evt-9")
+
+async def on_reconnect(user_id):
+    async def send(payload) -> bool:
+        return await websocket_send(user_id, payload)   # False / raise => retry later
+
+    result = await queue.flush(user_id, send, accepts=lambda msg: msg.get("persona") == "a")
+    print(result)   # FlushResult(sent=0, expired=0, failed=0, skipped=0, remaining=0)
+```
+
+#### Receiver side
+
+```python
+from autarkia_msgqueue import is_stale_offline_replay
+
+if is_stale_offline_replay(payload, max_age_seconds=600):
+    return  # drop a replay that is too old to be meaningful
+```
+
+### Concepts
+
+| API | Guarantee |
+| --- | --- |
+| `store_offline_message` | deep copy; returns `False` for duplicates or bad payloads |
+| `discard_offline_message` | removes every copy of that `message_id`, returns the count |
+| `flush` | FIFO replay; stops at the first failure and keeps the rest |
+| `QueueConfig` | `default_ttl_seconds`, `proactive_ttl_seconds`, `proactive_types` |
+| `FlushResult` | `sent` / `expired` / `failed` / `skipped` / `remaining`, plus `.ok` |
+| `offline_replay_age`, `is_stale_offline_replay` | receiver-side age check on replays |
+
+Replayed payloads carry `is_offline_replay: True` and `offline_queued_at` (epoch seconds); the stored copy is never mutated.
+
+### Design notes
+
+- **TTL per message type.** `type == "proactive_message"` or `is_proactive` uses `proactive_ttl_seconds` (default 10 min); everything else uses `default_ttl_seconds` (default 24 h). Expiry is `age >= ttl`.
+- **Atomic replay.** A message leaves the queue only after `sender` returns truthy. On failure it is pushed back to the front and the flush stops, so ordering survives a broken socket.
+- **Scan window.** `flush` only walks the messages present when it takes the lock; anything enqueued mid-flush is left for the next round.
+- **Routing predicate.** `accepts(payload)` returning `False` leaves the message queued and keeps scanning, so one connection never steals another persona's messages.
+- **Locks are per user per event loop.** Locks are recreated when the queue is used from a different event loop, so a module-level singleton does not leak locks across `asyncio.run` calls.
+- **In memory, by design.** The queue is a reconnect buffer, not a message store: a process restart drops it. Persist elsewhere if you need durability.
+- **Deterministic tests.** `clock=` on the queue and `now=` on `store` / `flush` / the guard remove all wall-clock dependence.
+
+### The bigger picture
+
+- Project page: <https://qishihao.icu/projects/autarkia>
+- Runtime repository: <https://github.com/hakituo/Autarkia>
+- This package: <https://github.com/hakituo/Autarkia-Msgqueue>
+- Roadmap: <https://github.com/hakituo/Autarkia-tool/blob/main/ROADMAP.md>
+- Author: Shihao Qi — <https://qishihao.icu>
+
+### License
+
+MIT

autarkia_msgqueue-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+autarkia_msgqueue/__init__.py,sha256=0L-ojA2LyozwpVEBDVyYmgxOp1j_B8Z5ql2fGSF8H8g,609
+autarkia_msgqueue/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autarkia_msgqueue/queue.py,sha256=TvE_01f7Xx64T5aN9Ygu_jT86DcHfDNlTX-WvxYeOTU,8545
+autarkia_msgqueue/replay_guard.py,sha256=4j2X4Rj2rgmq-QHdw-5khox219i79tO1iUQNsJ7wA6E,1617
+autarkia_msgqueue-0.1.0.dist-info/METADATA,sha256=IdiKIo5IIdF4Th5V5KWcodFTrz8LwhDb8DGKSHxhIvQ,11612
+autarkia_msgqueue-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+autarkia_msgqueue-0.1.0.dist-info/licenses/LICENSE,sha256=KjCC0TPNgxUUjuiaiDm4bNjiDFPtghA1apRPKt_8cU0,1066
+autarkia_msgqueue-0.1.0.dist-info/RECORD,,

autarkia_msgqueue-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

autarkia_msgqueue-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shihao Qi
+
+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.