fencekit 0.1.0__tar.gz

fencekit-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+.venv/
+venv/
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.eggs/
+dist/
+build/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.hypothesis/
+.coverage
+htmlcov/
+*.cover
+.env
+.DS_Store
+uv.lock

fencekit-0.1.0/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-07-16
+
+### Added
+
+- `idempotency_key` with deterministic JSON canonicalization
+- owner-bound `IdempotencyGuard` via Redis `SET NX EX`
+- `DistributedLock` with atomic acquire + fencing token (Lua)
+- `FenceGate` with atomic fenced Redis string writes
+- Typed public API (`py.typed`), errors, and key helpers
+- Unit, property (Hypothesis), and Redis integration tests
+- `DESIGN.md` documenting guarantees, non-guarantees, and crash semantics

fencekit-0.1.0/DESIGN.md

@@ -0,0 +1,226 @@
+# Design: fencekit
+
+## Purpose
+
+fencekit coordinates repeated delivery of background jobs and rejects stale
+writes through Redis fencing tokens. Celery orchestration and Redlock are outside
+its scope. The library makes no exactly-once delivery claim.
+
+## Origin
+
+ChessMate's Celery jobs analyze imported games with Stockfish and then write coaching
+reports. Worker crashes caused some jobs to be delivered again. The same batch could
+run twice. Duplicate runs wasted Stockfish CPU and left the saved progress ambiguous.
+fencekit contains the Redis operations pulled from those tasks. Its tests reproduce
+worker death and lock-expiry races.
+
+## Threat model
+
+Trusted: Redis is trusted infrastructure in v0.1 (no authz inside the library;
+use Redis ACLs/network policy at the ops layer). Callers are trusted not to forge
+`owner_id` for locks they do not hold (owner IDs are random UUIDs per acquire).
+
+Untrusted / hostile: concurrent workers, process kill mid-task, GC pauses
+longer than lock TTL, network delay delivering stale writes, Celery redelivery.
+
+Redis administrators are outside the threat model. So are compromised workers that
+bypass the API. The v0.1 model excludes split-brain and multi-primary failover.
+
+## Algorithms
+
+### Idempotency
+
+```
+SET {prefix}:idem:{namespace}:{sha256} "pending:{owner_id}" NX EX ttl
+```
+
+Only one caller begins. `mark_done` uses Lua to compare the guard owner before
+setting `done` (with an optional TTL refresh), so a stale worker cannot complete
+a key reclaimed by another worker after expiry.
+
+Canonicalization rules:
+
+- top-level payload and nested objects are mappings with string keys;
+- mapping keys are sorted recursively; sequence order is preserved;
+- JSON uses compact separators, UTF-8 input, and `ensure_ascii=True`;
+- integers and floats retain JSON's distinct spellings (`1` vs `1.0`);
+- NaN/infinity, bytes, sets, datetimes, and custom objects are rejected;
+- the key suffix is lowercase SHA-256 hex of the canonical JSON bytes; and
+- namespaces are non-empty and contain neither whitespace nor `:`.
+
+Callers must normalize business values (for example, datetime ISO format and
+case normalization) before calling `idempotency_key`. Key stability is part of
+the producer contract.
+
+### Lock + fencing token (atomic)
+
+Lua on acquire:
+
+```lua
+-- KEYS[1]=lock, KEYS[2]=sequence; ARGV[1]=owner, ARGV[2]=ttl_ms
+if redis.call('EXISTS', KEYS[1]) == 1 then
+  return false
+end
+local token = redis.call('INCR', KEYS[2])
+if redis.call('SET', KEYS[1], ARGV[1], 'PX', ARGV[2], 'NX') then
+  return token
+end
+return false
+```
+
+The script is atomic: no other client can acquire between `EXISTS` and `SET`.
+`INCR` precedes `SET` because Redis scripts do not roll back earlier
+writes after a runtime error. A corrupt or overflowing counter therefore cannot
+leave a lock without a token. Failed attempts can consume a token only if the
+final `SET` unexpectedly fails. Gaps are safe; the counter only needs to increase.
+
+Release and extend compare ownership in the same script as the mutation:
+
+```lua
+-- release: KEYS[1]=lock, ARGV[1]=owner
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('DEL', KEYS[1])
+end
+return 0
+
+-- extend: KEYS[1]=lock, ARGV[1]=owner, ARGV[2]=ttl_ms
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('PEXPIRE', KEYS[1], ARGV[2])
+end
+return 0
+```
+
+This prevents a delayed owner from deleting or extending a replacement lease.
+
+### Fence gate
+
+```lua
+local max = tonumber(redis.call('GET', max_key) or '0')
+if tonumber(token) < max then return 0 end  -- stale
+redis.call('SET', max_key, token)           -- equal token may rewrite
+return 1
+```
+
+`check` and `check_and_advance` operate only on the token registry. They are
+useful for diagnostics and coordination, but a check followed by a separate
+write has a time-of-check/time-of-use race. For Redis string state,
+`FenceGate.set_if_fresh` checks the token and writes the target in one Lua script.
+The script also records the accepted token. Other Redis data types require an
+equivalent application Lua script. External stores must compare the token in the
+same transaction or statement as their mutation.
+
+The Redis string helper is:
+
+```lua
+-- KEYS[1]=max_key, KEYS[2]=target; ARGV[1]=token, ARGV[2]=value
+local max = tonumber(redis.call('GET', KEYS[1]) or '0')
+local token = tonumber(ARGV[1])
+if token < max then return 0 end
+redis.call('SET', KEYS[1], ARGV[1])
+redis.call('SET', KEYS[2], ARGV[2])
+return 1
+```
+
+Martin Kleppmann describes the stale-holder problem in
+[How to do distributed locking](https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html).
+TTL locks cannot stop a paused holder, so **the storage layer must reject stale
+tokens**. Redis's
+[distributed-lock documentation](https://redis.io/docs/latest/develop/clients/patterns/distributed-locks/)
+also motivates random owner values and compare-before-delete release. fencekit
+uses that ownership rule and does not implement Redlock.
+
+## Guarantees
+
+| Claim | Status |
+|-------|--------|
+| At-most-once *start* within the idempotency TTL (Redis up) | Yes |
+| Mutual exclusion while lease held (single primary) | Best-effort |
+| Stale holder cannot mutate via atomic `set_if_fresh` | Yes |
+| Exactly-once delivery | No |
+| HA / failover / Redlock safety | No |
+| Writes that skip the token | No |
+
+At-most-once side effects require the application storage layer to combine the
+fencing check with a unique business-operation key in one transaction. A fence
+prevents stale overwrites. It cannot make a non-idempotent external API, such as
+a card charge, execute exactly once.
+
+## Non-guarantees and risks
+
+1. Redlock. fencekit does not implement multi-key majority locking. Its v0.1
+   safety model uses one Redis primary and storage-side fencing.
+2. Single Redis primary. Asynchronous failover may allow overlapping leases
+   or roll back a fence counter, so do not claim HA mutual exclusion or global
+   token monotonicity across failover. Redis Cluster is unsupported in v0.1;
+   multi-key Lua scripts also require keys in one hash slot.
+3. Clock skew. Redis server `PX` controls expiry. Worker-to-server skew does not
+   decide ownership. A Redis server clock jump can still make leases expire early
+   or late. Do not implement "lock valid until" on the worker wall clock; blocking
+   waits use the client monotonic clock only.
+4. Cooperative storage. Postgres (or S3, etc.) must also compare tokens in
+   the mutation itself. A separate preflight check cannot protect another store.
+5. GC pause > TTL. A newer token fences out the paused holder after its lease
+   expires.
+6. Idempotency TTL. Too short means a duplicate begin after expiry. Too long can
+   leave a key stuck in `pending` if a worker dies without `mark_done`/`clear`.
+   Align with the job SLA; v0.2 may add explicit takeover rules.
+7. Counter persistence and overflow. Fence counters intentionally do not
+   expire. Deleting/restoring/rolling them back can reuse old token values and
+   breaks monotonicity. Redis integer overflow makes acquisition fail safely
+   before the lock key is written.
+8. Ambiguous network outcomes. A client timeout does not prove Redis did not
+   apply a command. A fresh acquire cannot create a second lease while the first
+   key remains, but the caller may not know it owns the first lease. Likewise,
+   an idempotency `SET` whose reply was lost may suppress work until its TTL.
+   Applications must treat connection errors as an unknown outcome and reconcile.
+
+## Crash / restart semantics
+
+1. Kill while lock valid: lock remains until TTL; redelivery fails acquire /
+   `try_begin` while key is pending/done.
+2. Kill after TTL: new owner gets higher token; stale atomic fenced writes
+   fail (`FencedOutError`). See `tests/property/test_fencing_expiry.py`.
+3. Celery redelivery: same idempotency key means `try_begin` is False while TTL
+   holds.
+4. Partial side effects (temp files, half-written rows) remain an application
+   concern; fence every durable mutation.
+
+## TTL guidance
+
+Set the lock TTL longer than one chunk of work plus its heartbeat margin. Extend
+the lease regularly. Short leases recover faster after worker death than
+multi-hour leases.
+
+The idempotency TTL should cover retries and the maximum job duration. Use a longer
+value when a duplicate start after completion would be unsafe.
+
+## Key naming
+
+| Purpose | Pattern |
+|---------|---------|
+| Idempotency | `{prefix}:idem:{namespace}:{sha256}` |
+| Lock | `{prefix}:lock:{resource}` |
+| Fence sequence | `{prefix}:fence:seq:{resource}` |
+| Fence max | `{prefix}:fence:max:{resource}` |
+
+Default `prefix=fencekit`.
+
+## Trust boundaries
+
+Payloads are JSON-canonicalized; fencekit does not use pickle. The library does
+not log Redis URLs or credentials. v0.1 treats Redis as trusted infrastructure,
+so production deployments should restrict it with network controls and Redis
+ACLs.
+
+## Postgres pattern (app-owned)
+
+```sql
+UPDATE analysis_job
+SET progress = %(progress)s, fence_token = %(token)s
+WHERE id = %(id)s AND fence_token <= %(token)s;
+-- rowcount 0 => fenced out
+```
+
+## Versioning
+
+Semver from 0.1.0. Breaking API changes bump minor while 0.x.

fencekit-0.1.0/LICENSE

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

fencekit-0.1.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: fencekit
+Version: 0.1.0
+Summary: Redis-backed idempotent task primitives: fencing tokens and distributed locks
+Project-URL: Homepage, https://github.com/ahmed5145/fencekit
+Project-URL: Documentation, https://github.com/ahmed5145/fencekit/blob/main/DESIGN.md
+Project-URL: Changelog, https://github.com/ahmed5145/fencekit/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/ahmed5145/fencekit
+Author-email: Ahmed Mohamed <ahmed5145@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: celery,distributed-lock,fencing-token,idempotency,redis
+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 :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: redis>=5.0.0
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.100; extra == 'dev'
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.3; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# fencekit
+
+Redis-backed idempotency and fenced locks for background jobs. A destination that
+atomically checks the fencing token can reject writes from a stale lock holder.
+
+## Why
+
+ChessMate ([chess-mate.online](https://chess-mate.online)) runs imported games
+through Stockfish before writing a coaching report. With Redis as the Celery broker
+and late acknowledgements enabled, a worker crash can cause the same job to be
+delivered again. I saw batches progress twice. That wasted Stockfish CPU and left
+the recorded progress ambiguous.
+
+Celery requires late-ack tasks to be idempotent, but each task still needs code to
+enforce that property. fencekit collects the Redis operations I used in ChessMate.
+Its tests reproduce worker death and lock-expiry races.
+
+## Install
+
+```bash
+pip install fencekit
+# or
+uv add fencekit
+```
+
+Requires Redis 6+ (tested with Redis 7) and Python 3.10+.
+
+## 30-second example
+
+```python
+from datetime import timedelta
+from redis import Redis
+
+from fencekit import (
+    DistributedLock,
+    FenceGate,
+    IdempotencyGuard,
+    idempotency_key,
+)
+
+r = Redis.from_url("redis://localhost:6379/0", decode_responses=True)
+guard = IdempotencyGuard(r)
+lock = DistributedLock(r)
+fence = FenceGate(r)
+
+def analyze_batch() -> None:
+    key = idempotency_key(
+        {"game_ids": ["abc", "def"], "engine": "sf16"},
+        namespace="analysis",
+    )
+    if not guard.try_begin(key, ttl=timedelta(hours=24)):
+        return  # already started or completed
+
+    handle = lock.acquire("analysis:batch-42", ttl=timedelta(minutes=5))
+    try:
+        # Atomic fence check + Redis progress write:
+        fence.set_if_fresh(handle.token, "analysis:batch-42:status", "running")
+        # Extend the lock on heartbeats and fence every durable write.
+        guard.mark_done(key)
+    finally:
+        lock.release(handle)
+```
+
+## Guarantees
+
+| Claim | Status |
+|-------|--------|
+| At-most-once *start* within the idempotency TTL (Redis available) | Yes (`SET NX`) |
+| Mutual exclusion while lock TTL held (single Redis primary) | Best-effort lease |
+| Stale holder cannot overwrite via atomic `FenceGate.set_if_fresh` | Yes |
+| Exactly-once delivery | No |
+| Safety under Redis failover / split brain | No (v0.1) |
+| Safety if the app writes without presenting the token | No |
+
+See [DESIGN.md](DESIGN.md) for the threat model, Lua algorithms, TTL guidance, and
+crash/restart semantics. fencekit does not implement Redlock.
+
+Fencing covers stale overwrites. Exactly-once external effects also require the
+destination to enforce the fence token and a unique business-operation key in
+one atomic operation.
+
+## Running tests
+
+```bat
+REM CMD (Windows), no uv required
+cd fencekit
+python -m pip install -e ".[dev]"
+python -m ruff check --fix src tests
+python -m ruff check src tests
+python -m mypy src
+python -m pytest -m "not integration" -q
+```
+
+The full suite needs Redis on `localhost:6379`:
+
+```bat
+set FENCEKIT_REDIS_URL=redis://localhost:6379/15
+python -m pytest -q
+```
+
+Integration tests skip cleanly when Redis is unreachable or `FENCEKIT_REDIS_URL` is unset.
+
+```bash
+# Linux/macOS with uv + Docker
+uv sync --extra dev
+uv run pytest -m "not integration"
+docker run -d -p 6379:6379 --name fencekit-redis redis:7
+export FENCEKIT_REDIS_URL=redis://localhost:6379/15
+uv run pytest
+```
+
+v0.1 has no Celery adapter. A later release may add one as an optional extra.
+
+## License
+
+MIT

fencekit-0.1.0/README.md

@@ -0,0 +1,116 @@
+# fencekit
+
+Redis-backed idempotency and fenced locks for background jobs. A destination that
+atomically checks the fencing token can reject writes from a stale lock holder.
+
+## Why
+
+ChessMate ([chess-mate.online](https://chess-mate.online)) runs imported games
+through Stockfish before writing a coaching report. With Redis as the Celery broker
+and late acknowledgements enabled, a worker crash can cause the same job to be
+delivered again. I saw batches progress twice. That wasted Stockfish CPU and left
+the recorded progress ambiguous.
+
+Celery requires late-ack tasks to be idempotent, but each task still needs code to
+enforce that property. fencekit collects the Redis operations I used in ChessMate.
+Its tests reproduce worker death and lock-expiry races.
+
+## Install
+
+```bash
+pip install fencekit
+# or
+uv add fencekit
+```
+
+Requires Redis 6+ (tested with Redis 7) and Python 3.10+.
+
+## 30-second example
+
+```python
+from datetime import timedelta
+from redis import Redis
+
+from fencekit import (
+    DistributedLock,
+    FenceGate,
+    IdempotencyGuard,
+    idempotency_key,
+)
+
+r = Redis.from_url("redis://localhost:6379/0", decode_responses=True)
+guard = IdempotencyGuard(r)
+lock = DistributedLock(r)
+fence = FenceGate(r)
+
+def analyze_batch() -> None:
+    key = idempotency_key(
+        {"game_ids": ["abc", "def"], "engine": "sf16"},
+        namespace="analysis",
+    )
+    if not guard.try_begin(key, ttl=timedelta(hours=24)):
+        return  # already started or completed
+
+    handle = lock.acquire("analysis:batch-42", ttl=timedelta(minutes=5))
+    try:
+        # Atomic fence check + Redis progress write:
+        fence.set_if_fresh(handle.token, "analysis:batch-42:status", "running")
+        # Extend the lock on heartbeats and fence every durable write.
+        guard.mark_done(key)
+    finally:
+        lock.release(handle)
+```
+
+## Guarantees
+
+| Claim | Status |
+|-------|--------|
+| At-most-once *start* within the idempotency TTL (Redis available) | Yes (`SET NX`) |
+| Mutual exclusion while lock TTL held (single Redis primary) | Best-effort lease |
+| Stale holder cannot overwrite via atomic `FenceGate.set_if_fresh` | Yes |
+| Exactly-once delivery | No |
+| Safety under Redis failover / split brain | No (v0.1) |
+| Safety if the app writes without presenting the token | No |
+
+See [DESIGN.md](DESIGN.md) for the threat model, Lua algorithms, TTL guidance, and
+crash/restart semantics. fencekit does not implement Redlock.
+
+Fencing covers stale overwrites. Exactly-once external effects also require the
+destination to enforce the fence token and a unique business-operation key in
+one atomic operation.
+
+## Running tests
+
+```bat
+REM CMD (Windows), no uv required
+cd fencekit
+python -m pip install -e ".[dev]"
+python -m ruff check --fix src tests
+python -m ruff check src tests
+python -m mypy src
+python -m pytest -m "not integration" -q
+```
+
+The full suite needs Redis on `localhost:6379`:
+
+```bat
+set FENCEKIT_REDIS_URL=redis://localhost:6379/15
+python -m pytest -q
+```
+
+Integration tests skip cleanly when Redis is unreachable or `FENCEKIT_REDIS_URL` is unset.
+
+```bash
+# Linux/macOS with uv + Docker
+uv sync --extra dev
+uv run pytest -m "not integration"
+docker run -d -p 6379:6379 --name fencekit-redis redis:7
+export FENCEKIT_REDIS_URL=redis://localhost:6379/15
+uv run pytest
+```
+
+v0.1 has no Celery adapter. A later release may add one as an optional extra.
+
+## License
+
+MIT

fencekit-0.1.0/pyproject.toml

@@ -0,0 +1,100 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fencekit"
+version = "0.1.0"
+description = "Redis-backed idempotent task primitives: fencing tokens and distributed locks"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Ahmed Mohamed", email = "ahmed5145@users.noreply.github.com" },
+]
+keywords = [
+    "redis",
+    "distributed-lock",
+    "fencing-token",
+    "idempotency",
+    "celery",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Distributed Computing",
+    "Typing :: Typed",
+]
+dependencies = [
+    "redis>=5.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ahmed5145/fencekit"
+Documentation = "https://github.com/ahmed5145/fencekit/blob/main/DESIGN.md"
+Changelog = "https://github.com/ahmed5145/fencekit/blob/main/CHANGELOG.md"
+Repository = "https://github.com/ahmed5145/fencekit"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-timeout>=2.3",
+    "hypothesis>=6.100",
+    "ruff>=0.8",
+    "mypy>=1.13",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fencekit"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/tests",
+    "/README.md",
+    "/DESIGN.md",
+    "/CHANGELOG.md",
+    "/LICENSE",
+]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = ["tests"]
+markers = [
+    "integration: tests that require a real Redis instance (FENCEKIT_REDIS_URL)",
+]
+timeout = 60
+addopts = "-ra"
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "UP",
+    "B",
+    "SIM",
+    "RUF",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["fencekit"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+mypy_path = "src"
+packages = ["fencekit"]

fencekit-0.1.0/src/fencekit/__init__.py

@@ -0,0 +1,38 @@
+"""Redis idempotency and fenced locks for background jobs."""
+
+from fencekit._version import __version__
+from fencekit.canonicalize import canonicalize, idempotency_key
+from fencekit.client import RedisClient, SyncRedis
+from fencekit.errors import (
+    CanonicalizeError,
+    FencedOutError,
+    FenceKitError,
+    IdempotencyNotOwned,
+    LockNotAcquired,
+    LockNotOwned,
+    TokenExpiredError,
+)
+from fencekit.fence import FenceGate
+from fencekit.idempotency import IdempotencyGuard
+from fencekit.lock import DistributedLock
+from fencekit.types import FenceToken, LockHandle
+
+__all__ = [
+    "CanonicalizeError",
+    "DistributedLock",
+    "FenceGate",
+    "FenceKitError",
+    "FenceToken",
+    "FencedOutError",
+    "IdempotencyGuard",
+    "IdempotencyNotOwned",
+    "LockHandle",
+    "LockNotAcquired",
+    "LockNotOwned",
+    "RedisClient",
+    "SyncRedis",
+    "TokenExpiredError",
+    "__version__",
+    "canonicalize",
+    "idempotency_key",
+]

fencekit-0.1.0/src/fencekit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"