edgesync 0.2.0__py3-none-any.whl

edgesync/transports/registry.py

@@ -0,0 +1,52 @@
+"""Maps destination names to transports.
+
+``EdgeSync.publish(data, destination="telemetry")`` is routed through this
+registry to the transport registered under that name, falling back to the
+default destination when none is specified.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from edgesync.exceptions import ConfigurationError
+from edgesync.transports.base import Transport
+
+
+class TransportRegistry:
+    """Owns the lifecycle of every registered :class:`Transport`."""
+
+    def __init__(self, default_destination: str) -> None:
+        self._default_destination = default_destination
+        self._transports: dict[str, Transport] = {}
+        self._started = False
+
+    def register(self, name: str, transport: Transport) -> None:
+        self._transports[name] = transport
+
+    def get(self, destination: str | None) -> Transport:
+        name = destination or self._default_destination
+        try:
+            return self._transports[name]
+        except KeyError:
+            raise ConfigurationError(
+                f"no transport registered for destination {name!r} "
+                f"(registered: {sorted(self._transports)})"
+            ) from None
+
+    def destinations(self) -> list[str]:
+        return list(self._transports)
+
+    async def start_all(self) -> None:
+        if self._started:
+            return
+        await asyncio.gather(*(t.start() for t in self._transports.values()))
+        self._started = True
+
+    async def close_all(self) -> None:
+        if not self._transports:
+            return
+        await asyncio.gather(
+            *(t.close() for t in self._transports.values()), return_exceptions=True
+        )
+        self._started = False

edgesync/utils/__init__.py

@@ -0,0 +1 @@
+"""Internal utility helpers (clock abstraction, ID generation)."""

edgesync/utils/clock.py

@@ -0,0 +1,50 @@
+"""Clock abstraction.
+
+Business logic must never call ``datetime.now()`` or ``time.time()``
+directly. Going through a :class:`Clock` keeps all internal timestamps
+timezone-aware UTC and lets tests substitute a deterministic fake clock
+instead of sleeping or racing against wall-clock time.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Clock(Protocol):
+    """A source of the current time."""
+
+    def now(self) -> datetime:
+        """Return the current time as a timezone-aware UTC datetime."""
+        ...
+
+
+class SystemClock:
+    """Clock backed by the system wall clock."""
+
+    def now(self) -> datetime:
+        return datetime.now(timezone.utc)
+
+
+class FixedClock:
+    """Deterministic clock for tests.
+
+    The clock starts at ``start`` (or the current system time) and only
+    advances when :meth:`advance` is called explicitly.
+    """
+
+    def __init__(self, start: datetime | None = None) -> None:
+        self._current = start or SystemClock().now()
+
+    def now(self) -> datetime:
+        return self._current
+
+    def advance(self, seconds: float) -> None:
+        from datetime import timedelta
+
+        self._current = self._current + timedelta(seconds=seconds)
+
+    def set(self, when: datetime) -> None:
+        self._current = when

edgesync/utils/ids.py

@@ -0,0 +1,20 @@
+"""ID generation helpers.
+
+Message IDs are globally unique (UUID4) and are exposed to transports so
+destinations can implement idempotent processing (see
+``HTTPTransport``'s ``Idempotency-Key`` header).
+"""
+
+from __future__ import annotations
+
+import uuid
+
+
+def generate_message_id() -> str:
+    """Generate a globally unique message ID."""
+    return str(uuid.uuid4())
+
+
+def generate_lease_id() -> str:
+    """Generate an opaque lease/ownership token for a claimed message."""
+    return str(uuid.uuid4())

edgesync/worker/__init__.py

@@ -0,0 +1,5 @@
+"""The background synchronization worker."""
+
+from edgesync.worker.sync_worker import SyncWorker
+
+__all__ = ["SyncWorker"]

edgesync/worker/lifecycle.py

@@ -0,0 +1,62 @@
+"""Small state-machine guard shared by anything with start()/close() semantics.
+
+Used by both ``SyncWorker`` (to reject a second concurrent ``start()``) and
+``EdgeSync`` itself (to raise ``EdgeSyncNotStartedError`` when an operation
+is attempted before ``start()`` has completed).
+"""
+
+from __future__ import annotations
+
+import asyncio
+from enum import Enum
+
+
+class LifecycleState(str, Enum):
+    IDLE = "idle"
+    STARTING = "starting"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+
+
+class LifecycleGuard:
+    """Tracks start/stop transitions and makes them idempotent."""
+
+    def __init__(self, name: str) -> None:
+        self._name = name
+        self._state = LifecycleState.IDLE
+        self._lock = asyncio.Lock()
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._state
+
+    @property
+    def is_running(self) -> bool:
+        return self._state is LifecycleState.RUNNING
+
+    async def begin_start(self) -> bool:
+        """Transition IDLE -> STARTING. Returns False if already started/starting."""
+        async with self._lock:
+            if self._state is not LifecycleState.IDLE:
+                return False
+            self._state = LifecycleState.STARTING
+            return True
+
+    def mark_running(self) -> None:
+        self._state = LifecycleState.RUNNING
+
+    async def begin_stop(self) -> bool:
+        """Transition RUNNING -> STOPPING. Returns False if not running or already stopping."""
+        async with self._lock:
+            if self._state in (
+                LifecycleState.IDLE,
+                LifecycleState.STOPPING,
+                LifecycleState.STOPPED,
+            ):
+                return False
+            self._state = LifecycleState.STOPPING
+            return True
+
+    def mark_stopped(self) -> None:
+        self._state = LifecycleState.STOPPED

edgesync/worker/scheduler.py

@@ -0,0 +1,20 @@
+"""Controls the worker's polling cadence.
+
+Polls again immediately when the previous batch found work (there may be
+more queued up), and sleeps for ``poll_interval`` otherwise -- this is what
+keeps an idle worker from busy-looping.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+
+class PollScheduler:
+    def __init__(self, poll_interval: float) -> None:
+        self._poll_interval = poll_interval
+
+    async def wait(self, *, found_work: bool) -> None:
+        if found_work:
+            return
+        await asyncio.sleep(self._poll_interval)

edgesync/worker/sync_worker.py

@@ -0,0 +1,162 @@
+"""The background synchronization worker.
+
+Each poll cycle:
+
+1. Recover any messages whose lease expired (previous claim owner crashed
+   or was cancelled) and expire any messages past their TTL.
+2. Claim a batch of eligible PENDING messages (storage-level ownership via
+   a lease fencing token -- see storage/sqlite.py).
+3. Deliver each claimed message, bounded by ``worker_concurrency`` via a
+   semaphore so the number of in-flight network requests is capped.
+4. Turn each ``DeliveryResult`` into a storage write: delivered, retry
+   scheduled, or dead-lettered.
+
+The worker never treats in-memory state as the source of truth: every
+decision it makes is persisted back to storage before the message is
+considered handled, so a crash mid-batch just leaves messages IN_FLIGHT to
+be recovered by the next lease sweep.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import timedelta
+
+from edgesync.logging import logger
+from edgesync.models.delivery import DeliveryOutcome, DeliveryResult
+from edgesync.models.message import Message
+from edgesync.retry.policy import RetryPolicy
+from edgesync.storage.base import StorageBackend
+from edgesync.transports.registry import TransportRegistry
+from edgesync.utils.clock import Clock, SystemClock
+from edgesync.worker.lifecycle import LifecycleGuard
+from edgesync.worker.scheduler import PollScheduler
+
+
+class SyncWorker:
+    """Polls storage for eligible messages and drives them to delivery."""
+
+    def __init__(
+        self,
+        storage: StorageBackend,
+        transports: TransportRegistry,
+        retry_policy: RetryPolicy,
+        *,
+        batch_size: int,
+        concurrency: int,
+        poll_interval: float,
+        lease_duration: float,
+        clock: Clock | None = None,
+    ) -> None:
+        self._storage = storage
+        self._transports = transports
+        self._retry_policy = retry_policy
+        self._batch_size = batch_size
+        self._semaphore = asyncio.Semaphore(concurrency)
+        self._scheduler = PollScheduler(poll_interval)
+        self._lease_duration = lease_duration
+        self._clock = clock or SystemClock()
+        self._lifecycle = LifecycleGuard("SyncWorker")
+        self._task: asyncio.Task[None] | None = None
+        self._stopping = asyncio.Event()
+
+    @property
+    def is_running(self) -> bool:
+        return self._lifecycle.is_running
+
+    async def start(self) -> None:
+        if not await self._lifecycle.begin_start():
+            logger.debug("worker.start() called while already running; ignoring")
+            return
+        self._stopping.clear()
+        self._task = asyncio.create_task(self._run(), name="edgesync-worker")
+        self._lifecycle.mark_running()
+        logger.info("worker started")
+
+    async def stop(self, grace_period: float) -> None:
+        if not await self._lifecycle.begin_stop():
+            return
+        self._stopping.set()
+        if self._task is not None:
+            try:
+                await asyncio.wait_for(self._task, timeout=grace_period)
+            except asyncio.TimeoutError:
+                logger.warning(
+                    "worker did not stop within %.1fs grace period; cancelling in-flight work",
+                    grace_period,
+                )
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+        self._lifecycle.mark_stopped()
+        logger.info("worker stopped")
+
+    async def _run(self) -> None:
+        while not self._stopping.is_set():
+            messages: list[Message] = []
+            try:
+                await self._storage.recover_expired_leases()
+                await self._storage.expire_stale_messages()
+                messages = await self._storage.claim_batch(self._batch_size, self._lease_duration)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("worker: error while polling storage")
+
+            if messages:
+                logger.debug("worker: claimed %d message(s)", len(messages))
+                await asyncio.gather(*(self._process_one(m) for m in messages))
+
+            await self._scheduler.wait(found_work=bool(messages))
+
+    async def _process_one(self, message: Message) -> None:
+        async with self._semaphore:
+            try:
+                transport = self._transports.get(message.destination)
+            except Exception as exc:
+                logger.error("worker: no transport for message %s: %s", message.id, exc)
+                result = DeliveryResult.permanent_failure(f"no transport configured: {exc}")
+            else:
+                try:
+                    result = await transport.deliver(message)
+                except asyncio.CancelledError:
+                    raise
+                except Exception as exc:
+                    logger.exception(
+                        "worker: transport raised while delivering message %s", message.id
+                    )
+                    result = DeliveryResult.retryable_failure(f"transport raised: {exc}")
+
+            await self._handle_result(message, result)
+
+    async def _handle_result(self, message: Message, result: DeliveryResult) -> None:
+        assert message.lease_id is not None, "claimed messages always carry a lease_id"
+
+        if result.success:
+            await self._storage.mark_delivered(message.id, message.lease_id)
+            logger.info("message %s delivered (status=%s)", message.id, result.status_code)
+            return
+
+        new_attempts = message.attempts + 1
+        permanently_failed = (
+            result.outcome is DeliveryOutcome.PERMANENT_FAILURE
+            or self._retry_policy.is_exhausted(new_attempts)
+        )
+        if permanently_failed:
+            await self._storage.move_to_dead_letter(
+                message.id, message.lease_id, result.error or "delivery failed"
+            )
+            return
+
+        delay = self._retry_policy.next_delay(new_attempts)
+        next_attempt_at = self._clock.now() + timedelta(seconds=delay)
+        await self._storage.schedule_retry(
+            message.id, message.lease_id, result.error or "delivery failed", next_attempt_at
+        )
+        logger.info(
+            "message %s retry %d scheduled in %.2fs: %s",
+            message.id,
+            new_attempts,
+            delay,
+            result.error,
+        )

edgesync-0.2.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.5
+Name: edgesync
+Version: 0.2.0
+Summary: Reliable data delivery for unreliable networks.
+Project-URL: Homepage, https://github.com/adhuldas/EdgeSync
+Project-URL: Repository, https://github.com/adhuldas/EdgeSync
+Project-URL: Documentation, https://github.com/adhuldas/EdgeSync/tree/main/docs
+Project-URL: Changelog, https://github.com/adhuldas/EdgeSync/blob/main/CHANGELOG.md
+Author-email: Adhul Das M K <adhulamz@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: edge,iot,offline,queue,reliability,retry,sync
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# EdgeSync
+
+[![CI](https://github.com/adhuldas/EdgeSync/actions/workflows/ci.yml/badge.svg)](https://github.com/adhuldas/EdgeSync/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/edgesync.svg)](https://pypi.org/project/edgesync/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](pyproject.toml)
+
+A lightweight Python library for reliable data delivery from edge applications to cloud
+services. EdgeSync provides persistent local queuing, store-and-forward synchronization,
+automatic retries, and recovery from network or application failures. Built for IoT devices,
+edge gateways, industrial systems, and any application operating with intermittent
+connectivity.
+
+## Why EdgeSync
+
+Edge applications lose data for the same handful of reasons every time: the network drops,
+the cloud endpoint is temporarily unavailable, or the process crashes mid-send. EdgeSync
+solves this with a durable store-and-forward architecture:
+
+1. Data is persisted locally (SQLite) before anything is sent.
+2. A background worker attempts delivery to the configured destination.
+3. Acknowledged messages are removed from the local queue.
+4. Failed messages stay queued and are retried with backoff.
+5. Pending data survives process crashes and device restarts.
+
+EdgeSync provides **at-least-once** delivery, not exactly-once — see
+[docs/reliability.md](docs/reliability.md) for the exact guarantee and how to build
+idempotent consumers on top of it.
+
+## Install
+
+```bash
+pip install edgesync
+```
+
+## Quickstart
+
+```python
+import asyncio
+from edgesync import EdgeSync
+
+
+async def main():
+    async with EdgeSync(
+        database="edgesync.db",
+        endpoint="https://api.example.com/telemetry",
+    ) as sync:
+        receipt = await sync.publish(
+            {
+                "device_id": "device-001",
+                "temperature": 28.5,
+            }
+        )
+        print(f"queued as {receipt.message_id}")
+
+
+asyncio.run(main())
+```
+
+That's it: `publish()` durably persists the message and returns as soon as it's on disk. A
+background worker delivers it, retrying with exponential backoff on failure, without the
+caller needing to stay connected or wait for the network.
+
+## Usage with FastAPI, Flask, and plain asyncio
+
+EdgeSync is async-native, so it's most at home in an `asyncio` app or an async framework like
+FastAPI — start it once, publish from your handlers, close it on shutdown:
+
+```python
+# FastAPI
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await sync.start()
+    yield
+    await sync.close()
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.post("/telemetry")
+async def telemetry(payload: dict):
+    receipt = await sync.publish(payload)
+    return {"message_id": receipt.message_id}
+```
+
+Flask is synchronous, so it needs a small bridge to run EdgeSync's event loop on a background
+thread rather than spinning up a new loop per request. See
+[docs/integrations.md](docs/integrations.md) for the full FastAPI, Flask, and plain-`asyncio`
+guide, including the ready-to-use Flask bridge.
+
+## Features
+
+- **Durable local queue** — SQLite-backed, survives crashes and restarts.
+- **At-least-once delivery** — messages are only removed once the destination acknowledges
+  them.
+- **Automatic retries** — configurable exponential backoff with jitter.
+- **Dead-letter queue** — messages that exhaust retries or fail permanently are retained for
+  inspection instead of being silently dropped.
+- **Multiple destinations** — route different message types to different endpoints or
+  transports.
+- **Pluggable transports** — ships with an HTTP transport; implement `Transport` for anything
+  else (MQTT, gRPC, a message broker, ...).
+- **Bounded storage** — configurable queue capacity with a choice of overflow policies.
+- **Async-native** — built on `asyncio` and `httpx`.
+
+## Documentation
+
+- [Getting started](docs/getting-started.md)
+- [Using EdgeSync with FastAPI, Flask, and plain asyncio](docs/integrations.md)
+- [Reliability & delivery guarantees](docs/reliability.md)
+- [Storage design](docs/storage.md)
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check .
+uv run mypy
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the full workflow.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

edgesync-0.2.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+edgesync/__init__.py,sha256=sEaXEvrOXlQrds-YbEYsoj83bIpu7EYuozpHtqQR0NM,1773
+edgesync/client.py,sha256=3tQDfPrDYANaDcGXP3wJvAe215xCUDivY9vyAwP0La4,8905
+edgesync/config.py,sha256=-KXf-Yigk_1rRjvQ8crJQVMZqRCtTnOesZg4cvgFhsw,2774
+edgesync/exceptions.py,sha256=_v-ZnIYqHAz-Q76DVWmak0aZrqSwfqlpBioB6GYMGi8,1633
+edgesync/logging.py,sha256=5qZE0zY6aNVVmjcY7Ge0sTj3CqzTktdkuWo7_ELxC-E,522
+edgesync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edgesync/models/__init__.py,sha256=ha3zNRJCDE2lWvCcZfXoNvfsf4VO0lHz9PEr07TW398,471
+edgesync/models/delivery.py,sha256=IQ2zxEnxdTI20m3Y8n2-YZEOKJGK1Mg3V7S8P66uH5U,1978
+edgesync/models/message.py,sha256=j5XWth2oXrGfPGVWOQSEd1rwzQTSq_-LYWlDqe02kO4,2165
+edgesync/models/receipt.py,sha256=aYr6yuJFo6hm3P8BY1w3gA0cU_VF2VTaxJSVm5K3DtI,606
+edgesync/models/stats.py,sha256=BYbi-FdgC8RmggOutukOjgEQDhMynJsBQZUSEub70jo,737
+edgesync/queue/__init__.py,sha256=FRTn9y5ffNnwqqeqXI8aZhq1sDwrJtfy7immIrumGHo,161
+edgesync/queue/manager.py,sha256=35aF-Q3uKsSgEKg-BQk7rdho2yHyRZio-zX05L7U-UM,3102
+edgesync/retry/__init__.py,sha256=QikUc49eKUD4cw9PiB9WN8SekilpESYRFIeFigdh49w,130
+edgesync/retry/backoff.py,sha256=l_onIujEl7EdlaQ_Mg3KNhZ61XDUbI0XHpXwl5SghgU,1121
+edgesync/retry/policy.py,sha256=Qny8xy_0w2yELtb533bpjZHo583VkQNuLMCh0eJNBpM,2101
+edgesync/storage/__init__.py,sha256=haf9IUyapIrzYeQmhb7dLYt4S-LTfl7vyTpWn64ud2E,200
+edgesync/storage/base.py,sha256=uL-wSC1CBiM8esQkoGfIZhnl0lloiskJgVg6MH0SVmA,3752
+edgesync/storage/migrations.py,sha256=37WBCF0Q1ZpaObnsvGMLnTu1NSHoMP51RHkaRdxAqUQ,2211
+edgesync/storage/sqlite.py,sha256=2ydkuZLaw2-P518EtYm-zk1Rdit9btnoAti7Os1vAxk,21281
+edgesync/transports/__init__.py,sha256=sTW3K9XA1-DAzldfHCaGlv_XFcVnmMDtJHVnGJAl1gw,248
+edgesync/transports/base.py,sha256=6kkZWHesNXzBafHrbrtVFn3k9NoDmCxIhjKWna-X2EQ,947
+edgesync/transports/http.py,sha256=6q4ne70ztKAWTs0YJnqN72_3eo-NYFxEoD1qAwgoUek,4161
+edgesync/transports/registry.py,sha256=5wl0EmkHRRTgZkct9xiLGPzdhkWj_SS5R9hzKvnqTf4,1695
+edgesync/utils/__init__.py,sha256=iV5OXCznK1qG1K3zVCgjCV6H-X1ni2lhTI33dRNsDUw,67
+edgesync/utils/clock.py,sha256=JbeVoS_3Tv85LiNrLaijdWIsNrsSrEmQxxZGcMf2ZF0,1363
+edgesync/utils/ids.py,sha256=bES01uKJABuTR4XXgoctN-WfGRFCIDNzkyrqF2cINz4,507
+edgesync/worker/__init__.py,sha256=KW3kb-fcSBsK-pMJeklhQ41H3GZEhtjr6lzMSE5PG2s,123
+edgesync/worker/lifecycle.py,sha256=lp0h9bkt24TjVlYoIyEpvSR71sN1hbMuziydWKTF5JI,1851
+edgesync/worker/scheduler.py,sha256=Zsr49wIVCl0laOJ-tsw57Cf0_e9SHK7chkiV3pMr7-c,556
+edgesync/worker/sync_worker.py,sha256=3wL_Mo9MDJtLdq9_1yQRu3Q4WMGLE8S3ZLbjI3RPCN8,6367
+edgesync-0.2.0.dist-info/METADATA,sha256=BIyrpIXVW5drKTJW8wiUYGsxOHor4Fhm-aGzTQsiafA,5545
+edgesync-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+edgesync-0.2.0.dist-info/licenses/LICENSE,sha256=wfZl5iyvqgoar8g9FCkovkkWX_sPfEuD6NtW8nnUxUQ,1078
+edgesync-0.2.0.dist-info/RECORD,,

edgesync-0.2.0.dist-info/WHEEL

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

edgesync-0.2.0.dist-info/licenses/LICENSE

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