zerodb-celery 0.1.0__py3-none-any.whl

zerodb_celery/__init__.py

@@ -0,0 +1,16 @@
+"""zerodb-celery: Celery broker + result backend powered by ZeroDB.
+
+Replace Redis or RabbitMQ with ZeroDB in one line:
+
+    app = Celery('tasks')
+    app.config_from_object({
+        'broker_url': 'zerodb://auto',
+        'result_backend': 'zerodb://auto',
+    })
+"""
+
+from zerodb_celery.backend import ZeroDBBackend
+from zerodb_celery.broker import ZeroDBBroker
+
+__version__ = "0.1.0"
+__all__ = ["ZeroDBBackend", "ZeroDBBroker"]

zerodb_celery/backend.py

@@ -0,0 +1,172 @@
+"""ZeroDB Celery Result Backend — stores task results in a ZeroDB table.
+
+Uses the ZeroDB tables API:
+  - POST /api/v1/zerodb/tables/{table}/rows   (store result)
+  - GET  /api/v1/zerodb/tables/{table}/rows/{id}  (get result)
+"""
+
+import json
+import time
+from datetime import datetime, timezone
+
+from celery.backends.base import BaseKeyValueStoreBackend
+from celery.exceptions import ImproperlyConfigured
+
+import requests
+
+from zerodb_celery.provision import (
+    ZERODB_API,
+    auto_provision,
+    ensure_results_table,
+)
+
+
+class ZeroDBBackend(BaseKeyValueStoreBackend):
+    """Celery result backend using ZeroDB tables.
+
+    Configuration via Celery app:
+        app.conf.update(
+            result_backend='zerodb://auto',
+            zerodb_api_key='...',       # optional, auto-provisions
+            zerodb_project_id='...',    # optional, auto-provisions
+            zerodb_base_url='...',      # optional
+            zerodb_results_table='celery_results',  # optional
+        )
+
+    Or use the helper:
+        ZeroDBBackend.configure(app)
+    """
+
+    # Celery uses this to find the backend class from URL scheme
+    # e.g., result_backend = 'zerodb://auto'
+
+    def __init__(self, app=None, url=None, **kwargs):
+        super().__init__(app=app, url=url, **kwargs)
+        self._api_key = None
+        self._project_id = None
+        self._base_url = ZERODB_API
+        self._table = "celery_results"
+        self._provisioned = False
+        self._resolve_config()
+
+    def _resolve_config(self):
+        """Resolve ZeroDB credentials from Celery config or auto-provision."""
+        conf = self.app.conf if self.app else None
+
+        if conf:
+            self._api_key = getattr(conf, "zerodb_api_key", None)
+            self._project_id = getattr(conf, "zerodb_project_id", None)
+            base = getattr(conf, "zerodb_base_url", None)
+            if base:
+                self._base_url = base
+            table = getattr(conf, "zerodb_results_table", None)
+            if table:
+                self._table = table
+
+        if not self._api_key or not self._project_id:
+            self._api_key, self._project_id = auto_provision(self._base_url)
+
+    def _ensure_table(self):
+        """Lazily ensure the results table exists (once per process)."""
+        if not self._provisioned:
+            ensure_results_table(self._api_key, self._project_id, self._base_url)
+            self._provisioned = True
+
+    def _headers(self):
+        return {
+            "Authorization": f"Bearer {self._api_key}",
+            "X-Project-ID": self._project_id,
+            "Content-Type": "application/json",
+        }
+
+    def get(self, key):
+        """Retrieve a task result by key (task_id)."""
+        self._ensure_table()
+        try:
+            resp = requests.get(
+                f"{self._base_url}/api/v1/zerodb/tables/{self._table}/rows/{key}",
+                headers=self._headers(),
+                timeout=15,
+            )
+            if resp.status_code == 404:
+                return None
+            resp.raise_for_status()
+            row = resp.json()
+            # Return the raw stored value (JSON string)
+            result_data = row.get("result") or row.get("data", {}).get("result")
+            if isinstance(result_data, str):
+                return result_data.encode("utf-8")
+            return result_data
+        except requests.RequestException:
+            return None
+
+    def set(self, key, value):
+        """Store a task result."""
+        self._ensure_table()
+        # value comes as bytes from Celery
+        if isinstance(value, bytes):
+            value = value.decode("utf-8")
+
+        try:
+            resp = requests.post(
+                f"{self._base_url}/api/v1/zerodb/tables/{self._table}/rows",
+                headers=self._headers(),
+                json={
+                    "id": key,
+                    "data": {
+                        "task_id": key,
+                        "result": value,
+                        "date_done": datetime.now(timezone.utc).isoformat(),
+                    },
+                },
+                timeout=15,
+            )
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            raise BackendError(f"Failed to store result in ZeroDB: {e}") from e
+
+    def mget(self, keys):
+        """Retrieve multiple results."""
+        return [self.get(key) for key in keys]
+
+    def delete(self, key):
+        """Delete a task result."""
+        try:
+            requests.delete(
+                f"{self._base_url}/api/v1/zerodb/tables/{self._table}/rows/{key}",
+                headers=self._headers(),
+                timeout=15,
+            )
+        except requests.RequestException:
+            pass
+
+    @classmethod
+    def configure(cls, app, api_key=None, project_id=None, base_url=None,
+                  results_table=None):
+        """Configure a Celery app to use ZeroDB as result backend.
+
+        Args:
+            app: Celery application instance.
+            api_key: ZeroDB API key (auto-provisions if not set).
+            project_id: ZeroDB project ID (auto-provisions if not set).
+            base_url: ZeroDB API base URL.
+            results_table: Name of the results table (default: celery_results).
+        """
+        conf = {
+            "result_backend": "zerodb_celery.backend:ZeroDBBackend",
+        }
+        if api_key:
+            conf["zerodb_api_key"] = api_key
+        if project_id:
+            conf["zerodb_project_id"] = project_id
+        if base_url:
+            conf["zerodb_base_url"] = base_url
+        if results_table:
+            conf["zerodb_results_table"] = results_table
+
+        app.config_from_object(conf)
+        return app
+
+
+class BackendError(Exception):
+    """Raised when backend operations fail."""

zerodb_celery/broker.py

@@ -0,0 +1,214 @@
+"""ZeroDB Celery Broker — uses ZeroDB event stream as a message queue.
+
+Publishes tasks via POST /api/v1/zerodb/events and consumes them
+via GET /api/v1/zerodb/events?topic={queue}.
+"""
+
+import json
+import time
+
+from kombu.transport import virtual
+from kombu.utils.encoding import bytes_to_str
+
+from zerodb_celery.provision import ZERODB_API, auto_provision
+
+import requests
+
+
+class Channel(virtual.Channel):
+    """A Kombu channel backed by ZeroDB event stream."""
+
+    # Prefix for ZeroDB event topics so they don't collide
+    _topic_prefix = "celery:"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._api_key = None
+        self._project_id = None
+        self._base_url = ZERODB_API
+        self._provision()
+
+    def _provision(self):
+        """Resolve credentials from the broker URL or auto-provision."""
+        url = self.connection.client.hostname or ""
+        # Parse zerodb://key:project@host or zerodb://auto
+        if url and url not in ("auto", "localhost"):
+            self._base_url = f"https://{url}"
+
+        transport_opts = self.connection.client.transport_options or {}
+        self._api_key = transport_opts.get("api_key")
+        self._project_id = transport_opts.get("project_id")
+        base = transport_opts.get("base_url")
+        if base:
+            self._base_url = base
+
+        if not self._api_key or not self._project_id:
+            self._api_key, self._project_id = auto_provision(self._base_url)
+
+    def _headers(self):
+        return {
+            "Authorization": f"Bearer {self._api_key}",
+            "X-Project-ID": self._project_id,
+            "Content-Type": "application/json",
+        }
+
+    def _put(self, queue, message, **kwargs):
+        """Publish a message (task) to the queue via ZeroDB events."""
+        topic = f"{self._topic_prefix}{queue}"
+        payload = message if isinstance(message, str) else json.dumps(message)
+        try:
+            resp = requests.post(
+                f"{self._base_url}/api/v1/zerodb/events",
+                headers=self._headers(),
+                json={
+                    "topic": topic,
+                    "data": payload,
+                },
+                timeout=15,
+            )
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            raise ChannelError(f"Failed to publish task to ZeroDB: {e}") from e
+
+    def _get(self, queue, timeout=None):
+        """Consume the next message from the queue via ZeroDB events."""
+        topic = f"{self._topic_prefix}{queue}"
+        try:
+            resp = requests.get(
+                f"{self._base_url}/api/v1/zerodb/events",
+                headers=self._headers(),
+                params={
+                    "topic": topic,
+                    "limit": 1,
+                    "consume": "true",
+                },
+                timeout=timeout or 15,
+            )
+            if resp.status_code == 404:
+                raise virtual.Empty()
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.RequestException:
+            raise virtual.Empty()
+
+        events = data if isinstance(data, list) else data.get("events", [])
+        if not events:
+            raise virtual.Empty()
+
+        event = events[0]
+        raw = event.get("data", event)
+        if isinstance(raw, str):
+            try:
+                raw = json.loads(raw)
+            except (json.JSONDecodeError, TypeError):
+                pass
+        return raw
+
+    def _purge(self, queue):
+        """Purge all messages from a queue."""
+        topic = f"{self._topic_prefix}{queue}"
+        try:
+            resp = requests.delete(
+                f"{self._base_url}/api/v1/zerodb/events",
+                headers=self._headers(),
+                params={"topic": topic},
+                timeout=15,
+            )
+            if resp.ok:
+                return resp.json().get("deleted", 0)
+        except requests.RequestException:
+            pass
+        return 0
+
+    def _size(self, queue):
+        """Return approximate queue size."""
+        topic = f"{self._topic_prefix}{queue}"
+        try:
+            resp = requests.get(
+                f"{self._base_url}/api/v1/zerodb/events",
+                headers=self._headers(),
+                params={"topic": topic, "count_only": "true"},
+                timeout=10,
+            )
+            if resp.ok:
+                data = resp.json()
+                return data.get("count", 0)
+        except requests.RequestException:
+            pass
+        return 0
+
+
+class ChannelError(Exception):
+    """Raised when broker operations fail."""
+
+
+class Transport(virtual.Transport):
+    """Kombu transport that uses ZeroDB as the message broker."""
+
+    Channel = Channel
+
+    driver_type = "zerodb"
+    driver_name = "zerodb"
+
+    # Connection defaults
+    default_port = 443
+    connection_errors = (
+        virtual.Transport.connection_errors + (
+            requests.ConnectionError,
+            requests.Timeout,
+        )
+    )
+    channel_errors = (
+        virtual.Transport.channel_errors + (
+            ChannelError,
+        )
+    )
+
+    # Polling interval (seconds) when no messages are available
+    polling_interval = 1.0
+
+    def driver_version(self):
+        from zerodb_celery import __version__
+        return __version__
+
+
+class ZeroDBBroker:
+    """Convenience wrapper for configuring Celery with ZeroDB broker.
+
+    Usage:
+        app = Celery('tasks')
+        app.config_from_object({
+            'broker_url': 'zerodb://auto',
+            'broker_transport': 'zerodb_celery.broker:Transport',
+        })
+
+    Or use the helper:
+        ZeroDBBroker.configure(app)
+    """
+
+    TRANSPORT = "zerodb_celery.broker:Transport"
+
+    @classmethod
+    def configure(cls, app, api_key=None, project_id=None, base_url=None):
+        """Configure a Celery app to use ZeroDB as broker.
+
+        Args:
+            app: Celery application instance.
+            api_key: ZeroDB API key (auto-provisions if not set).
+            project_id: ZeroDB project ID (auto-provisions if not set).
+            base_url: ZeroDB API base URL.
+        """
+        transport_options = {}
+        if api_key:
+            transport_options["api_key"] = api_key
+        if project_id:
+            transport_options["project_id"] = project_id
+        if base_url:
+            transport_options["base_url"] = base_url
+
+        app.conf.update(
+            broker_url="zerodb://auto",
+            broker_transport=cls.TRANSPORT,
+            broker_transport_options=transport_options,
+        )
+        return app

zerodb_celery/provision.py

@@ -0,0 +1,132 @@
+"""Auto-provisioning for ZeroDB projects.
+
+Creates a free ZeroDB project on first use — no signup, no credit card.
+Credentials are cached in ~/.zerodb/credentials.json for reuse.
+Also ensures the celery_results table exists.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import requests
+
+ZERODB_API = "https://api.ainative.studio"
+CREDENTIALS_PATH = Path.home() / ".zerodb" / "credentials.json"
+
+CELERY_RESULTS_TABLE = "celery_results"
+CELERY_RESULTS_COLUMNS = {
+    "task_id": "string",
+    "status": "string",
+    "result": "string",
+    "traceback": "string",
+    "date_done": "string",
+    "meta": "string",
+}
+
+
+def _load_cached_credentials():
+    """Load cached credentials from disk."""
+    if CREDENTIALS_PATH.exists():
+        try:
+            data = json.loads(CREDENTIALS_PATH.read_text())
+            if data.get("api_key") and data.get("project_id"):
+                return data["api_key"], data["project_id"]
+        except (json.JSONDecodeError, KeyError):
+            pass
+    return None, None
+
+
+def _save_credentials(api_key: str, project_id: str):
+    """Cache credentials to disk for reuse."""
+    CREDENTIALS_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CREDENTIALS_PATH.write_text(json.dumps({
+        "api_key": api_key,
+        "project_id": project_id,
+    }, indent=2))
+    try:
+        CREDENTIALS_PATH.chmod(0o600)
+    except OSError:
+        pass
+
+
+def auto_provision(base_url: str = ZERODB_API) -> tuple:
+    """Auto-provision a ZeroDB project.
+
+    Resolution order:
+    1. ZERODB_API_KEY + ZERODB_PROJECT_ID env vars
+    2. Cached credentials in ~/.zerodb/credentials.json
+    3. Provision a new free project via API
+
+    Returns:
+        tuple: (api_key, project_id)
+
+    Raises:
+        RuntimeError: If provisioning fails.
+    """
+    # 1. Environment variables
+    api_key = os.environ.get("ZERODB_API_KEY")
+    project_id = os.environ.get("ZERODB_PROJECT_ID")
+    if api_key and project_id:
+        return api_key, project_id
+
+    # 2. Cached credentials
+    api_key, project_id = _load_cached_credentials()
+    if api_key and project_id:
+        return api_key, project_id
+
+    # 3. Auto-provision
+    print("[zerodb-celery] Auto-provisioning free ZeroDB project...", file=sys.stderr)
+    try:
+        resp = requests.post(
+            f"{base_url}/api/v1/zerodb/projects/provision",
+            json={"source": "zerodb-celery"},
+            timeout=30,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        api_key = data["api_key"]
+        project_id = data["project_id"]
+    except requests.RequestException as e:
+        raise RuntimeError(
+            f"Failed to auto-provision ZeroDB project: {e}\n"
+            "Set ZERODB_API_KEY and ZERODB_PROJECT_ID manually, or visit "
+            "https://ainative.studio to create a free account."
+        ) from e
+
+    _save_credentials(api_key, project_id)
+
+    claim_url = data.get("claim_url", "https://ainative.studio/claim")
+    print(
+        f"[zerodb-celery] Project provisioned! Claim it at: {claim_url}",
+        file=sys.stderr,
+    )
+    return api_key, project_id
+
+
+def ensure_results_table(api_key: str, project_id: str, base_url: str = ZERODB_API):
+    """Create the celery_results table if it does not exist.
+
+    This is idempotent — calling it multiple times is safe.
+    """
+    try:
+        resp = requests.post(
+            f"{base_url}/api/v1/zerodb/tables",
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "X-Project-ID": project_id,
+            },
+            json={
+                "name": CELERY_RESULTS_TABLE,
+                "columns": CELERY_RESULTS_COLUMNS,
+            },
+            timeout=15,
+        )
+        # 409 = table already exists — that's fine
+        if resp.status_code not in (200, 201, 409):
+            resp.raise_for_status()
+    except requests.RequestException:
+        # Non-fatal: the table might already exist or will be created
+        # lazily on first write by ZeroDB
+        pass

zerodb_celery-0.1.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: zerodb-celery
+Version: 0.1.0
+Summary: Celery broker + result backend powered by ZeroDB. Replace Redis/RabbitMQ with one line — zero infrastructure, auto-provisioned.
+Project-URL: Homepage, https://github.com/AINative-Studio/zerodb-celery
+Project-URL: Documentation, https://docs.ainative.studio
+Project-URL: Repository, https://github.com/AINative-Studio/zerodb-celery
+Project-URL: Issues, https://github.com/AINative-Studio/zerodb-celery/issues
+Author-email: AINative Studio <hello@ainative.studio>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-pipeline,ainative,auto-provisioning,background-jobs,celery,celery-backend,celery-broker,claude,cursor,event-driven,ml-pipeline,python,rabbitmq-alternative,redis-alternative,task-queue,zerodb
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Celery
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.8
+Requires-Dist: celery>=5.0
+Requires-Dist: requests>=2.28
+Description-Content-Type: text/markdown
+
+# zerodb-celery
+
+**Celery broker + result backend powered by ZeroDB. Replace Redis/RabbitMQ with one line.**
+
+[![PyPI](https://img.shields.io/pypi/v/zerodb-celery)](https://pypi.org/project/zerodb-celery/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+## Why?
+
+Celery requires Redis or RabbitMQ for its broker and result backend. That means provisioning, configuring, and paying for infrastructure you shouldn't need.
+
+`zerodb-celery` replaces both with [ZeroDB](https://ainative.studio) — a cloud database that auto-provisions on first use. No signup, no credit card, no infrastructure.
+
+## Install
+
+```bash
+pip install zerodb-celery
+```
+
+## Quick Start
+
+```python
+from celery import Celery
+from zerodb_celery import ZeroDBBroker, ZeroDBBackend
+
+app = Celery('tasks')
+
+# Configure both broker and backend
+ZeroDBBroker.configure(app)
+ZeroDBBackend.configure(app)
+
+@app.task
+def add(x, y):
+    return x + y
+
+# Trigger a task
+result = add.delay(4, 6)
+print(result.get(timeout=30))  # 10
+```
+
+## Configuration
+
+### Auto-provisioning (default)
+
+Just use `zerodb://auto` — a free ZeroDB project is created on first use:
+
+```python
+app.config_from_object({
+    'broker_url': 'zerodb://auto',
+    'broker_transport': 'zerodb_celery.broker:Transport',
+    'result_backend': 'zerodb_celery.backend:ZeroDBBackend',
+})
+```
+
+### Explicit credentials
+
+Set environment variables:
+
+```bash
+export ZERODB_API_KEY=zdb_your_key_here
+export ZERODB_PROJECT_ID=proj_your_id_here
+```
+
+Or pass them directly:
+
+```python
+ZeroDBBroker.configure(app, api_key='zdb_...', project_id='proj_...')
+ZeroDBBackend.configure(app, api_key='zdb_...', project_id='proj_...')
+```
+
+### Credential resolution order
+
+1. Explicit `api_key` / `project_id` parameters
+2. `ZERODB_API_KEY` / `ZERODB_PROJECT_ID` environment variables
+3. Cached credentials in `~/.zerodb/credentials.json`
+4. Auto-provision a new free project via API
+
+## How It Works
+
+### Broker (message queue)
+
+The broker uses ZeroDB's event stream as a message queue:
+
+- **Publish task**: `POST /api/v1/zerodb/events` with topic `celery:{queue_name}`
+- **Consume task**: `GET /api/v1/zerodb/events?topic=celery:{queue_name}&consume=true`
+
+### Result backend (task results)
+
+The backend stores results in a ZeroDB table called `celery_results`:
+
+- **Store result**: `POST /api/v1/zerodb/tables/celery_results/rows`
+- **Get result**: `GET /api/v1/zerodb/tables/celery_results/rows/{task_id}`
+
+The table is auto-created on first use.
+
+## Use Cases
+
+- **ML pipelines**: Queue training jobs, store results — no Redis needed
+- **AI agent workflows**: Background task processing for agent swarms
+- **Serverless apps**: No infrastructure to manage alongside your Celery workers
+- **Prototyping**: Get Celery running in 30 seconds without Docker
+
+## Comparison
+
+| Feature | Redis | RabbitMQ | zerodb-celery |
+|---------|-------|----------|---------------|
+| Setup time | 5-30 min | 10-60 min | 0 min (auto) |
+| Infrastructure | Self-hosted or managed | Self-hosted or managed | None |
+| Cost | $15-100+/mo | $15-100+/mo | Free tier |
+| Persistence | Optional (AOF/RDB) | Yes | Yes |
+| Auto-provisioning | No | No | Yes |
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/ -v
+```
+
+## License
+
+MIT

zerodb_celery-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+zerodb_celery/__init__.py,sha256=Lc7g-H6cxH4t4N8qRcSQdzmYSWjKMbgKusuba-GgfDI,431
+zerodb_celery/backend.py,sha256=OWQXV-O7ZgB6Zt9JGnxWkVIMU5JL5ig9lubs4XVcQbA,5785
+zerodb_celery/broker.py,sha256=l8upQGFxj2h8I4Ot8lPduSRYKJSAdralezVcDTw3b88,6612
+zerodb_celery/provision.py,sha256=wBxPTH1gMiOvVjJ2AR5wMGe05FIaHXG_k1rRt9uYF3E,4022
+zerodb_celery-0.1.0.dist-info/METADATA,sha256=wC32qJof1gEz0Mi-w1UQGqcyx6A6HIA1Vi_nhD9txMg,4851
+zerodb_celery-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+zerodb_celery-0.1.0.dist-info/licenses/LICENSE,sha256=-3M2h1U80S6mPyiuvRG25A0l1xZGpa7eO43lysBIzBY,1072
+zerodb_celery-0.1.0.dist-info/RECORD,,

zerodb_celery-0.1.0.dist-info/WHEEL

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

zerodb_celery-0.1.0.dist-info/licenses/LICENSE

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