postgres-mutex 0.1.0__py3-none-any.whl

postgres_mutex/mutex.py

@@ -0,0 +1,320 @@
+"""Public ``Mutex`` API: sync and async acquire/release/heartbeat, context managers,
+and the ``@mutex.singleton`` decorator.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import functools
+import logging
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+from typing import ParamSpec, TypeVar
+
+from ._async import AsyncConnectionPool, AsyncMutexCore
+from ._config import MutexConfig, default_instance_id
+from ._sync import SyncConnectionPool, SyncMutexCore
+from .metrics import MetricsHook
+
+logger = logging.getLogger("postgres_mutex")
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class Mutex:
+    """A distributed mutex backed by a single Postgres table.
+
+    One ``Mutex`` maps to one ``lock_name``. Construct it once and reuse it — sync and
+    async operations are both available on the same instance, though a given lock is
+    typically driven from one side or the other in a given process.
+
+    Supply exactly one connection source:
+
+    - ``dsn`` (the common case): a libpq connection string passed straight to
+      psycopg. Mutex opens and owns one dedicated connection per side (sync/async)
+      used for it — fine for typical singleton-job / leader-election use, but it's an
+      extra always-open connection per ``Mutex`` instance.
+    - ``pool`` / ``async_pool``: an existing ``psycopg_pool.ConnectionPool`` /
+      ``AsyncConnectionPool`` that your application already manages (e.g. behind
+      pgbouncer). Mutex borrows a connection for the duration of each operation
+      (acquire, heartbeat, release) and returns it — it never owns or closes the
+      pool. Pass both if you use the mutex from both sync and async code.
+
+    Example::
+
+        mutex = Mutex(dsn="postgres://...", lock_name="nightly-report-job")
+        with mutex.acquire(blocking=False) as acquired:
+            if acquired:
+                run_the_job()
+            else:
+                log.info("another instance is running the job")
+
+    Or, reusing a pool your app already has::
+
+        mutex = Mutex(lock_name="nightly-report-job", pool=app_pool)
+
+    Args:
+        dsn: libpq connection string / URL passed straight to psycopg. Omit if
+            passing ``pool``/``async_pool`` instead.
+        lock_name: name of the lock, unique per table. Max 64 characters.
+        pool: a ``psycopg_pool.ConnectionPool`` to borrow sync connections from,
+            instead of ``dsn``.
+        async_pool: a ``psycopg_pool.AsyncConnectionPool`` to borrow async
+            connections from, instead of ``dsn``.
+        instance_id: identifies this process as the holder. Defaults to
+            ``<hostname>-<random>``; set explicitly if you want stable, recognizable
+            IDs in logs and alerts (e.g. ``f"{hostname}-pid{os.getpid()}"``).
+        table: name of the lock table. Defaults to ``mutex_lock``; override to run
+            multiple independent lock tables in the same database.
+        heartbeat_interval: seconds between heartbeats while the lock is held.
+        alert_threshold: seconds of missed heartbeat before ``on_alert``/metrics fire,
+            signalling on-call should investigate a possibly-stuck holder.
+        stale_threshold: seconds of missed heartbeat before another instance is
+            allowed to reclaim the lock outright, assuming the holder crashed.
+        poll_interval: seconds between retries while blocking on ``acquire``.
+        metrics: optional ``MetricsHook`` implementation (Prometheus, OTel, etc).
+    """
+
+    def __init__(
+        self,
+        dsn: str | None = None,
+        lock_name: str = "",
+        *,
+        pool: SyncConnectionPool | None = None,
+        async_pool: AsyncConnectionPool | None = None,
+        instance_id: str | None = None,
+        table: str = "mutex_lock",
+        heartbeat_interval: float = 10.0,
+        alert_threshold: float = 30.0,
+        stale_threshold: float = 600.0,
+        poll_interval: float = 0.5,
+        metrics: MetricsHook | None = None,
+    ) -> None:
+        if dsn is None and pool is None and async_pool is None:
+            raise ValueError("Mutex needs a connection source: pass dsn, pool, or async_pool")
+        self.dsn = dsn
+        self.pool = pool
+        self.async_pool = async_pool
+        self.config = MutexConfig(
+            lock_name=lock_name,
+            instance_id=instance_id or default_instance_id(),
+            table=table,
+            heartbeat_interval=heartbeat_interval,
+            alert_threshold=alert_threshold,
+            stale_threshold=stale_threshold,
+            poll_interval=poll_interval,
+        )
+        self.metrics = metrics
+        self._sync_core: SyncMutexCore | None = None
+        self._async_core: AsyncMutexCore | None = None
+
+    # -- properties -------------------------------------------------
+
+    @property
+    def lock_name(self) -> str:
+        return self.config.lock_name
+
+    @property
+    def instance_id(self) -> str:
+        return self.config.instance_id
+
+    @property
+    def held(self) -> bool:
+        """Best-effort local flag: was the lock acquired and not yet released/lost?
+
+        This reflects local state, not a fresh read of the database — a heartbeat
+        failure updates it asynchronously (within one ``heartbeat_interval``), it
+        does not poll on every access.
+        """
+        if self._sync_core is not None and self._sync_core._held:
+            return True
+        return bool(self._async_core is not None and self._async_core._held)
+
+    # -- lazy core accessors -------------------------------------------------
+
+    def _sync(self) -> SyncMutexCore:
+        if self._sync_core is None:
+            if self.dsn is None and self.pool is None:
+                raise ValueError(
+                    "this Mutex has no sync connection source configured "
+                    "(pass dsn or pool) — only async_pool was given"
+                )
+            self._sync_core = SyncMutexCore(self.config, self.metrics, dsn=self.dsn, pool=self.pool)
+        return self._sync_core
+
+    def _async(self) -> AsyncMutexCore:
+        if self._async_core is None:
+            if self.dsn is None and self.async_pool is None:
+                raise ValueError(
+                    "this Mutex has no async connection source configured "
+                    "(pass dsn or async_pool) — only pool was given"
+                )
+            self._async_core = AsyncMutexCore(
+                self.config, self.metrics, dsn=self.dsn, pool=self.async_pool
+            )
+        return self._async_core
+
+    # -- schema -------------------------------------------------
+
+    def create_schema(self) -> None:
+        """Create the lock table if it doesn't already exist. Safe to call repeatedly."""
+        self._sync().ensure_schema()
+
+    async def create_schema_async(self) -> None:
+        """Async counterpart to ``create_schema``."""
+        await self._async().ensure_schema()
+
+    # -- sync API -------------------------------------------------
+
+    @contextlib.contextmanager
+    def acquire(self, blocking: bool = False, timeout: float | None = None) -> Iterator[bool]:
+        """Context manager. Yields ``True`` if the lock was acquired, ``False`` otherwise.
+
+        With ``blocking=False`` (default), returns immediately either way — check the
+        yielded value to decide whether to proceed. With ``blocking=True``, waits
+        (polling every ``poll_interval`` seconds) until the lock frees up or
+        ``timeout`` elapses, raising ``LockAcquisitionTimeout`` on timeout.
+
+        The lock is released automatically on exiting the ``with`` block, regardless
+        of whether the body raises.
+        """
+        core = self._sync()
+        acquired = core.acquire(blocking=blocking, timeout=timeout)
+        try:
+            yield acquired
+        finally:
+            if acquired:
+                core.release()
+
+    def release(self) -> None:
+        """Release the lock outright (deletes the row) and stop the heartbeat thread.
+
+        Prefer the ``acquire()`` context manager, which calls this for you. Raises
+        ``LockNotHeldError`` if this instance no longer holds the lock (e.g. it was
+        reclaimed after a missed heartbeat).
+        """
+        self._sync().release()
+
+    def heartbeat(self) -> None:
+        """Manually send one heartbeat. Not usually needed — ``acquire()`` starts a
+        background thread that does this automatically. Raises ``LockNotHeldError``
+        if the lock was reclaimed by another instance.
+        """
+        self._sync().heartbeat()
+
+    def singleton(
+        self,
+        lock_name: str | None = None,
+        *,
+        blocking: bool = False,
+        timeout: float | None = None,
+    ) -> Callable[[Callable[P, R]], Callable[P, R | None]]:
+        """Decorator: run the wrapped function only if the lock is acquired.
+
+        Returns ``None`` (and logs at INFO level) instead of calling the function
+        when another instance already holds the lock and ``blocking=False``::
+
+            @mutex.singleton("nightly-report-job")
+            def run_the_job():
+                ...
+        """
+        target = self if lock_name is None else self._sibling(lock_name)
+
+        def decorator(func: Callable[P, R]) -> Callable[P, R | None]:
+            @functools.wraps(func)
+            def wrapper(*args: P.args, **kwargs: P.kwargs) -> R | None:
+                with target.acquire(blocking=blocking, timeout=timeout) as acquired:
+                    if not acquired:
+                        logger.info(
+                            "postgres_mutex: skipping %s — lock %r held elsewhere",
+                            func.__name__,
+                            target.lock_name,
+                        )
+                        return None
+                    return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    # -- async API -------------------------------------------------
+
+    @contextlib.asynccontextmanager
+    async def acquire_async(
+        self, blocking: bool = True, timeout: float | None = None
+    ) -> AsyncIterator[bool]:
+        """Async counterpart to ``acquire()``. Note the different default: ``blocking``
+        defaults to ``True`` here, matching the common async usage pattern of awaiting
+        a turn rather than polling manually.
+        """
+        core = self._async()
+        acquired = await core.acquire(blocking=blocking, timeout=timeout)
+        try:
+            yield acquired
+        finally:
+            if acquired:
+                await core.release()
+
+    async def release_async(self) -> None:
+        await self._async().release()
+
+    async def heartbeat_async(self) -> None:
+        await self._async().heartbeat()
+
+    def singleton_async(
+        self,
+        lock_name: str | None = None,
+        *,
+        blocking: bool = True,
+        timeout: float | None = None,
+    ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R | None]]]:
+        """Async counterpart to ``singleton()``."""
+        target = self if lock_name is None else self._sibling(lock_name)
+
+        def decorator(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R | None]]:
+            @functools.wraps(func)
+            async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R | None:
+                async with target.acquire_async(blocking=blocking, timeout=timeout) as acquired:
+                    if not acquired:
+                        logger.info(
+                            "postgres_mutex: skipping %s — lock %r held elsewhere",
+                            func.__name__,
+                            target.lock_name,
+                        )
+                        return None
+                    return await func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    # -- lifecycle -------------------------------------------------
+
+    def close(self) -> None:
+        """Close the underlying sync connection. Does not release the lock — call
+        ``release()`` first if you want a clean shutdown.
+        """
+        if self._sync_core is not None:
+            self._sync_core.close()
+
+    async def close_async(self) -> None:
+        if self._async_core is not None:
+            await self._async_core.close()
+
+    # -- internals -------------------------------------------------
+
+    def _sibling(self, lock_name: str) -> Mutex:
+        """A new Mutex for a different lock_name, same connection source/config/metrics."""
+        overrides = dataclasses.replace(
+            self.config, lock_name=lock_name, instance_id=self.config.instance_id
+        )
+        sibling = Mutex.__new__(Mutex)
+        sibling.dsn = self.dsn
+        sibling.pool = self.pool
+        sibling.async_pool = self.async_pool
+        sibling.config = overrides
+        sibling.metrics = self.metrics
+        sibling._sync_core = None
+        sibling._async_core = None
+        return sibling

postgres_mutex-0.1.0.dist-info/METADATA

@@ -0,0 +1,258 @@
+Metadata-Version: 2.5
+Name: postgres-mutex
+Version: 0.1.0
+Summary: A distributed mutex for Postgres. One table, heartbeat-based liveness, automatic crash recovery. No ZooKeeper, no Redis.
+Project-URL: Homepage, https://github.com/rishi-rana/postgres-mutex
+Project-URL: Repository, https://github.com/rishi-rana/postgres-mutex
+Project-URL: Issues, https://github.com/rishi-rana/postgres-mutex/issues
+Author: Rishi Rana
+License: MIT
+License-File: LICENSE
+Keywords: distributed-lock,leader-election,mutex,postgres,postgresql,scheduling,singleton
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Database
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: psycopg[binary]>=3.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: psycopg-pool>=3.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: testcontainers[postgres]>=4.0; extra == 'dev'
+Provides-Extra: pool
+Requires-Dist: psycopg-pool>=3.1; extra == 'pool'
+Description-Content-Type: text/markdown
+
+# postgres-mutex
+
+A distributed mutex for Postgres. One table, heartbeat-based liveness, automatic
+recovery from crashed lock holders. No ZooKeeper, no Redis, no Consul, no etcd.
+
+If you already have Postgres, you shouldn't need any of those just to run a job on
+exactly one instance at a time.
+
+## Quickstart
+
+```bash
+pip install postgres-mutex
+```
+
+```python
+from postgres_mutex import Mutex
+
+mutex = Mutex(dsn="postgres://user:pass@host/db", lock_name="nightly-report-job")
+mutex.create_schema()  # creates the mutex_lock table if it doesn't exist; idempotent
+
+with mutex.acquire(blocking=False) as acquired:
+    if acquired:
+        run_the_job()
+    else:
+        print("another instance is running the job")
+```
+
+Async works the same way:
+
+```python
+async with mutex.acquire_async(blocking=True, timeout=30):
+    await run_the_job_async()
+```
+
+Or skip the `if acquired` branch entirely with the decorator:
+
+```python
+@mutex.singleton("nightly-report-job")
+def run_the_job(): ...
+```
+
+### Supplying connection info
+
+Two ways to give `Mutex` a way to reach Postgres — pick one:
+
+**`dsn`** (the common case) — any libpq connection string, passed straight to
+psycopg untouched. `Mutex` opens and owns one dedicated connection for it.
+
+```python
+Mutex(dsn="postgres://user:pass@host:5432/dbname?sslmode=require", lock_name="job")
+```
+
+Because it's handed to psycopg unmodified, all the usual libpq conventions work:
+keyword form (`"host=localhost dbname=mydb user=me password=secret"`), partial DSNs
+filled in from `PGHOST` / `PGPORT` / `PGUSER` / `PGPASSWORD` / `PGDATABASE` /
+`PGSSLMODE`, and `.pgpass` for passwords you don't want in the DSN at all. Where that
+string comes from — an env var, a secrets manager, a config file — is up to you;
+postgres-mutex just needs a valid one.
+
+**`pool` / `async_pool`** — if your app already manages a `psycopg_pool`
+`ConnectionPool` / `AsyncConnectionPool` (e.g. sitting in front of pgbouncer),
+hand it to `Mutex` instead of a `dsn` so it doesn't open an extra always-on
+connection of its own. `Mutex` borrows a connection for the duration of each
+operation (acquire, heartbeat, release) and gives it back — it never owns, opens, or
+closes the pool.
+
+```python
+from psycopg_pool import ConnectionPool
+
+pool = ConnectionPool("postgres://...")  # owned and closed by your app
+mutex = Mutex(lock_name="nightly-report-job", pool=pool)
+```
+
+Pass `async_pool` instead (or as well, if the same lock is driven from both sync and
+async code) for `acquire_async` / `heartbeat_async` / `release_async`. Requires the
+`psycopg-pool` package (`pip install postgres-mutex[pool]`).
+
+## How it works
+
+One table:
+
+```sql
+CREATE TABLE mutex_lock (
+  lock_name      VARCHAR(64) NOT NULL,
+  locked         INT NOT NULL DEFAULT 1,
+  instance_id    VARCHAR(64) NOT NULL,
+  last_heartbeat TIMESTAMPTZ NOT NULL,
+  acquired_at    TIMESTAMPTZ NOT NULL,
+  CONSTRAINT uq_mutex_lock UNIQUE (locked, lock_name),
+  CONSTRAINT chk_locked CHECK (locked = 1)
+);
+```
+
+`UNIQUE(locked, lock_name)` combined with `CHECK (locked = 1)` means only one row can
+ever exist per `lock_name`. Acquiring is just "try to insert a row" — whoever's
+`INSERT` lands first wins, enforced by the database itself. No CAS loop, no advisory
+locks, no race conditions to reason about.
+
+The lock holder heartbeats every 10 seconds (`UPDATE ... SET last_heartbeat = now()`).
+Every field used for staleness detection — `now()`, the interval comparisons — is
+computed **inside a single Postgres statement**, so results depend only on the
+Postgres server's clock, never on any client's wall clock. Skewed or jumping client
+clocks can't corrupt lock state.
+
+### Dual-threshold stale handling
+
+Most distributed-lock tutorials use one timeout. That's the wrong call:
+
+- **30 seconds without a heartbeat** → an alert fires (via your metrics hook /
+  `on_alert` callback) so on-call can look — is the holder just slow, or actually dead?
+- **10 minutes without a heartbeat** → the lock auto-releases; safe to assume the
+  holder crashed.
+
+If you release at 30 seconds, a holder that's merely slow (GC pause, a long query, a
+noisy neighbor) loses the lock to another instance that's likely to hit the exact same
+slowness — you can end up in a churn loop where nobody makes progress. The alert
+window buys a human time to intervene before the system self-heals on its own.
+
+### Clean shutdown
+
+On graceful shutdown, `release()` deletes the row outright, so the next instance can
+acquire immediately instead of waiting out the stale threshold.
+
+## API
+
+```python
+Mutex(
+    dsn: str | None = None,               # or pass pool / async_pool instead
+    lock_name: str,
+    *,
+    pool: psycopg_pool.ConnectionPool | None = None,
+    async_pool: psycopg_pool.AsyncConnectionPool | None = None,
+    instance_id: str | None = None,       # default: "<hostname>-<random>"
+    table: str = "mutex_lock",
+    heartbeat_interval: float = 10.0,
+    alert_threshold: float = 30.0,
+    stale_threshold: float = 600.0,
+    poll_interval: float = 0.5,           # blocking-acquire retry interval
+    metrics: MetricsHook | None = None,
+)
+```
+
+- `mutex.acquire(blocking=False, timeout=None)` — sync context manager, yields `bool`
+- `mutex.acquire_async(blocking=True, timeout=None)` — async context manager
+- `mutex.release()` / `mutex.release_async()`
+- `mutex.heartbeat()` / `mutex.heartbeat_async()` — manual heartbeat (usually automatic)
+- `mutex.singleton(lock_name=None, *, blocking=False, timeout=None)` — decorator
+- `mutex.singleton_async(...)` — async decorator
+- `mutex.create_schema()` / `mutex.create_schema_async()` — idempotent `CREATE TABLE IF NOT EXISTS`
+
+### Metrics
+
+Implement whichever subset of `MetricsHook` you care about (Prometheus, OpenTelemetry,
+statsd, or your own):
+
+```python
+class PrometheusMetrics:
+    def acquired(self, lock_name, *, instance_id): ...
+    def released(self, lock_name, *, instance_id): ...
+    def contended(self, lock_name, *, instance_id): ...
+    def stale_reclaimed(self, lock_name, *, instance_id, previous_holder): ...
+    def alert(self, lock_name, *, holder, seconds_since_heartbeat): ...
+    def heartbeat_latency(self, lock_name, *, instance_id, seconds): ...
+
+
+mutex = Mutex(dsn, "nightly-report-job", metrics=PrometheusMetrics())
+```
+
+A broken metrics implementation can never break the lock — every call is wrapped in a
+best-effort try/except.
+
+## Why not X?
+
+| | Extra infra? | Survives a crash cleanly? | Blocks other queries? | Notes |
+|---|---|---|---|---|
+| **postgres-mutex** | No — uses Postgres you already have | Yes — heartbeat + dual-threshold auto-release | No | Single table, ~one round trip per acquire |
+| **Redis Redlock** | Yes — Redis (ideally 5 independent nodes) | Depends on TTL tuning | No | Correctness has been [actively debated](https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html) for multi-node deployments |
+| **ShedLock** | No extra infra, but adds a dependency + its own table conventions | Yes, similar TTL model | No | Good option if you're already on it; postgres-mutex is a smaller, dependency-light alternative |
+| **`SELECT ... FOR UPDATE`** | No | No — a crashed holder's transaction rollback releases it, but a hung connection holds the lock indefinitely and blocks readers | Yes — blocks queries waiting on the row/table | Simplest option for short critical sections inside one transaction; not a good fit for "hold across a long job" |
+| **ZooKeeper / Consul / etcd** | Yes — a whole coordination service to run and operate | Yes — ephemeral nodes / sessions | No | Correct and battle-tested, but a lot of infrastructure for "run this job on one instance" |
+
+## Failure modes, explicitly
+
+- **Holder crashes**: heartbeat stops. Alert fires at `alert_threshold` (default 30s).
+  Lock is reclaimable by any other instance at `stale_threshold` (default 600s).
+- **Holder is just slow** (GC pause, long query): same alert fires at 30s — that's the
+  point, so a human can tell "slow" from "dead" before the system takes action.
+- **Network partition** (holder alive, can't reach Postgres): heartbeats fail
+  silently and retry; from every other instance's point of view this is
+  indistinguishable from a crash, so the same dual-threshold logic applies. If the
+  partition heals before `stale_threshold`, the original holder keeps the lock. If not,
+  another instance reclaims it, and the original holder's next heartbeat raises
+  `LockNotHeldError` — write your job logic to check for that on long-running work if
+  split-brain during the alert window is unacceptable for your use case.
+- **Clock skew between instances**: irrelevant. Every staleness check runs `now() -
+  last_heartbeat` inside one Postgres statement — only the Postgres server's clock is
+  ever consulted.
+- **`instance_id` reused across two live processes**: don't do this — release/heartbeat
+  scoping is by `(lock_name, instance_id)`, so two processes sharing an `instance_id`
+  can each mutate the other's lock state. The default (`hostname-<random>`) avoids
+  this; set your own only if it's genuinely unique per process.
+
+## What's not in v1
+
+- No fencing tokens
+- No read/write locks — single mutex only
+- No lock hierarchies
+- No cross-database coordination
+- Postgres only (MySQL/SQLite not planned for v1)
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest              # spins up real Postgres via testcontainers — needs Docker
+ruff check .
+mypy
+```
+
+## License
+
+MIT

postgres_mutex-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+postgres_mutex/__init__.py,sha256=Bs-K5CGp-q_q12y7t2D5sBMRex69JAjIpSIRAonvvrU,652
+postgres_mutex/_async.py,sha256=qPlpj1FR4WgzQ4rX-I9tmSIbxsIAVUF2fiXSnISyBWA,11658
+postgres_mutex/_config.py,sha256=J1tEq-01tEcbZAEJHr3z4I8vb8mVHxdDmYev5R_87aQ,2082
+postgres_mutex/_sql.py,sha256=wOI_Fj4Jp_VA7CwronMM0EITd4NhWMPW5JcoDZR-6AM,2574
+postgres_mutex/_sync.py,sha256=diMXziHYExjsW1Yom1F3Ga6rSsnlUQMSdyYUGmZMjlg,11867
+postgres_mutex/exceptions.py,sha256=4oFYvurr0sE14lms4JrfMrDhvuC3LxU1nxf1R9FnWE8,1122
+postgres_mutex/metrics.py,sha256=mwPR5oaxzQ1ZkoG8q_obVLkXFUDp78hjyC6My94EFqU,3099
+postgres_mutex/mutex.py,sha256=CAcNKT4uonn8xsYPFVTVylwqQnwsa00MjEZb7qGwuiI,12923
+postgres_mutex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+postgres_mutex-0.1.0.dist-info/METADATA,sha256=wAk_hGKYAk346d5BIJoVFYwFf-LIxdp2WPyY85nfh4k,11069
+postgres_mutex-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+postgres_mutex-0.1.0.dist-info/licenses/LICENSE,sha256=PqvBoZmFz07eUUbwFsE4I1CFLngmhk2tEzYvaO-eXss,1067
+postgres_mutex-0.1.0.dist-info/RECORD,,

postgres_mutex-0.1.0.dist-info/WHEEL

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

postgres_mutex-0.1.0.dist-info/licenses/LICENSE

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