fastapi-stream-lease 0.1.0__py3-none-any.whl

fastapi_stream_lease/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from fastapi_stream_lease.config import LeaseConfig
+from fastapi_stream_lease.exceptions import StreamLeaseError, StreamLeaseRejected
+from fastapi_stream_lease.lease import StreamLease
+from fastapi_stream_lease.manager import StreamLeaseManager
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "LeaseConfig",
+    "StreamLease",
+    "StreamLeaseError",
+    "StreamLeaseManager",
+    "StreamLeaseRejected",
+    "__version__",
+]

fastapi_stream_lease/config.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class LeaseConfig:
+    """Configuration for stream lease management."""
+
+    lease_seconds: float = 30.0
+    """Duration (in seconds) of each lease before expiring in Redis if not renewed."""
+
+    max_per_user: int = 3
+    """Maximum concurrent streams allowed for a single user/principal key."""
+
+    max_global: int = 500
+    """Maximum concurrent streams allowed across the entire cluster."""
+
+    key_prefix: str = "stream_lease"
+    """Prefix for Redis keys (e.g. stream_lease:user:{id}, stream_lease:global)."""
+
+    def __post_init__(self) -> None:
+        if self.lease_seconds <= 0:
+            raise ValueError("lease_seconds must be greater than 0")
+        if self.max_per_user < 0:
+            raise ValueError("max_per_user cannot be negative")
+        if self.max_global < 0:
+            raise ValueError("max_global cannot be negative")
+
+    @property
+    def _cluster_prefix(self) -> str:
+        """Ensure prefix uses Redis hash tags {...} for slot affinity in Redis Cluster."""
+        if "{" in self.key_prefix and "}" in self.key_prefix:
+            return self.key_prefix
+        return f"{{{self.key_prefix}}}"
+
+    def user_key(self, user_id: str | int) -> str:
+        return f"{self._cluster_prefix}:user:{user_id}"
+
+    @property
+    def global_key(self) -> str:
+        return f"{self._cluster_prefix}:global"
+
+    @property
+    def redis_ttl(self) -> int:
+        """TTL set on Redis keys to ensure dead keys self-clean (twice lease duration)."""
+        return max(60, int(self.lease_seconds * 2))

fastapi_stream_lease/exceptions.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+
+class StreamLeaseError(Exception):
+    """Base exception for all stream lease errors."""
+
+
+class StreamLeaseRejected(StreamLeaseError):
+    """Raised when a stream lease request is rejected due to concurrency limits."""
+
+    def __init__(
+        self,
+        reason: Literal["user_limit", "global_limit"],
+        retry_after: int = 5,
+        detail: str | None = None,
+    ) -> None:
+        self.reason: Literal["user_limit", "global_limit"] = reason
+        self.retry_after: int = retry_after
+        self.detail: str = detail or (
+            "User stream limit reached" if reason == "user_limit" else "Global stream limit reached"
+        )
+        super().__init__(f"Stream lease rejected: {self.reason} - {self.detail}")
+
+    def as_response(self) -> Any:
+        """Convert this rejection into a JSONResponse (HTTP 429)."""
+        try:
+            from starlette.responses import JSONResponse
+        except ImportError as err:
+            raise RuntimeError(
+                "Starlette or FastAPI must be installed to use as_response()"
+            ) from err
+
+        return JSONResponse(
+            status_code=429,
+            content={
+                "code": "stream_connection_limit",
+                "reason": self.reason,
+                "detail": self.detail,
+            },
+            headers={"Retry-After": str(self.retry_after)},
+        )
+
+    def as_http_exception(self) -> Any:
+        """Convert this rejection into a FastAPI/Starlette HTTPException (HTTP 429) to be raised."""
+        try:
+            from starlette.exceptions import HTTPException
+        except ImportError as err:
+            raise RuntimeError(
+                "FastAPI or Starlette must be installed to use as_http_exception()"
+            ) from err
+
+        return HTTPException(
+            status_code=429,
+            detail=self.detail,
+            headers={"Retry-After": str(self.retry_after)},
+        )

fastapi_stream_lease/lease.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from collections.abc import AsyncIterable, AsyncIterator
+from contextlib import suppress
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, TypeVar
+
+if TYPE_CHECKING:
+    from fastapi_stream_lease.manager import StreamLeaseManager
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+@dataclass
+class StreamLease:
+    """Represents an active, acquired stream lease."""
+
+    lease_id: str
+    user_id: str | int
+    user_key: str
+    global_key: str
+    manager: StreamLeaseManager
+    created_at: float = field(default_factory=time.time)
+    _is_released: bool = field(default=False, init=False)
+
+    async def __aenter__(self) -> StreamLease:
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.release()
+
+    async def renew(self) -> bool:
+        """Manually renew this lease, extending its TTL in Redis."""
+        if self._is_released:
+            return False
+        return await self.manager.renew(self)
+
+    async def release(self) -> None:
+        """Explicitly release this lease from Redis."""
+        if self._is_released:
+            return
+        self._is_released = True
+        await self.manager.release(self)
+
+    async def wrap(
+        self,
+        stream: AsyncIterable[T],
+        auto_renew: bool = True,
+        renew_interval: float | None = None,
+    ) -> AsyncIterator[T]:
+        """
+        Wrap an async stream (e.g. SSE event generator or LLM token stream).
+
+        Guarantees that:
+        1. A background renewal worker keeps the lease alive during long pauses
+           (such as slow LLM time-to-first-token or client idle periods).
+        2. When the stream terminates, is cancelled, or the client disconnects,
+           the lease is guaranteed to be released in the `finally` block.
+        """
+        if renew_interval is not None and renew_interval >= self.manager.config.lease_seconds:
+            logger.warning(
+                "renew_interval (%.1fs) >= lease_seconds (%.1fs) on lease %s",
+                renew_interval,
+                self.manager.config.lease_seconds,
+                self.lease_id,
+            )
+
+        interval = renew_interval or (self.manager.config.lease_seconds / 2.0)
+        renew_task: asyncio.Task[None] | None = None
+
+        async def _auto_renew_worker() -> None:
+            while not self._is_released:
+                await asyncio.sleep(interval)
+                success = await self.renew()
+                if not success:
+                    logger.warning("Stream lease %s was lost during auto-renewal", self.lease_id)
+                    break
+
+        if auto_renew:
+            renew_task = asyncio.create_task(_auto_renew_worker())
+
+        try:
+            async for chunk in stream:
+                yield chunk
+        finally:
+            if renew_task is not None:
+                renew_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await renew_task
+            await self.release()

fastapi_stream_lease/lua.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+# Atomic Lua script to acquire a stream lease:
+# Checks and clears expired leases, validates user and global limits, and adds the lease.
+# Returns:
+#   1 -> Acquired successfully
+#   2 -> User stream limit reached
+#   3 -> Global stream limit reached
+ACQUIRE_SCRIPT = """
+local user_key = KEYS[1]
+local global_key = KEYS[2]
+local now = tonumber(ARGV[1])
+local expires = tonumber(ARGV[2])
+local lease_id = ARGV[3]
+local user_limit = tonumber(ARGV[4])
+local global_limit = tonumber(ARGV[5])
+local ttl = tonumber(ARGV[6])
+
+redis.call('ZREMRANGEBYSCORE', user_key, '-inf', now)
+if global_limit > 0 then
+    redis.call('ZREMRANGEBYSCORE', global_key, '-inf', now)
+end
+
+if user_limit > 0 and redis.call('ZCARD', user_key) >= user_limit then
+    return 2
+end
+
+if global_limit > 0 and redis.call('ZCARD', global_key) >= global_limit then
+    return 3
+end
+
+redis.call('ZADD', user_key, expires, lease_id)
+redis.call('EXPIRE', user_key, ttl)
+
+if global_limit > 0 then
+    redis.call('ZADD', global_key, expires, lease_id)
+    redis.call('EXPIRE', global_key, ttl)
+end
+
+return 1
+"""
+
+# Atomic Lua script to renew an active stream lease:
+# Verifies the lease is still active in sets and extends its expiration.
+# Returns:
+#   1 -> Renewed successfully
+#   0 -> Lease not found or already expired
+RENEW_SCRIPT = """
+local user_key = KEYS[1]
+local global_key = KEYS[2]
+local lease_id = ARGV[1]
+local new_expires = tonumber(ARGV[2])
+local ttl = tonumber(ARGV[3])
+local check_global = tonumber(ARGV[4]) or 1
+
+if not redis.call('ZSCORE', user_key, lease_id) then
+    return 0
+end
+
+if check_global > 0 and not redis.call('ZSCORE', global_key, lease_id) then
+    return 0
+end
+
+redis.call('ZADD', user_key, new_expires, lease_id)
+redis.call('EXPIRE', user_key, ttl)
+
+if check_global > 0 then
+    redis.call('ZADD', global_key, new_expires, lease_id)
+    redis.call('EXPIRE', global_key, ttl)
+end
+
+return 1
+"""
+
+# Atomic Lua script to release a stream lease immediately:
+# Removes the lease from both user and global sets.
+RELEASE_SCRIPT = """
+local user_key = KEYS[1]
+local global_key = KEYS[2]
+local lease_id = ARGV[1]
+
+redis.call('ZREM', user_key, lease_id)
+redis.call('ZREM', global_key, lease_id)
+
+return 1
+"""
+
+# Atomic script to clean expired elements and return active stream count:
+COUNT_SCRIPT = """
+local target_key = KEYS[1]
+local now = tonumber(ARGV[1])
+
+redis.call('ZREMRANGEBYSCORE', target_key, '-inf', now)
+return redis.call('ZCARD', target_key)
+"""

fastapi_stream_lease/manager.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any
+from uuid import uuid4
+
+from fastapi_stream_lease.config import LeaseConfig
+from fastapi_stream_lease.exceptions import StreamLeaseRejected
+from fastapi_stream_lease.lease import StreamLease
+from fastapi_stream_lease.lua import (
+    ACQUIRE_SCRIPT,
+    COUNT_SCRIPT,
+    RELEASE_SCRIPT,
+    RENEW_SCRIPT,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StreamLeaseManager:
+    """
+    Coordinates distributed stream concurrency leases backed by atomic Redis Lua scripts.
+    """
+
+    def __init__(self, redis: Any, config: LeaseConfig | None = None) -> None:
+        self.redis = redis
+        self.config: LeaseConfig = config or LeaseConfig()
+
+    async def acquire(self, user_id: str | int) -> StreamLease:
+        """
+        Acquire a new stream lease for the given user.
+
+        Raises:
+            StreamLeaseRejected: If user or global concurrency limits are exceeded.
+            RuntimeError: If Redis evaluation fails unexpectedly.
+        """
+        lease_id = uuid4().hex
+        user_key = self.config.user_key(user_id)
+        global_key = self.config.global_key
+        now = time.time()
+        expires = now + self.config.lease_seconds
+
+        result = await self.redis.eval(
+            ACQUIRE_SCRIPT,
+            2,
+            user_key,
+            global_key,
+            now,
+            expires,
+            lease_id,
+            self.config.max_per_user,
+            self.config.max_global,
+            self.config.redis_ttl,
+        )
+
+        code = int(result)
+        if code == 2:
+            raise StreamLeaseRejected(reason="user_limit")
+        if code == 3:
+            raise StreamLeaseRejected(reason="global_limit")
+        if code != 1:
+            raise RuntimeError(f"Unexpected stream lease acquisition return code: {code}")
+
+        return StreamLease(
+            lease_id=lease_id,
+            user_id=user_id,
+            user_key=user_key,
+            global_key=global_key,
+            manager=self,
+            created_at=now,
+        )
+
+    async def renew(self, lease: StreamLease) -> bool:
+        """
+        Renew an active lease, extending its TTL in Redis.
+
+        Returns:
+            bool: True if successfully extended, False if the lease expired, was evicted,
+                  or if a Redis error occurred.
+        """
+        new_expires = time.time() + self.config.lease_seconds
+        check_global = 1 if self.config.max_global > 0 else 0
+        try:
+            result = await self.redis.eval(
+                RENEW_SCRIPT,
+                2,
+                lease.user_key,
+                lease.global_key,
+                lease.lease_id,
+                new_expires,
+                self.config.redis_ttl,
+                check_global,
+            )
+            return int(result) == 1
+        except Exception as exc:
+            logger.warning("Failed to renew stream lease %s: %s", lease.lease_id, exc)
+            return False
+
+    async def release(self, lease: StreamLease) -> None:
+        """
+        Release an active lease immediately from Redis.
+        """
+        try:
+            await self.redis.eval(
+                RELEASE_SCRIPT,
+                2,
+                lease.user_key,
+                lease.global_key,
+                lease.lease_id,
+            )
+        except Exception as exc:
+            logger.warning("Failed to release stream lease %s: %s", lease.lease_id, exc)
+
+    async def get_active_count(self, user_id: str | int | None = None) -> int:
+        """
+        Return the current number of active (non-expired) streams for a user or globally.
+        """
+        target_key = (
+            self.config.user_key(user_id) if user_id is not None else self.config.global_key
+        )
+        now = time.time()
+        count = await self.redis.eval(COUNT_SCRIPT, 1, target_key, now)
+        return int(count)
+
+    @asynccontextmanager
+    async def lease(self, user_id: str | int) -> AsyncIterator[StreamLease]:
+        """
+        Context manager for acquiring and safely releasing a stream lease for scoped
+        executions (such as WebSockets, background tasks, or pub/sub loops).
+
+        For HTTP StreamingResponse (SSE / LLM tokens), use `lease = await acquire()`
+        and `return StreamingResponse(lease.wrap(...))` instead.
+
+        Example:
+            async with lease_manager.lease(user_id=42) as lease:
+                while True:
+                    msg = await websocket.receive_text()
+                    ...
+        """
+        stream_lease = await self.acquire(user_id)
+        try:
+            yield stream_lease
+        finally:
+            await stream_lease.release()

fastapi_stream_lease/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.

fastapi_stream_lease-0.1.0.dist-info/METADATA

@@ -0,0 +1,213 @@
+Metadata-Version: 2.5
+Name: fastapi-stream-lease
+Version: 0.1.0
+Summary: Distributed stream and SSE concurrency lease manager for FastAPI and Starlette backed by atomic Redis Lua scripts.
+Project-URL: Homepage, https://github.com/agustin18/fastapi-stream-lease
+Project-URL: Repository, https://github.com/agustin18/fastapi-stream-lease
+Project-URL: Issues, https://github.com/agustin18/fastapi-stream-lease/issues
+Author-email: Agustin Saiz <agustinsaiz02@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: concurrency,fastapi,llm-streaming,rate-limiting,redis,server-sent-events,sse,starlette,streaming
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+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 :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: redis>=5.0.0
+Provides-Extra: dev
+Requires-Dist: fakeredis[lua]>=2.20.0; extra == 'dev'
+Requires-Dist: fastapi>=0.100.0; extra == 'dev'
+Requires-Dist: httpx>=0.25.0; extra == 'dev'
+Requires-Dist: mypy>=1.10.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100.0; extra == 'fastapi'
+Description-Content-Type: text/markdown
+
+# fastapi-stream-lease
+
+[![CI](https://github.com/agustin18/fastapi-stream-lease/actions/workflows/ci.yml/badge.svg)](https://github.com/agustin18/fastapi-stream-lease/actions)
+[![PyPI version](https://img.shields.io/pypi/v/fastapi-stream-lease.svg)](https://pypi.org/project/fastapi-stream-lease/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code style: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+**Distributed stream and SSE concurrency lease manager for FastAPI and Starlette, backed by atomic Redis Lua scripts.**
+
+---
+
+## ⚡ The Problem: Why Traditional Rate Limiters Fail for Streams & LLMs
+
+Standard rate limiters (such as `fastapi-limiter` or `slowapi`) count **requests per unit of time** (e.g. *5 requests per minute*).
+
+While this works for standard REST APIs, it completely breaks down for **long-lived streaming connections** (Server-Sent Events, WebSockets, or streaming LLM tokens from OpenAI / Claude / Ollama):
+
+1. **Duration Blindness:** A user can make a single request that stays open for 15 minutes, consuming a server socket the entire time. A rate limiter considers this "1 request" and allows the user to open 50 more tabs.
+2. **Zombie Connection Leaks:** When mobile users switch networks or close tabs abruptly without clean TCP closure, worker connections remain blocked until timeout, causing connection pool exhaustion and denial of service.
+3. **Multi-Worker Desynchronization:** In-memory concurrency limiters (like `asyncio.Semaphore`) fail across multi-process deployments (Gunicorn / Docker containers) because workers cannot share state.
+
+```
+ Traditional Rate Limiter:               fastapi-stream-lease:
+ ┌───────────────────────┐               ┌──────────────────────────────────────────────┐
+ │ Request 1 -> ALLOWED  │               │ Stream 1 (Active)  -> LEASE ACQUIRED (1/2)   │
+ │ Request 2 -> ALLOWED  │               │ Stream 2 (Active)  -> LEASE ACQUIRED (2/2)   │
+ │ (Both streams active  │               │ Stream 3 (Attempt) -> REJECTED: HTTP 429     │
+ │  for 10 minutes,      │               │                       Retry-After: 5         │
+ │  server sockets exhausted!)           │ Stream 1 disconnects -> LEASE RELEASED       │
+ └───────────────────────┘               │ Stream 3 re-attempt -> LEASE ACQUIRED (2/2)  │
+                                         └──────────────────────────────────────────────┘
+```
+
+`fastapi-stream-lease` solves this with **Sliding Distributed Leases** inside **atomic Redis Lua scripts**:
+- Enforces strict concurrency limits **per user** (`max_per_user`) and **globally** (`max_global`).
+- Leases automatically self-expire if the client or worker dies without clean closure (zero zombies).
+- A background renewal task keeps long-running streams alive even during slow Time-To-First-Token (TTFT) pauses.
+- Released immediately when the stream finishes or client disconnects.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install fastapi-stream-lease
+```
+
+Or using `uv`:
+
+```bash
+uv add fastapi-stream-lease
+```
+
+*(Requires Redis 5.0+ and Python 3.10+)*
+
+---
+
+## 💡 Quickstart
+
+Protect an SSE or LLM streaming endpoint in just a few lines:
+
+```python
+from fastapi import FastAPI, Depends, Request
+from fastapi.responses import StreamingResponse
+import redis.asyncio as redis
+
+from fastapi_stream_lease import (
+    StreamLeaseManager,
+    LeaseConfig,
+    StreamLeaseRejected,
+)
+
+app = FastAPI()
+redis_client = redis.from_url("redis://localhost:6379")
+
+# Configure lease boundaries:
+# Each user can hold at most 2 concurrent streams; cluster max is 500.
+lease_manager = StreamLeaseManager(
+    redis=redis_client,
+    config=LeaseConfig(
+        max_per_user=2,
+        max_global=500,
+        lease_seconds=30.0,
+    ),
+)
+
+
+# Convert lease rejections into clean HTTP 429 Too Many Requests responses:
+@app.exception_handler(StreamLeaseRejected)
+async def lease_rejected_handler(request: Request, exc: StreamLeaseRejected):
+    return exc.as_response()
+
+
+@app.get("/api/chat/stream")
+async def chat_stream(user_id: str = "user_123"):
+    # 1. Acquire lease (raises StreamLeaseRejected if limit reached)
+    lease = await lease_manager.acquire(user_id)
+
+    async def token_generator():
+        # Example: streaming tokens from an LLM
+        for word in ["Hello", "world", "this", "is", "streamed!"]:
+            yield f"data: {word}\n\n"
+
+    # 2. Wrap generator: guarantees background auto-renewal and release on disconnect
+    return StreamingResponse(
+        lease.wrap(token_generator()),
+        media_type="text/event-stream",
+    )
+```
+
+### Protecting WebSockets
+
+For WebSockets and scoped async routines, use the `lease_manager.lease(...)` context manager:
+
+```python
+@app.websocket("/ws/chat/{user_id}")
+async def websocket_chat(websocket: WebSocket, user_id: str):
+    await websocket.accept()
+    # Acquires lease on enter, automatically releases when socket closes or disconnects
+    async with lease_manager.lease(user_id):
+        while True:
+            msg = await websocket.receive_text()
+            await websocket.send_text(f"Echo: {msg}")
+```
+
+---
+
+## 🛠️ How It Works (Algorithmic Math)
+
+All concurrency validations, expirations, and insertions run inside **atomic Lua scripts** on Redis:
+
+1. **Sorted Sets (`ZSET`):** Active streams are stored in Redis `ZSET`s where the value is a unique `lease_id` and the score is the epoch expiration timestamp (`now + lease_seconds`).
+2. **Atomic Eviction:** Before checking capacity, `ZREMRANGEBYSCORE` purges all expired entries in $O(\log N + M)$.
+3. **Capacity Check:** `ZCARD` verifies current stream count in $O(1)$ against `max_per_user` and `max_global`. Setting either to `0` disables that limit.
+4. **Redis Cluster Slot Affinity:** Keys automatically use `{prefix}` hash tags (e.g. `{stream_lease}:user:123` and `{stream_lease}:global`), guaranteeing zero `CROSSSLOT` errors across distributed Redis clusters.
+5. **Acquisition:** If capacity permits, `ZADD` registers the lease in $O(\log N)$ and updates the key TTL.
+6. **Auto-Renewal:** While the stream is active, `lease.wrap()` spawns a lightweight background worker that calls `ZADD` to advance the expiration score every `lease_seconds / 2`.
+7. **Guaranteed Release:** When the stream completes or the client disconnects, `ZREM` removes the lease immediately in the `finally:` block.
+
+---
+
+## ⚙️ Configuration Options
+
+Customize `LeaseConfig`:
+
+```python
+from fastapi_stream_lease import LeaseConfig
+
+config = LeaseConfig(
+    lease_seconds=30.0,  # Lease expiration window (seconds)
+    max_per_user=3,  # Max active streams per user (set 0 to disable)
+    max_global=1000,  # Max active streams cluster-wide (set 0 to disable)
+    key_prefix="my_app:sse",  # Custom Redis key prefix (hash-tag safe)
+)
+```
+
+---
+
+## 🧪 Testing & Observability
+
+You can inspect the live count of active streams at any time:
+
+```python
+# Active streams for a specific user:
+active_user_streams = await lease_manager.get_active_count("user_123")
+
+# Active streams across the entire cluster:
+active_global_streams = await lease_manager.get_active_count()
+```
+
+---
+
+## 📄 License
+
+This project is licensed under the [MIT License](LICENSE).

fastapi_stream_lease-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fastapi_stream_lease/__init__.py,sha256=cKkJzlD-no7fUIaVbcyNmkdvxh1GPSyHuDsje270BPU,453
+fastapi_stream_lease/config.py,sha256=VUAiWiOaTcliZpvLvHUHsKTuZnXRR5lqzZZg15NDiAg,1624
+fastapi_stream_lease/exceptions.py,sha256=uNBDyckMf1irbglLCZh2f6LlPtxCS5UCSYfEz-9iEgo,1989
+fastapi_stream_lease/lease.py,sha256=bObEIpm19mn0Xw_-lqPYK_GbOV0eYNCTPSoE1hzPOxk,3108
+fastapi_stream_lease/lua.py,sha256=kWlIeZ2rC2KC8n24_nih_wzVSJxrIIE3K9nIGbzTPWg,2482
+fastapi_stream_lease/manager.py,sha256=33KVnyXZpIW83wGMfIw0NAkVgpkkoNm7VfYx60Ak4KQ,4777
+fastapi_stream_lease/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
+fastapi_stream_lease-0.1.0.dist-info/METADATA,sha256=dc6ZTTg_eJtu9NYUQo2bP0f3a9drwLzyCvh1Wu3m2Rs,9446
+fastapi_stream_lease-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+fastapi_stream_lease-0.1.0.dist-info/licenses/LICENSE,sha256=lIUyM6GLlCSB712vCX1qjIh556nlLYlwChOhrhazGb8,1069
+fastapi_stream_lease-0.1.0.dist-info/RECORD,,

fastapi_stream_lease-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

fastapi_stream_lease-0.1.0.dist-info/licenses/LICENSE

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