bunqueue-client 0.1.5__py3-none-any.whl

bunqueue/worker_runtime.py

@@ -0,0 +1,221 @@
+"""Worker runtime mixin: poll loop body, job execution, heartbeats, registry.
+
+Split from :mod:`worker` to keep files small; ``Worker`` composes this mixin
+with the lifecycle surface (start/run/pause/close).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import socket as _socket
+import time
+import traceback
+from typing import Any, Dict, Optional
+
+from .ack_batcher import AckItem
+from .errors import BunqueueError, UnrecoverableError
+from .job import Job
+from .wire import _compact
+
+logger = logging.getLogger("bunqueue")
+
+MAX_POLL_TIMEOUT_MS = 30000
+# The server persists the FIRST `stackTraceLimit` lines (default 10) of the
+# stack we send. A Python traceback ends with the raise site, so we send the
+# LAST lines — but no more than the server keeps, or the raise site would be
+# truncated away by the server-side first-N cap.
+MAX_STACK_LINES = 10
+RECONNECT_BACKOFF_S = (0.5, 1.0, 2.0, 5.0)
+
+
+class WorkerRuntime:
+    """Mixin: requires the attributes initialized in ``Worker.__init__``."""
+
+    def _poll_once(self) -> None:
+        with self._active_lock:
+            free = self.concurrency - len(self._active)
+        if free <= 0:
+            self._stop.wait(0.05)
+            return
+
+        # The registration is per-connection server state: after a reconnect
+        # the server no longer knows this worker (ListWorkers, skipIfNoWorker
+        # crons). Detect the new connection generation and re-register.
+        if (
+            self.connection.connected
+            and self.connection.generation != self._registered_generation
+        ):
+            self._register()
+
+        response = self.connection.call(
+            {
+                "cmd": "PULLB",
+                "queue": self.queue,
+                "count": min(free, self.batch_size),
+                "timeout": self.poll_timeout_ms,
+                "owner": self.worker_id,
+                "lockTtl": self.lock_ttl_ms,
+            },
+            timeout=self.poll_timeout_ms / 1000 + 10,
+        )
+        jobs = response.get("jobs") or []
+        tokens = response.get("tokens") or []
+        if not jobs:
+            with self._active_lock:
+                idle = not self._active
+            if self._was_busy and idle:
+                self._was_busy = False
+                self.emit("drained")
+            return
+
+        self._was_busy = True
+        assert self._executor is not None
+        for raw, tok in zip(jobs, tokens):
+            job_id = str(raw.get("id"))
+            with self._active_lock:
+                self._active[job_id] = tok
+            self._executor.submit(self._run_job, raw, tok)
+
+    def _run_job(self, raw: Dict[str, Any], token: str) -> None:
+        job = Job(raw, self.connection, token, on_progress=lambda j, p: self.emit("progress", j, p))
+        self.emit("active", job)
+        try:
+            result = self.processor(job)
+        except BaseException as exc:  # noqa: BLE001 - fail the job, never the worker
+            # Send at most as many trailing lines as the server will keep
+            # (its cap keeps the FIRST N): honor a per-job stackTraceLimit.
+            cap = raw.get("stackTraceLimit")
+            cap = cap if isinstance(cap, int) and cap > 0 else MAX_STACK_LINES
+            stack = traceback.format_exc().splitlines()[-cap:]
+            failed_sent = self._safe_call(
+                _compact(
+                    {
+                        "cmd": "FAIL",
+                        "id": job.id,
+                        "error": str(exc) or exc.__class__.__name__,
+                        "token": token,
+                        "stack": stack,
+                        "unrecoverable": True if isinstance(exc, UnrecoverableError) else None,
+                    }
+                )
+            )
+            self._finish_job(job.id)
+            # Only count/emit 'failed' when the server recorded the failure;
+            # on a wire failure only 'error' fired and the server re-leases
+            # the job after lock expiry (same gate as the TS worker).
+            if failed_sent:
+                self._failed += 1
+                self.emit("failed", job, exc)
+            return
+        if self._ack_batcher is not None:
+            # Defer the ACK into a batch; the job stays active (lock renewed by
+            # the heartbeat loop) until the ACKB settles. _on_ack_settled frees
+            # the slot FIRST so a raising listener can never leak it and
+            # permanently shrink the worker's effective concurrency.
+            self._ack_batcher.add(
+                AckItem(
+                    id=job.id,
+                    token=token,
+                    result=result,
+                    on_settled=lambda err, job=job, result=result: self._on_ack_settled(
+                        job, result, err
+                    ),
+                )
+            )
+            return
+        ack: Dict[str, Any] = {"cmd": "ACK", "id": job.id, "token": token}
+        if result is not None:
+            ack["result"] = result
+        acked = self._safe_call(ack)
+        # Free the slot BEFORE emitting (same rationale as the batched path).
+        self._finish_job(job.id)
+        # Only count/emit 'completed' when the ACK reached the server: an
+        # unconfirmed ack means the job will be redelivered after lock expiry,
+        # so reporting success here would double-count (same gate as the
+        # batched path and the TS worker).
+        if acked:
+            self._processed += 1
+            self.emit("completed", job, result)
+
+    def _on_ack_settled(self, job: Job, result: Any, err: Optional[BaseException]) -> None:
+        """Settle callback for a batched ACK: free the slot, then report.
+
+        On a failed ACKB the job is NOT reported as completed: the server
+        never confirmed the ack (the job will be retried after lock expiry),
+        so the worker surfaces an 'error' event per job instead."""
+        self._finish_job(job.id)
+        if err is not None:
+            self.emit("error", err)
+        else:
+            self._processed += 1
+            self.emit("completed", job, result)
+
+    def _finish_job(self, job_id: str) -> None:
+        with self._active_lock:
+            self._active.pop(job_id, None)
+            self._cancelled.pop(job_id, None)
+
+    def _heartbeat_loop(self) -> None:
+        while not self._stop.wait(self.heartbeat_interval_s):
+            with self._active_lock:
+                ids = list(self._active.keys())
+                tokens = [self._active[i] for i in ids]
+                active_count = len(ids)
+            self._safe_call(
+                {
+                    "cmd": "Heartbeat",
+                    "id": self.worker_id,
+                    "activeJobs": active_count,
+                    "processed": self._processed,
+                    "failed": self._failed,
+                }
+            )
+            if ids:
+                self._safe_call({"cmd": "JobHeartbeatB", "ids": ids, "tokens": tokens})
+
+    def _register(self) -> None:
+        """Register the worker; mark the generation ONLY on success.
+
+        A failed RegisterWorker must leave ``_registered_generation`` stale so
+        the next poll iteration retries: marking it unconditionally would leave
+        the server unaware of this worker (ListWorkers, skipIfNoWorker crons,
+        Discussion #103 class) until the next reconnect.
+
+        The generation is snapshotted BEFORE the call: if the call itself
+        triggers a reconnect, the stale snapshot forces one harmless duplicate
+        registration (server-side upsert) instead of ever missing one.
+        """
+        generation = self.connection.generation
+        try:
+            self.connection.call(
+                {
+                    "cmd": "RegisterWorker",
+                    "name": self.name,
+                    "queues": [self.queue],
+                    "concurrency": self.concurrency,
+                    "workerId": self.worker_id,
+                    "hostname": _socket.gethostname(),
+                    "pid": os.getpid(),
+                    "startedAt": int(time.time() * 1000),
+                }
+            )
+        except BunqueueError as exc:
+            logger.warning("RegisterWorker failed (will retry next poll): %s", exc)
+            self.emit("error", exc)
+            return
+        self._registered_generation = generation
+
+    def _safe_call(self, command: Dict[str, Any]) -> bool:
+        """Fire a command, swallowing wire failures into an 'error' event.
+
+        Returns True only when the command reached the server, so callers can
+        gate success-side effects (counters, 'completed'/'failed' emits) on
+        the wire outcome, mirroring the TypeScript worker's safeCall."""
+        try:
+            self.connection.call(command)
+            return True
+        except BunqueueError as exc:
+            logger.warning("swallowed %s failure: %s", command.get("cmd"), exc)
+            self.emit("error", exc)
+            return False

bunqueue_client-0.1.5.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: bunqueue-client
+Version: 0.1.5
+Summary: Python client SDK for bunqueue — high-performance job queue server (TCP mode)
+Project-URL: Homepage, https://github.com/egeominotti/bunqueue
+Project-URL: Documentation, https://bunqueue.dev
+Project-URL: Repository, https://github.com/egeominotti/bunqueue
+Project-URL: Changelog, https://github.com/egeominotti/bunqueue/blob/main/sdk/python/CHANGELOG.md
+Author: Egeo Minotti
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bunqueue,jobs,queue,task-queue,worker
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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.9
+Requires-Dist: msgpack>=1.0.0
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<a href="https://bunqueue.dev">
+  <img src="https://raw.githubusercontent.com/egeominotti/bunqueue/main/.github/logo.png" alt="bunqueue logo" width="110" />
+</a>
+
+# bunqueue-client (Python)
+
+**The official Python client for [bunqueue](https://bunqueue.dev), the high performance job queue server.**
+
+Native TCP protocol (msgpack, pipelined), one runtime dependency (`msgpack`), sync plus thread based workers.
+
+[![license](https://img.shields.io/badge/license-MIT-1a1a2e)](https://github.com/egeominotti/bunqueue/blob/main/sdk/python/LICENSE)
+[![python](https://img.shields.io/badge/python-3.9%2B-2ea44f)](https://github.com/egeominotti/bunqueue/tree/main/sdk/python)
+[![conformance](https://img.shields.io/badge/protocol-conformant%2017%2F17-d3156d)](https://github.com/egeominotti/bunqueue/tree/main/sdk/conformance)
+
+[Documentation](https://bunqueue.dev/guide/sdks/) · [Protocol spec](https://github.com/egeominotti/bunqueue/blob/main/docs/protocol.md) · [Server](https://github.com/egeominotti/bunqueue) · [Changelog](https://github.com/egeominotti/bunqueue/blob/main/sdk/python/CHANGELOG.md)
+
+</div>
+
+---
+
+Python client for [bunqueue](https://github.com/egeominotti/bunqueue), the
+high-performance job queue server for Bun. Talks the native TCP protocol
+(msgpack, pipelined) with the same core API as the TypeScript SDK, including
+opt-in ACK batching and dependency-free structured transport telemetry.
+Connection pooling remains TypeScript-only for now.
+
+The bunqueue **server** runs on Bun (or as a compiled binary / Docker). This
+SDK lets any Python service produce and consume jobs on it: *one queue, any
+language*.
+
+## Install
+
+```bash
+# PyPI release coming soon; install from the repo today:
+pip install "git+https://github.com/egeominotti/bunqueue.git#subdirectory=sdk/python"
+# dependency: msgpack; import name: bunqueue
+```
+
+Requires Python ≥ 3.9 and a running bunqueue server (`bunx bunqueue start`).
+
+## Quick start
+
+```python
+from bunqueue import Queue, Worker
+
+# Producer
+queue = Queue("emails", host="localhost", port=6789)
+job = queue.add("send", {"to": "user@example.com"}, priority=5, attempts=3)
+print(job.id)
+
+# Consumer
+def process(job):
+    job.update_progress(50)
+    return {"sent": True}
+
+worker = Worker("emails", process, concurrency=10)
+worker.on("completed", lambda job, result: print(job.id, result))
+worker.run()  # blocking; or worker.start() for a background thread
+```
+
+All queue semantics (retry, backoff, DLQ, priorities, stall detection, cron)
+run **server-side** — the worker only pulls, heartbeats, and acks.
+
+## Feature surface
+
+- **Queue**: `add`, `add_bulk`, full job options (priority, delay, attempts,
+  backoff, ttl, timeout, job_id, deduplication, depends_on, tags, group_id,
+  lifo, remove_on_complete/fail, durable, repeat, debounce, …)
+- **Query**: `get_job`, `get_job_by_custom_id`, `get_jobs` (+ per-state
+  helpers), `get_state`, `get_result`, `get_progress`, `wait_for_job`
+  (raises `CommandTimeoutError` on timeout, BullMQ contract),
+  counts (+ per-priority), children values, job logs
+- **Control**: pause/resume/drain/obliterate/clean, remove, discard,
+  promote (single/bulk), retry_job / retry_jobs, move to wait/delayed,
+  change priority/delay, update data, extend lock
+- **DLQ**: `get_dlq`, `retry_dlq`, `purge_dlq`, DLQ config
+- **Schedulers**: `upsert_job_scheduler` (cron pattern or interval),
+  `add_cron` / `every` shorthands, get/list/remove
+- **Admin**: rate limit, global concurrency, stall config, webhooks,
+  stats/metrics/list_queues/get_workers
+- **Worker**: events (`ready`, `active`, `completed`, `failed`, `progress`,
+  `drained`, `error`, `closed`), pause/resume, graceful `close()` (also a
+  context manager), automatic lock heartbeats (jobs longer than the lock TTL
+  survive), `UnrecoverableError` to skip retries, opt-in ACK batching
+  (`ack_batch={"max_size": 50, "max_delay_ms": 5}`: successful ACKs flush as
+  one `ACKB` on size/delay/close; a job stays active until its batch settles)
+- **FlowProducer**: `add` (parent/child trees), `add_bulk`, `add_chain`
+  (sequential), `add_bulk_then` (fan-in), `get_flow`, atomic rollback
+- **Simple Mode** (`Bunqueue`): Queue + Worker in one object — routes,
+  onion middleware, in-process retry (fixed/exponential/jitter/fibonacci/
+  custom + `retry_if`), circuit breaker, batch accumulation, event triggers,
+  job TTL, priority aging, cooperative cancellation (`get_signal`),
+  dedup/debounce defaults, cron shorthands — 1:1 with the official client
+  (TCP mode; `embedded` raises)
+- **Connection**: auth token, TLS (`tls=True`, `{"ca_file": ...}`,
+  `{"verify": False}`), pipelining, lazy reconnect, structured telemetry
+
+Not applicable outside Bun (by design): embedded mode, sandboxed workers,
+`QueueEvents` (in-process subscription; use webhooks or SSE/WS on the HTTP
+port instead).
+
+## Errors
+
+```python
+from bunqueue import (
+    BunqueueError,        # base
+    ConnectionClosedError,
+    CommandTimeoutError,
+    CommandError,         # server answered ok=false
+    AuthError,
+    SerializationError,   # payload not msgpack-serializable (e.g. datetime)
+    UnrecoverableError,   # raise in a processor: fail terminally, no retries
+)
+```
+
+The SDK logs its otherwise-silent failure points (swallowed command errors,
+raising listeners, failed registrations) at warning level on the `bunqueue`
+logger; attach a handler to see them.
+
+### Structured telemetry
+
+Pass `on_telemetry` to `Connection` or `Queue` to bridge transport metrics to
+OpenTelemetry, Prometheus, or your logger without adding an SDK dependency:
+
+```python
+queue = Queue("emails", on_telemetry=lambda event: metrics.record(event))
+```
+
+Events cover `connect`, `disconnect`, `reconnect_scheduled`, `auth`, `command`,
+`command_timeout`, and `error`. Command events contain the command name,
+request id, outcome, and monotonic duration. Payloads and authentication tokens
+are never included. A telemetry callback that raises is isolated from the
+transport and cannot fail a queue operation.
+
+## Protocol notes
+
+- Wire: 4-byte big-endian length prefix + standard msgpack map per message;
+  requests carry a `reqId` echoed by the server (pipelining).
+- Integers outside int32 are sent as float64 (exact ≤ 2^53): the server's
+  msgpack decoder turns int64 into `BigInt`, which its arithmetic rejects.
+  The SDK handles this automatically. Consequence: integers larger than 2^53
+  (e.g. 64-bit snowflake IDs) lose precision — pass them as **strings**.
+- Command maps require string keys at every nesting level. Cyclic containers
+  and integers outside the float64 range raise `SerializationError` locally,
+  before a pending request is registered or any bytes are written. Binary
+  values and array-like lists/tuples are preserved by the wire normalizer.
+
+## Tests
+
+```bash
+python -m venv .venv && .venv/bin/pip install msgpack
+.venv/bin/python tests/test_integration.py   # basic (8)
+.venv/bin/python tests/run_e2e.py            # full e2e vs real server (112)
+BUNQUEUE_SDK_SOAK_SECONDS=3600 .venv/bin/python tests/soak.py
+```
+
+Both spawn a real bunqueue server (`bun src/main.ts` from the repo root). The
+E2E runner emits a monotonic duration for each case so the isolated SDK gate
+can rank slow tests without relying on timing assertions. Hardening covers
+independent-connection idempotency and single-lease contention, fixed-seed
+generated payloads, malformed mutation corpora, 1000-job bursts, and
+crash/restart recovery. The opt-in soak keeps one connection alive; set
+`BUNQUEUE_SDK_SOAK_BATCH` to increase load.
+
+## License
+
+MIT. See the [LICENSE](https://github.com/egeominotti/bunqueue/blob/main/sdk/python/LICENSE) file.
+Documentation: [bunqueue.dev/guide/sdks](https://bunqueue.dev/guide/sdks/).
+Issues and feature requests: [GitHub issues](https://github.com/egeominotti/bunqueue/issues).

bunqueue_client-0.1.5.dist-info/RECORD

@@ -0,0 +1,34 @@
+bunqueue/__init__.py,sha256=AVJPSMlGV7TaWIAl_TWyZ_qgqiYurkYW7q9JlkO2PDg,1799
+bunqueue/ack_batcher.py,sha256=VTB42-C4Wwcx4Ja-oI7tZjTXx6jufGtDJArCPdNpZYw,3506
+bunqueue/connection.py,sha256=Kt0-TcdX8lOpimWvIV5W1JvidU7fx8NJ-fny7pH1JJE,9166
+bunqueue/connection_lifecycle.py,sha256=uF8N7T0aMsi2hNnQ4n3FswGOrOdJJs7kwPLuUe0cvyA,3974
+bunqueue/errors.py,sha256=ufaAFPdBlBJR4pyJTEUfdq39lv6oZkuouVAuotfFbzo,1141
+bunqueue/events.py,sha256=R8rKu68nr2tbqpzrji8xKXcLzXNcd6yc8VGa3xmxAeM,1932
+bunqueue/flow.py,sha256=Yh8HCa8hJBc1lYzjsN6dVdmdD_GH2l-CSQuEHjHz37Y,9318
+bunqueue/job.py,sha256=RKWfOiEkvXQ7BEQlFxz8X5T1i1qbtmh71n7jIL6OAtU,6072
+bunqueue/options.py,sha256=CGLMIJheKmQTw2iBnTgKk2Il0sLzvT7j-TfcKZRg3nE,5135
+bunqueue/queue.py,sha256=lBS2_vVxEPUVMaUydBgtTKflEGRg7ae_E2SG6xebpfw,9343
+bunqueue/queue_admin.py,sha256=g9w92oXPgK0O7wH_kJ7bu7HDmtKgCHQ4NGIRGLo7Kxg,9096
+bunqueue/queue_query.py,sha256=bSwtkdC3QaKVGWfUKt-q8c9njZdZli9WwM7_ybfC1lY,8749
+bunqueue/telemetry.py,sha256=Hz-15K_iQJJ7CtNn-MmflE-2RRhABSBx-6aeLHWREjM,864
+bunqueue/transport.py,sha256=0v1_UDbLWCiyga97ZkA1BGZ6DvWRBY0TUW7ZobJk5Oc,1575
+bunqueue/wire.py,sha256=4PeeOeHuYYV_bnUwa3SXrRxJ8fpRy7-3XgKoZdgKYMo,3523
+bunqueue/worker.py,sha256=E3y7ew0Xu328z2RofL0CNEbylj9EJQ1yzcYgKJBv1eQ,9940
+bunqueue/worker_runtime.py,sha256=Axl3ZYbumCyxi0Bx2hPqF0A7tD-q9hIwG9mh-2SCjbY,8958
+bunqueue/simple/__init__.py,sha256=q0NYG9vgGZ6MqyAAAllRTB82RcGZK2ampKLUKKE8emw,487
+bunqueue/simple/aging.py,sha256=pvbRMEQSSGXFt9jqksDCHIs3i5D_aGDc4Pq70kBT_8E,2283
+bunqueue/simple/app.py,sha256=jr1D-zPBcexZjgINaPjy72RP7UeD4CVkCLr2tsCUOEw,6277
+bunqueue/simple/app_api.py,sha256=J57dL34d_-HpeEhnzgMLQ26y5B8Jit64f6HtJVfnluo,4947
+bunqueue/simple/batch.py,sha256=lZBeBhrsGKmpDceZXprjyaxSZd_6rspcKF9V-zPQk2E,3064
+bunqueue/simple/cancellation.py,sha256=u_QdYTv_i5fTG2bkCyC3u9JRrOm6to6wLoLKkNmrCBw,2326
+bunqueue/simple/circuit_breaker.py,sha256=kUSR0CmqYpXoWVsd0G-6M3QedsmbfonDlQAPLGBdPy8,2929
+bunqueue/simple/dedup_debounce.py,sha256=lTea4mCBl3_Vcbf5awqIZu88V3yFlz7XR9X2j7S_3JY,1420
+bunqueue/simple/rate_gate.py,sha256=sVGTJ5A5P4uP_5O8vZyhS71YtySaj8DskI_5uY3fPUY,2157
+bunqueue/simple/retry.py,sha256=BKz1dPMqQTlcKnBSEnA4F23GEb2bDIzZJMV9A6U2uv8,2216
+bunqueue/simple/triggers.py,sha256=SqLdgQpCBASK4cXtnTDYHEAC6-C-80uAn-pU4HpcuKM,1637
+bunqueue/simple/ttl.py,sha256=wX6Sa5XhxPUlIFQ3zqO0tHYnCUkUk5kO9dcCZqEk8Kc,1062
+bunqueue/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bunqueue_client-0.1.5.dist-info/METADATA,sha256=5vvem67o-0hjERJ-Ror7s1es7sgvi_bCFmArNLyNDxA,8940
+bunqueue_client-0.1.5.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+bunqueue_client-0.1.5.dist-info/licenses/LICENSE,sha256=y5XqDMIC5-PicSAv0CsVSQ_wbUwRiPun9Qzp-gAHte0,1069
+bunqueue_client-0.1.5.dist-info/RECORD,,

bunqueue_client-0.1.5.dist-info/WHEEL

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

bunqueue_client-0.1.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Egeo Minotti
+
+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.