mgf-livepush 0.1.2__py3-none-any.whl

mgf/livepush/__init__.py

@@ -0,0 +1,36 @@
+"""mgf-livepush — realtime push pipeline (SSE + pluggable pub/sub broker).
+
+A `mgf-common` sibling under the `mgf.*` namespace. Public surface:
+
+  * :class:`SSEStreamService` / :class:`SSEStream` / :func:`sse_headers`
+    — the broker-agnostic SSE streaming primitive.
+  * :class:`Broker` / :class:`RedisBroker` / :class:`MockBroker` /
+    :class:`Subscription` — the pub/sub seam + adapters.
+  * :class:`SlotCap` — the per-key connection-slot cap (R-28 pattern).
+  * :class:`CapExceededError` / :class:`LivePushError` — typed errors
+    (subclass ``mgf.common.exceptions.AppError``).
+
+The FastAPI ``StreamingResponse`` wrapper lives in
+:mod:`mgf.livepush.fastapi` (requires the ``[fastapi]`` extra). See the
+README for the dev/prod-proxy SSE recipe.
+"""
+
+from __future__ import annotations
+
+from mgf.livepush._broker import Broker, MockBroker, RedisBroker, Subscription
+from mgf.livepush._errors import CapExceededError, LivePushError
+from mgf.livepush._slotcap import SlotCap
+from mgf.livepush._sse import SSEStream, SSEStreamService, sse_headers
+
+__all__ = [
+    "Broker",
+    "CapExceededError",
+    "LivePushError",
+    "MockBroker",
+    "RedisBroker",
+    "SSEStream",
+    "SSEStreamService",
+    "SlotCap",
+    "Subscription",
+    "sse_headers",
+]

mgf/livepush/_broker.py

@@ -0,0 +1,129 @@
+"""Pluggable pub/sub broker seam for live-push fan-out.
+
+`Broker` is the port; `RedisBroker` (gated behind the `[redis]` extra)
+is the production adapter and `MockBroker` is the in-process test
+double. A consumer that wants Redis Streams / NATS / Kafka writes a new
+adapter — `SSEStreamService` never sees the broker's internals.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from typing import Any, Protocol, runtime_checkable
+
+__all__ = ["Broker", "MockBroker", "RedisBroker", "Subscription"]
+
+
+@runtime_checkable
+class Subscription(Protocol):
+    """A live subscription to one channel."""
+
+    async def get_message(self, *, timeout: float) -> bytes | None:
+        """Return the next message payload, or ``None`` on timeout."""
+        ...
+
+    async def close(self) -> None:
+        """Release the subscription (unsubscribe + free resources)."""
+        ...
+
+
+@runtime_checkable
+class Broker(Protocol):
+    """A pub/sub backend behind a two-method port."""
+
+    async def publish(self, channel: str, payload: str | bytes) -> int:
+        """Publish ``payload`` to ``channel``; return the delivery count."""
+        ...
+
+    async def subscribe(self, channel: str) -> Subscription:
+        """Open a :class:`Subscription` to ``channel``."""
+        ...
+
+
+# ---------------------------------------------------------------------------
+# Redis adapter (requires the `[redis]` extra)
+# ---------------------------------------------------------------------------
+
+
+class _RedisSubscription:
+    def __init__(self, pubsub: Any, channel: str) -> None:
+        self._pubsub = pubsub
+        self._channel = channel
+
+    async def get_message(self, *, timeout: float) -> bytes | None:
+        msg = await self._pubsub.get_message(
+            ignore_subscribe_messages=True, timeout=timeout
+        )
+        if msg is None:
+            return None
+        data = msg.get("data")
+        if isinstance(data, bytes):
+            return data
+        if isinstance(data, str):
+            return data.encode("utf-8")
+        return None
+
+    async def close(self) -> None:
+        with contextlib.suppress(Exception):
+            await self._pubsub.unsubscribe(self._channel)
+            await self._pubsub.aclose()
+
+
+class RedisBroker:
+    """Redis pub/sub adapter. Pass a ``redis.asyncio.Redis`` client."""
+
+    def __init__(self, redis: Any) -> None:
+        self._redis = redis
+
+    async def publish(self, channel: str, payload: str | bytes) -> int:
+        return int(await self._redis.publish(channel, payload))
+
+    async def subscribe(self, channel: str) -> Subscription:
+        pubsub = self._redis.pubsub()
+        await pubsub.subscribe(channel)
+        return _RedisSubscription(pubsub, channel)
+
+
+# ---------------------------------------------------------------------------
+# In-process mock adapter (for consumers' tests)
+# ---------------------------------------------------------------------------
+
+
+class _MockSubscription:
+    def __init__(self) -> None:
+        self._queue: asyncio.Queue[bytes] = asyncio.Queue()
+        self._closed = False
+
+    async def get_message(self, *, timeout: float) -> bytes | None:
+        try:
+            return await asyncio.wait_for(self._queue.get(), timeout)
+        except TimeoutError:
+            return None
+
+    async def close(self) -> None:
+        self._closed = True
+
+    def deliver(self, data: bytes) -> None:
+        if not self._closed:
+            self._queue.put_nowait(data)
+
+
+class MockBroker:
+    """Deterministic in-process broker. Only delivers to subscribers that
+    were subscribed BEFORE the publish (matching real pub/sub semantics)."""
+
+    def __init__(self) -> None:
+        self._subs: dict[str, list[_MockSubscription]] = {}
+
+    async def publish(self, channel: str, payload: str | bytes) -> int:
+        data = payload.encode("utf-8") if isinstance(payload, str) else payload
+        subs = self._subs.get(channel, [])
+        for sub in subs:
+            sub.deliver(data)
+        return len(subs)
+
+    async def subscribe(self, channel: str) -> Subscription:
+        sub = _MockSubscription()
+        self._subs.setdefault(channel, []).append(sub)
+        return sub

mgf/livepush/_errors.py

@@ -0,0 +1,31 @@
+"""mgf-livepush typed errors.
+
+All subclass ``mgf.common.exceptions.AppError`` so a consumer's
+top-level handler treats them uniformly (rule EH-01).
+"""
+
+from __future__ import annotations
+
+from mgf.common.exceptions import AppError
+
+__all__ = ["CapExceededError", "LivePushError"]
+
+
+class LivePushError(AppError):
+    """Base class for every mgf-livepush error."""
+
+
+class CapExceededError(LivePushError):
+    """The per-key connection-slot cap is exhausted.
+
+    The caller should refuse the new stream (HTTP 429). Carries the
+    ``slot_key`` + ``cap`` for logging / the ``Retry-After`` response.
+    """
+
+    def __init__(self, slot_key: str, cap: int) -> None:
+        self.slot_key = slot_key
+        self.cap = cap
+        super().__init__(
+            f"live-push slot cap of {cap} concurrent connections "
+            f"exceeded for {slot_key!r}"
+        )

mgf/livepush/_slotcap.py

@@ -0,0 +1,92 @@
+"""Per-key connection-slot cap over a Redis counter (the R-28 pattern).
+
+INCR on acquire, DECR on release, with a TTL so a crashed process can't
+leak a slot forever. Best-effort + **fail-OPEN**: a Redis outage lets
+connections through rather than locking everyone out (the push path is
+already degraded in an outage; denying authenticated users on top is the
+wrong failure mode). Optional ``on_acquire`` / ``on_release`` callbacks
+let a consumer wire its own observability without this module importing
+it.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+__all__ = ["SlotCap"]
+
+LOG = logging.getLogger(__name__)
+
+
+class SlotCap:
+    def __init__(
+        self,
+        redis: Any,
+        *,
+        cap: int = 20,
+        key_prefix: str = "livepush:slot:",
+        ttl_seconds: int = 300,
+        on_acquire: Callable[[str], None] | None = None,
+        on_release: Callable[[str], None] | None = None,
+    ) -> None:
+        self._redis = redis
+        self.cap = cap
+        self._prefix = key_prefix
+        self._ttl = ttl_seconds
+        self._on_acquire = on_acquire
+        self._on_release = on_release
+
+    def _key(self, slot_key: str) -> str:
+        return f"{self._prefix}{slot_key}"
+
+    async def acquire(self, slot_key: str) -> bool:
+        """Reserve one slot for ``slot_key``. Returns ``False`` if the cap
+        is reached (caller refuses); ``True`` otherwise (caller MUST
+        eventually :meth:`release`). Fails OPEN (returns ``True``) on any
+        Redis error."""
+        key = self._key(slot_key)
+        try:
+            count = await self._redis.incr(key)
+            if count == 1:
+                await self._redis.expire(key, self._ttl)
+            if count > self.cap:
+                await self._redis.decr(key)
+                return False
+        except Exception:
+            LOG.warning(
+                "livepush: slot acquire failed; failing open",
+                exc_info=True,
+                extra={
+                    "slot_key": slot_key,
+                    "cap": self.cap,
+                    "fingerprint": f"livepush.slot_acquire_failed:{slot_key}",
+                },
+            )
+            return True
+        if self._on_acquire is not None:
+            self._on_acquire(slot_key)
+        return True
+
+    async def release(self, slot_key: str) -> None:
+        """Release one slot for ``slot_key``. No-op on Redis failure;
+        floors the counter at 0."""
+        key = self._key(slot_key)
+        try:
+            count = await self._redis.decr(key)
+            if count is not None and count < 0:
+                await self._redis.set(key, 0, ex=self._ttl)
+        except Exception:
+            LOG.warning(
+                "livepush: slot release failed (best-effort)",
+                exc_info=True,
+                extra={
+                    "slot_key": slot_key,
+                    "fingerprint": f"livepush.slot_release_failed:{slot_key}",
+                },
+            )
+        if self._on_release is not None:
+            self._on_release(slot_key)

mgf/livepush/_sse.py

@@ -0,0 +1,117 @@
+"""Broker-agnostic SSE streaming primitive.
+
+`SSEStreamService.open_stream` acquires a slot (raising
+:class:`CapExceededError` *synchronously* if the cap is full — so a
+consumer maps it to 429 BEFORE opening the stream), subscribes via the
+broker, and returns an :class:`SSEStream` (headers + an async byte
+iterator). The iterator emits the ``retry:`` directive, heartbeat
+comments, and ``data:`` frames, and in a ``finally`` block releases the
+slot + closes the subscription on disconnect / cancel / error.
+
+Framework-agnostic: the consumer supplies an async ``is_disconnected``
+callable (FastAPI's ``request.is_disconnected``) and wraps the iterator
+in whatever streaming response its framework uses.
+:mod:`mgf.livepush.fastapi` ships a one-line wrapper.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from mgf.livepush._errors import CapExceededError
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable
+
+    from mgf.livepush._broker import Broker, Subscription
+    from mgf.livepush._slotcap import SlotCap
+
+__all__ = ["SSEStream", "SSEStreamService", "sse_headers"]
+
+LOG = logging.getLogger(__name__)
+
+# EventSource reconnect cadence (ms). Pairs with a 429 Retry-After: 5 so
+# a flapping client doesn't tighten into a hot loop against the cap.
+_RETRY_MS = 5000
+# Heartbeat envelope — survives AWS ALB / Cloudflare 30 s idle-close.
+_DEFAULT_HEARTBEAT_SECONDS = 15.0
+
+
+def sse_headers() -> dict[str, str]:
+    """Headers every SSE response needs so proxies pass the wire
+    untouched (disable caching/transform + Nginx-style buffering)."""
+    return {"Cache-Control": "no-cache, no-transform", "X-Accel-Buffering": "no"}
+
+
+@dataclass
+class SSEStream:
+    """The result of :meth:`SSEStreamService.open_stream` — the headers to
+    set on the response + the byte iterator to stream as its body."""
+
+    headers: dict[str, str]
+    body: AsyncIterator[bytes]
+
+
+class SSEStreamService:
+    """Per-app SSE primitive over a :class:`Broker` + :class:`SlotCap`."""
+
+    def __init__(
+        self,
+        broker: Broker,
+        slot_cap: SlotCap,
+        *,
+        heartbeat_seconds: float = _DEFAULT_HEARTBEAT_SECONDS,
+    ) -> None:
+        self._broker = broker
+        self._slot_cap = slot_cap
+        self._heartbeat_s = heartbeat_seconds
+
+    async def open_stream(
+        self,
+        *,
+        channel: str,
+        slot_key: str,
+        is_disconnected: Callable[[], Awaitable[bool]],
+    ) -> SSEStream:
+        """Acquire a slot, subscribe to ``channel``, return an
+        :class:`SSEStream`. Raises :class:`CapExceededError` synchronously
+        when the cap is full — no subscription / slot leak (the acquire
+        happens before any pubsub state)."""
+        acquired = await self._slot_cap.acquire(slot_key)
+        if not acquired:
+            raise CapExceededError(slot_key, self._slot_cap.cap)
+        sub = await self._broker.subscribe(channel)
+        return SSEStream(
+            headers=sse_headers(),
+            body=self._event_gen(sub, slot_key, is_disconnected),
+        )
+
+    async def _event_gen(
+        self,
+        sub: Subscription,
+        slot_key: str,
+        is_disconnected: Callable[[], Awaitable[bool]],
+    ) -> AsyncIterator[bytes]:
+        try:
+            yield f"retry: {_RETRY_MS}\n\n".encode()
+            while True:
+                data = await sub.get_message(timeout=self._heartbeat_s)
+                if await is_disconnected():
+                    return
+                if data is None:
+                    yield b": keep-alive\n\n"
+                    continue
+                yield b"data: " + data + b"\n\n"
+        except asyncio.CancelledError:
+            return
+        finally:
+            # Close the subscription BEFORE releasing the slot: if release
+            # came first and close hung, the slot would be reusable before
+            # the underlying resource was freed (slot-leak adjacent).
+            with contextlib.suppress(Exception):
+                await sub.close()
+            await self._slot_cap.release(slot_key)

mgf/livepush/fastapi.py

@@ -0,0 +1,50 @@
+"""Optional FastAPI adapter (requires the ``[fastapi]`` extra).
+
+One line in a route handler turns an :class:`SSEStreamService` into a
+``StreamingResponse``, mapping the cap-exceeded case to a 429 with a
+``Retry-After`` header.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from mgf.livepush._errors import CapExceededError
+
+if TYPE_CHECKING:
+    from fastapi import Request
+    from fastapi.responses import StreamingResponse
+
+    from mgf.livepush._sse import SSEStreamService
+
+__all__ = ["sse_streaming_response"]
+
+
+async def sse_streaming_response(
+    service: SSEStreamService,
+    request: Request,
+    *,
+    channel: str,
+    slot_key: str,
+) -> StreamingResponse:
+    """Open an SSE stream and wrap it in a FastAPI ``StreamingResponse``.
+
+    Raises ``HTTPException(429)`` with ``Retry-After: 5`` when the
+    per-key slot cap is exhausted.
+    """
+    from fastapi import HTTPException
+    from fastapi.responses import StreamingResponse
+
+    try:
+        stream = await service.open_stream(
+            channel=channel,
+            slot_key=slot_key,
+            is_disconnected=request.is_disconnected,
+        )
+    except CapExceededError as exc:
+        raise HTTPException(
+            status_code=429, detail=str(exc), headers={"Retry-After": "5"}
+        ) from exc
+    return StreamingResponse(
+        stream.body, media_type="text/event-stream", headers=stream.headers
+    )

mgf_livepush-0.1.2.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: mgf-livepush
+Version: 0.1.2
+Summary: Realtime push pipeline for mgf-common consumers — SSE streaming, a pluggable pub/sub broker seam (Redis + mock), and per-key connection-slot caps. Sibling of mgf-common under the mgf.* namespace.
+Author: Bassam Alsanie, mgf-livepush contributors
+License: MIT
+License-File: LICENSE
+Keywords: fastapi,pubsub,realtime,redis,sse,streaming
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: mgf-common<0.43,>=0.41
+Provides-Extra: dev
+Requires-Dist: import-linter>=2.0; extra == 'dev'
+Requires-Dist: mgf-test-supervisor<0.2,>=0.1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.3; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.110; extra == 'fastapi'
+Provides-Extra: redis
+Requires-Dist: redis>=5.0; extra == 'redis'
+Provides-Extra: test
+Requires-Dist: fastapi>=0.110; extra == 'test'
+Requires-Dist: redis>=5.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# mgf-livepush
+
+Realtime push pipeline for `mgf-common` consumers: an SSE streaming
+primitive, a pluggable pub/sub **broker seam** (Redis adapter + an
+in-process mock), and a per-key connection-**slot cap**. A sibling of
+`mgf-common` under the `mgf.*` namespace.
+
+Extracted from PlasmaMapper's Phase-4 push surface after the
+pre-release core re-design hardened it (heartbeat cadence, slot
+lifecycle, disconnect cleanup, and the dev/prod-proxy buffering recipe
+below). The broker seam means a consumer can swap Redis pub/sub for
+Redis Streams / NATS without touching the SSE machinery.
+
+## Install
+
+```bash
+pip install "mgf-livepush[redis,fastapi]"   # adapters are opt-in extras
+```
+
+## Quickstart (FastAPI)
+
+```python
+from redis.asyncio import Redis
+from mgf.livepush import SSEStreamService, RedisBroker, SlotCap
+from mgf.livepush.fastapi import sse_streaming_response
+
+redis = Redis.from_url("redis://localhost:6379/0")
+sse = SSEStreamService(RedisBroker(redis), SlotCap(redis, cap=20))
+
+@router.get("/events/stream")
+async def stream(request: Request):
+    # 429 (Retry-After: 5) automatically when the per-key cap is full.
+    return await sse_streaming_response(
+        sse, request, channel=f"events:{tenant_id}", slot_key=str(tenant_id)
+    )
+```
+
+Publisher side, anywhere:
+
+```python
+await RedisBroker(redis).publish(f"events:{tenant_id}", json.dumps(event))
+```
+
+Framework-agnostic core: `open_stream(...)` returns an `SSEStream`
+(`.headers` + `.body` async byte iterator) — wrap `.body` in whatever
+streaming response your framework uses. Tests use `MockBroker` (no
+Redis).
+
+## The dev/prod-proxy SSE recipe (read this — it's the tarpit)
+
+A FastAPI `text/event-stream` endpoint behind a proxy (SvelteKit `vite`,
+a `+server.ts` `[...path]` forward, nginx, AWS ALB) will silently
+**buffer** the body and break your latency budget even though the API
+side is correct. To get live push through a proxy:
+
+1. **Response headers (set by this lib):** `Cache-Control: no-cache,
+   no-transform` + `X-Accel-Buffering: no`. If your proxy gzips, also
+   force `Content-Encoding: identity` on the proxied response.
+2. **Node `fetch` forwarding** of a streamed body needs `duplex: 'half'`.
+3. **Playwright:** `waitForLoadState('networkidle')` *never fires* with
+   an open `EventSource` (the long-lived connection counts as in-flight)
+   — wait on a concrete readiness signal instead.
+4. **Playwright:** `webServer` spawns *before* `globalSetup`, so any env
+   the proxy needs must be declared statically in `webServer.env`, not
+   threaded from `globalSetup`.
+
+## Public surface
+
+| Name | What |
+|---|---|
+| `SSEStreamService` | acquire slot → subscribe → stream (`open_stream`) |
+| `SSEStream` / `sse_headers` | the `(headers, body)` result + the proxy-safe headers |
+| `Broker` / `Subscription` | the pub/sub port (Protocols) |
+| `RedisBroker` / `MockBroker` | adapters (`[redis]` extra / in-process) |
+| `SlotCap` | per-key INCR/DECR connection cap, fail-open, TTL |
+| `CapExceededError` / `LivePushError` | typed errors (subclass `AppError`) |
+| `mgf.livepush.fastapi.sse_streaming_response` | one-line FastAPI wrapper (`[fastapi]` extra) |

mgf_livepush-0.1.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+mgf/livepush/__init__.py,sha256=qmWG8GjWYVH6R7nu-kN68YJs1Mbfv3in4FlnLh69KPU,1265
+mgf/livepush/_broker.py,sha256=5idCJaM_hd__rqrW8WwOflWdkR9QTqpB8-zJHitV6jY,4181
+mgf/livepush/_errors.py,sha256=jehN-qXpCIK0OtgLT65ab9s1Jqjc-9hUQJKRUreNDBQ,866
+mgf/livepush/_slotcap.py,sha256=G2S5LEO2xiq0R1Wo_OIQsMLFl2xmHQZT63T4Ku-XCPg,3135
+mgf/livepush/_sse.py,sha256=7ePvjxYLT56PDCdGqvCXO3l6W0VRMFScsOn9ygHo52M,4160
+mgf/livepush/fastapi.py,sha256=mVNa_zE1l1b5LSwvnWRWXSdwVVajtR4Z8WqMFBKcHmc,1426
+mgf/livepush/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mgf_livepush-0.1.2.dist-info/METADATA,sha256=1RLh8KzO5IUDS-OiaZ9v71KGHKjJYypBeBWX2XwSZQU,4742
+mgf_livepush-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+mgf_livepush-0.1.2.dist-info/licenses/LICENSE,sha256=608k_GqtNLHawes6fp-TlRhHA2Ha6rGGenwLZPN-j9U,1101
+mgf_livepush-0.1.2.dist-info/RECORD,,

mgf_livepush-0.1.2.dist-info/WHEEL

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

mgf_livepush-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bassam Alsanie and mgf-livepush contributors
+
+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.