diffusr 0.1.0__py3-none-any.whl

diffusr/__init__.py

@@ -0,0 +1,20 @@
+"""The diffusr API client. Stdlib only.
+
+    from diffusr import Diffusr
+    d = Diffusr()  # reads DIFFUSR_KEY
+    quote = d.make_video(prompt="...", dry_run=True)   # free
+"""
+
+from ._client import DEFAULT_BASE_URL, TERMINAL_STATUSES, Diffusr
+from ._errors import DiffusrError
+from ._verify import SIGNATURE_TOLERANCE_SEC, verify_callback
+
+__all__ = [
+    "Diffusr",
+    "DiffusrError",
+    "verify_callback",
+    "DEFAULT_BASE_URL",
+    "TERMINAL_STATUSES",
+    "SIGNATURE_TOLERANCE_SEC",
+]
+__version__ = "0.1.0"

diffusr/_client.py

@@ -0,0 +1,287 @@
+from __future__ import annotations
+
+import json
+import mimetypes
+import os
+import socket
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Callable, Dict, Mapping, Optional, Union
+
+from ._errors import DiffusrError
+from ._verify import verify_callback as _verify_callback
+
+DEFAULT_BASE_URL = "https://app.diffusr.ai/api/v2"
+SDK_VERSION = "0.1.0"
+TERMINAL_STATUSES = ("SUCCEEDED", "FAILED", "CANCELED")
+# Never sleep longer than this on one automatic retry; raise instead.
+MAX_AUTO_RETRY_WAIT_SEC = 30
+
+_CONTENT_TYPES = {
+    ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp",
+    ".gif": "image/gif", ".mp4": "video/mp4", ".mov": "video/quicktime", ".webm": "video/webm",
+    ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4",
+}
+
+
+class Diffusr:
+    """Client for the diffusr REST API (v2). Bodies and answers are the API's own snake_case JSON.
+
+    api_key   dfsr_live_... or dfsr_test_... (free). Default: the DIFFUSR_KEY environment variable.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        *,
+        max_retries: int = 3,
+        retry_base: float = 0.5,
+        timeout: float = 60.0,
+    ) -> None:
+        key = api_key or os.environ.get("DIFFUSR_KEY")
+        if not key:
+            raise DiffusrError(0, "MISSING_API_KEY", "Pass an API key or set DIFFUSR_KEY.")
+        self._key = key
+        self._base = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self._max_retries = max_retries
+        self._retry_base = retry_base
+        self._timeout = timeout
+
+    # ——— make calls (paid; dry_run=True is free) ———
+
+    def make_video(self, **body: Any) -> Dict[str, Any]:
+        return self._make("make_video", body)
+
+    def make_image(self, **body: Any) -> Dict[str, Any]:
+        return self._make("make_image", body)
+
+    def edit_image(self, **body: Any) -> Dict[str, Any]:
+        return self._make("edit_image", body)
+
+    def recast(self, **body: Any) -> Dict[str, Any]:
+        return self._make("recast", body)
+
+    def make_music(self, **body: Any) -> Dict[str, Any]:
+        return self._make("make_music", body)
+
+    def creator_video(self, **body: Any) -> Dict[str, Any]:
+        return self._make("creator_video", body)
+
+    def run_template(self, **body: Any) -> Dict[str, Any]:
+        """Run one of diffusr's templates. One flat body: template="<id from list_templates()>",
+        plus the fields that template takes (mode, prompt, pictures, image_urls, product_image_url,
+        script, place, people, setup, resolution, dry_run, callback_url)."""
+        return self._make("run_template", body)
+
+    def _make(self, tool: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        # One Idempotency-Key per call, reused by every automatic retry.
+        key = body.pop("idempotency_key", None) or str(uuid.uuid4())
+        return self._request("POST", f"/{tool}", body=body, headers={"Idempotency-Key": key})
+
+    # ——— results ———
+
+    def get_result(self, id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/results/{urllib.parse.quote(id, safe='')}")
+
+    def list_results(self, limit: Optional[int] = None) -> Dict[str, Any]:
+        return self._request("GET", "/results" + _query(limit=limit))
+
+    def cancel(self, id: str) -> Dict[str, Any]:
+        """Stop queued work before it generates (that part is never charged).
+
+        A step that is already generating may still finish and be charged: check
+        result["charge"] on the answer. A finished job comes back unchanged.
+        """
+        return self._request("POST", f"/results/{urllib.parse.quote(id, safe='')}/cancel", body={})
+
+    def wait_for(
+        self,
+        id: str,
+        timeout: float = 900.0,
+        interval: float = 3.0,
+        on_poll: Optional[Callable[[Dict[str, Any]], None]] = None,
+    ) -> Dict[str, Any]:
+        """Poll until the job is over and return the result (seconds, not ms).
+
+        A job that ends FAILED or CANCELED is returned too: check result["status"].
+        Raises DiffusrError(code="WAIT_TIMEOUT") if it is still running at the
+        deadline (the job itself keeps going).
+        """
+        deadline = time.monotonic() + timeout
+        pause = interval
+        while True:
+            result = self.get_result(id)
+            if on_poll:
+                on_poll(result)
+            if result.get("status") in TERMINAL_STATUSES:
+                return result
+            left = deadline - time.monotonic()
+            if left <= 0:
+                break
+            time.sleep(min(pause, left))
+            pause = min(pause * 1.5, max(15.0, interval))
+            if time.monotonic() >= deadline:
+                break
+        raise DiffusrError(
+            0,
+            "WAIT_TIMEOUT",
+            f"Result {id} was still not finished after {int(timeout)} s. It keeps running: call wait_for or get_result again.",
+        )
+
+    # ——— files ———
+
+    def upload_file(
+        self, file: Union[str, "os.PathLike[str]", bytes, bytearray], content_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Upload a local file (a path, or bytes) and get a file_url to pass to a tool.
+
+        Two steps: ask for a signed URL, PUT the exact bytes to it.
+        """
+        if isinstance(file, (bytes, bytearray)):
+            data = bytes(file)
+        else:
+            path = os.fspath(file)
+            with open(path, "rb") as f:
+                data = f.read()
+            content_type = content_type or _CONTENT_TYPES.get(os.path.splitext(path)[1].lower()) or mimetypes.guess_type(path)[0]
+        if not content_type:
+            raise DiffusrError(0, "CONTENT_TYPE_REQUIRED", 'Pass content_type (e.g. "video/mp4"): it could not be worked out.')
+        ticket = self._request("POST", "/uploads", body={"content_type": content_type, "size_bytes": len(data)})
+        req = urllib.request.Request(ticket["upload_url"], data=data, method=ticket.get("method", "PUT"))
+        for k, v in ticket.get("headers", {}).items():
+            req.add_header(k, v)
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout):
+                pass
+        except urllib.error.HTTPError as e:
+            raise DiffusrError(e.code, "UPLOAD_FAILED", f"The upload PUT failed with HTTP {e.code}.") from None
+        except urllib.error.URLError as e:
+            raise DiffusrError(0, "NETWORK_ERROR", f"The upload PUT failed: {e.reason}") from None
+        return {"file_url": ticket["file_url"], "kind": ticket.get("kind")}
+
+    def upload_from_url(self, source_url: str) -> Dict[str, Any]:
+        """Have us copy a public link in (images and short clips; use upload_file for big videos)."""
+        return self._request("POST", "/uploads", body={"source_url": source_url})
+
+    # ——— catalog ———
+
+    def list_models(self, kind: Optional[str] = None) -> Dict[str, Any]:
+        return self._request("GET", "/models" + _query(kind=kind))
+
+    def list_templates(self) -> Dict[str, Any]:
+        return self._request("GET", "/templates")
+
+    # ——— callbacks ———
+
+    def list_callbacks(self, limit: Optional[int] = None, cursor: Optional[str] = None) -> Dict[str, Any]:
+        return self._request("GET", "/callbacks" + _query(limit=limit, cursor=cursor))
+
+    def retry_callback(self, event_id: str) -> Dict[str, Any]:
+        """One more try for a FAILED event (up to 3 by hand)."""
+        return self._request("POST", f"/callbacks/{urllib.parse.quote(event_id, safe='')}/retry", body={})
+
+    def get_callback_secret(self) -> Dict[str, Any]:
+        """Your signing secret (whsec_...) for Diffusr.verify_callback."""
+        return self._request("GET", "/callbacks/secret")
+
+    def rotate_callback_secret(self) -> Dict[str, Any]:
+        return self._request("POST", "/callbacks/secret/rotate", body={})
+
+    @staticmethod
+    def verify_callback(
+        raw_body: Union[str, bytes],
+        headers: Mapping[str, str],
+        secret: str,
+        tolerance_sec: int = 300,
+        now: Optional[float] = None,
+    ) -> bool:
+        """Check a callback's signature (Standard Webhooks). Rejects a timestamp more than 5 minutes off."""
+        return _verify_callback(raw_body, headers, secret, tolerance_sec, now)
+
+    # ——— plumbing ———
+
+    def _backoff(self, attempt: int) -> float:
+        return self._retry_base * (2**attempt)
+
+    def _request(
+        self, method: str, path: str, body: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
+        hdrs = {
+            "Authorization": f"Bearer {self._key}",
+            "Accept": "application/json",
+            "User-Agent": f"diffusr-python/{SDK_VERSION}",
+        }
+        data = None
+        if body is not None:
+            hdrs["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+        hdrs.update(headers or {})
+
+        attempt = 0
+        while True:
+            req = urllib.request.Request(self._base + path, data=data, method=method, headers=hdrs)
+            try:
+                with urllib.request.urlopen(req, timeout=self._timeout) as res:
+                    text = res.read().decode("utf-8")
+                    return json.loads(text) if text else {}
+            except urllib.error.HTTPError as e:
+                err = _to_error(e)
+                wait = err.retry_after if err.retry_after is not None else self._backoff(attempt)
+                retryable = e.code in (429, 503) or (method == "GET" and e.code in (500, 502, 504))
+                if retryable and attempt < self._max_retries and wait <= MAX_AUTO_RETRY_WAIT_SEC:
+                    time.sleep(wait)
+                    attempt += 1
+                    continue
+                raise err from None
+            except (urllib.error.URLError, OSError) as e:
+                # OSError covers socket.timeout (a separate class before 3.10), TimeoutError, ConnectionError.
+                if attempt < self._max_retries:
+                    time.sleep(self._backoff(attempt))
+                    attempt += 1
+                    continue
+                reason = getattr(e, "reason", e)
+                if _is_timeout(e) or _is_timeout(reason):
+                    raise DiffusrError(0, "TIMEOUT", f"diffusr did not answer within {self._timeout:g} s.") from None
+                raise DiffusrError(0, "NETWORK_ERROR", f"Could not reach diffusr: {reason}") from None
+
+
+def _is_timeout(e: Any) -> bool:
+    return isinstance(e, (socket.timeout, TimeoutError))
+
+
+def _query(**params: Any) -> str:
+    q = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
+    return f"?{q}" if q else ""
+
+
+def _to_error(e: urllib.error.HTTPError) -> DiffusrError:
+    text = ""
+    try:
+        text = e.read().decode("utf-8", "replace")
+    except Exception:
+        pass
+    body: Optional[Dict[str, Any]] = None
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, dict):
+            body = parsed
+    except ValueError:
+        pass
+    retry_after: Optional[float] = None
+    header = e.headers.get("Retry-After") if e.headers else None
+    if header is not None:
+        try:
+            retry_after = float(header)
+        except ValueError:
+            pass
+    if retry_after is None and body and isinstance(body.get("retry_after_seconds"), (int, float)):
+        retry_after = float(body["retry_after_seconds"])
+    message = body["error"] if body and isinstance(body.get("error"), str) else (text[:300] or f"HTTP {e.code}")
+    code = body["code"] if body and isinstance(body.get("code"), str) else f"HTTP_{e.code}"
+    request_id = body.get("request_id") if body and isinstance(body.get("request_id"), str) else None
+    request_id = request_id or (e.headers.get("X-Request-Id") if e.headers else None)
+    return DiffusrError(e.code, code, message, request_id, retry_after, body)

diffusr/_errors.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+
+class DiffusrError(Exception):
+    """Every non-2xx answer (and a few client-side failures) raises this.
+
+    status       HTTP status; 0 when no answer came (network error, wait timeout)
+    code         the API's machine code, e.g. "RATE_LIMITED"
+    message      the API's plain-words error
+    request_id   quote it to support
+    retry_after  seconds to wait before trying again, when the API said so
+    body         the whole JSON error body (field, issues, budget...)
+    """
+
+    def __init__(
+        self,
+        status: int,
+        code: str,
+        message: str,
+        request_id: Optional[str] = None,
+        retry_after: Optional[float] = None,
+        body: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+        self.retry_after = retry_after
+        self.body = body
+
+    def __str__(self) -> str:
+        rid = f" (request_id {self.request_id})" if self.request_id else ""
+        return f"[{self.code}] {self.message}{rid}"

diffusr/_verify.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import base64
+import binascii
+import hashlib
+import hmac
+import time
+from typing import Mapping, Optional, Union
+
+SIGNATURE_TOLERANCE_SEC = 300
+
+
+def _header(headers: Mapping[str, str], name: str) -> Optional[str]:
+    for k, v in headers.items():
+        if k.lower() == name:
+            return v if isinstance(v, str) else " ".join(v)
+    return None
+
+
+def verify_callback(
+    raw_body: Union[str, bytes],
+    headers: Mapping[str, str],
+    secret: str,
+    tolerance_sec: int = SIGNATURE_TOLERANCE_SEC,
+    now: Optional[float] = None,
+) -> bool:
+    """Check a diffusr callback (Standard Webhooks).
+
+    raw_body is the request body exactly as received, before JSON parsing.
+    Returns False for a missing header, a bad or stale signature; never raises.
+    """
+    try:
+        msg_id = _header(headers, "webhook-id")
+        timestamp = _header(headers, "webhook-timestamp")
+        signature = _header(headers, "webhook-signature")
+        if not msg_id or not timestamp or not signature or not timestamp.isdigit():
+            return False
+        current = time.time() if now is None else now
+        if abs(int(current) - int(timestamp)) > tolerance_sec:
+            return False
+        body = raw_body if isinstance(raw_body, (bytes, bytearray)) else raw_body.encode("utf-8")
+        key = base64.b64decode(secret[6:] if secret.startswith("whsec_") else secret)
+        expected = hmac.new(key, f"{msg_id}.{timestamp}.".encode("utf-8") + bytes(body), hashlib.sha256).digest()
+        ok = False
+        for part in signature.split(" "):
+            if not part.startswith("v1,"):
+                continue
+            try:
+                given = base64.b64decode(part[3:], validate=True)
+            except (binascii.Error, ValueError):
+                continue
+            if hmac.compare_digest(given, expected):
+                ok = True
+        return ok
+    except Exception:
+        return False

diffusr-0.1.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: diffusr
+Version: 0.1.0
+Summary: The diffusr API client: make videos, images and music from code. Free price checks, idempotent starts, wait_for, signed callbacks.
+Project-URL: Homepage, https://diffusr.ai
+Project-URL: Documentation, https://diffusr.ai/docs
+License: MIT
+License-File: LICENSE
+Keywords: ai,api,diffusr,image,video
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# diffusr
+
+The diffusr API client for Python 3.9+. Make videos, images and music from
+code. Standard library only. Bodies and answers are the API's own snake_case
+JSON (plain dicts).
+
+```sh
+pip install diffusr
+```
+
+## Quickstart
+
+Use a **test key** (`dfsr_test_…`) while you build: prices are quoted exactly,
+nothing is charged, no model runs, and the result is a placeholder file a few
+seconds later. Swap in a live key (`dfsr_live_…`) when you are ready to spend.
+Mint keys on the Developers page in the app.
+
+```python
+from diffusr import Diffusr
+
+diffusr = Diffusr()  # reads DIFFUSR_KEY
+
+# 1. Ask the price. Free: nothing is made, nothing is spent.
+quote = diffusr.make_video(
+    prompt="A can of sparkling water on a wet street, slow push-in, rain",
+    duration_sec=5,
+    dry_run=True,
+)
+print(quote["price"])  # {'credits': 63, 'usd': '0.6300', ...}
+
+# 2. Make it. An Idempotency-Key is added for you and reused on retries,
+#    so a dropped connection never pays twice.
+job = diffusr.make_video(
+    prompt="A can of sparkling water on a wet street, slow push-in, rain",
+    duration_sec=5,
+)
+
+# 3. Wait for it (polls with backoff; raises WAIT_TIMEOUT if it takes too long).
+result = diffusr.wait_for(job["id"], timeout=600)
+if result["status"] == "SUCCEEDED":
+    print(result["output"]["url"])
+else:
+    print(result["status"], result.get("error"))
+print(result["charge"])  # quoted_credits, charged_credits, final
+```
+
+### Callbacks instead of polling
+
+Pass `callback_url` (https, public) and we POST one signed event when the job
+ends. Verify it with your signing secret (`diffusr.get_callback_secret()["secret"]`):
+
+```python
+from diffusr import Diffusr
+
+# Flask: use the RAW body, not the parsed one.
+@app.post("/diffusr")
+def hook():
+    raw = request.get_data(as_text=True)
+    if not Diffusr.verify_callback(raw, request.headers, os.environ["DIFFUSR_WHSEC"]):
+        return "", 400
+    event = json.loads(raw)  # {id, type: "result.finished", data: <result>}
+    return "", 200  # any 2xx; drop repeats of event["id"]
+```
+
+`verify_callback` implements [Standard Webhooks](https://www.standardwebhooks.com):
+constant-time compare, two signatures after a secret rotation, a 5-minute
+timestamp window, `whsec_` prefix handled.
+
+## Methods
+
+| Method | REST |
+|---|---|
+| `make_video`, `make_image`, `edit_image`, `recast`, `make_music`, `creator_video`, `run_template` `(**body)` | `POST /{tool}` |
+| `get_result(id)`, `list_results(limit=)`, `cancel(id)` (stops queued work; a step already generating may finish and be charged: check `result["charge"]`) | `GET /results/{id}`, `GET /results`, `POST /results/{id}/cancel` |
+| `wait_for(id, timeout=, interval=, on_poll=)` | polls `GET /results/{id}` |
+| `upload_file(path_or_bytes, content_type=)`, `upload_from_url(url)` | `POST /uploads` + signed `PUT` |
+| `list_models(kind=)`, `list_templates()` | `GET /models`, `GET /templates` |
+| `list_callbacks(limit=, cursor=)`, `retry_callback(event_id)`, `get_callback_secret()`, `rotate_callback_secret()` | `/callbacks…` |
+| `Diffusr.verify_callback(raw_body, headers, secret)` | |
+
+`run_template` takes one flat body: `template="<id from list_templates()>"` plus the fields that
+template takes (`mode`, `prompt`, `pictures`, `image_urls`, `product_image_url`, `script`, `place`,
+`people`, `setup`, `resolution`):
+
+```python
+diffusr.run_template(template="tpl-ugc-talking-head", script="Hi!", people=[{"name": "Mia", "image_url": "https://…"}], dry_run=True)
+```
+
+`dry_run=True` on any make call answers with the price only. Pass
+`idempotency_key="…"` to use your own key.
+
+## Retries and errors
+
+- Every request times out after 60 s (`Diffusr(timeout=...)`) with a `TIMEOUT` error.
+- `GET`s (and so `wait_for`) retry on 429, 500, 502, 503, 504, network errors
+  and timeouts with backoff, honouring `Retry-After` (waits over 30 s are not
+  slept: the error is raised).
+- Make calls retry on 429, 503, network errors and timeouts only, **with the
+  same Idempotency-Key**.
+- Every failure is a `DiffusrError`:
+
+```python
+from diffusr import DiffusrError
+
+try:
+    diffusr.make_video(prompt="…")
+except DiffusrError as e:
+    print(e.status, e.code, e.message, e.request_id, e.retry_after)
+    # e.body has the extras: issues, field, budget…
+```
+
+Codes are the API's (`RATE_LIMITED`, `BUDGET_EXCEEDED`, `INSUFFICIENT_CREDITS`…).
+The SDK adds `NETWORK_ERROR`, `TIMEOUT`, `WAIT_TIMEOUT`, `UPLOAD_FAILED`,
+`CONTENT_TYPE_REQUIRED` and `MISSING_API_KEY`. Handle codes you don't know.
+
+## Docs
+
+Full API reference, prices and agent guides: https://diffusr.ai/docs
+
+MIT licensed.

diffusr-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+diffusr/__init__.py,sha256=GJu0H3cqXBbB8VunnZqrzq0rqAGhOGSlEpP0i1Fasvo,516
+diffusr/_client.py,sha256=MMyVDdmff1nIQSuiFKf_9c0sJDITUSY-fkNQjodgKyI,12005
+diffusr/_errors.py,sha256=YWrBDO9lzEqHgckTc66uLcpETfvbWmeyhmB2rFVJkzc,1184
+diffusr/_verify.py,sha256=d5pNG-qf3CtXWuI5Ejm614kB96o0shMPE9xa34s_ZgM,1954
+diffusr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffusr-0.1.0.dist-info/METADATA,sha256=XzZOenx6fc7hiOEjMPj-vlsA6LzXjNtfus3xZDAC76A,5151
+diffusr-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+diffusr-0.1.0.dist-info/licenses/LICENSE,sha256=1l1mtdgkeKxmibt4kNGlmLRfZhUQWNx-rJB0lQD_dWY,1064
+diffusr-0.1.0.dist-info/RECORD,,

diffusr-0.1.0.dist-info/WHEEL

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

diffusr-0.1.0.dist-info/licenses/LICENSE

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