steadycron 0.1.0__py3-none-any.whl

steadycron/__init__.py

@@ -0,0 +1,61 @@
+"""SteadyCron code-monitoring SDK for Python.
+
+Quickstart::
+
+    import steadycron
+
+    steadycron.api_key = "sc_ro_..."  # read-only key, or set STEADYCRON_API_KEY env var
+
+    @steadycron.job("nightly-db-backup")
+    def backup():
+        ...   # start on entry, success on return, fail (+re-raise) on exception
+
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+# ── Module-level configuration (set directly or via configure()) ──────────────
+api_key: Optional[str] = None
+api_url: str = "https://api.steadycron.com"
+ping_url: str = "https://ping.steadycron.com"
+environment: Optional[str] = None
+capture_errors: bool = False
+ping_timeout: float = 5.0
+resolve_cache_ttl: float = 3600.0
+monitors: dict[str, str] = {}  # key → direct ping token (hardened path)
+
+# ── Public API ────────────────────────────────────────────────────────────────
+from ._config import configure
+from ._exceptions import (
+    AmbiguousJobKeyError,
+    ConfigurationError,
+    InvalidMonitorKindError,
+    MonitorNotFoundError,
+)
+from ._monitor import Monitor, job, monitor
+from ._resolve import clear_cache
+
+__all__ = [
+    # Config
+    "api_key",
+    "api_url",
+    "ping_url",
+    "environment",
+    "capture_errors",
+    "ping_timeout",
+    "resolve_cache_ttl",
+    "monitors",
+    "configure",
+    # Core API
+    "Monitor",
+    "job",
+    "monitor",
+    # Exceptions
+    "MonitorNotFoundError",
+    "AmbiguousJobKeyError",
+    "InvalidMonitorKindError",
+    "ConfigurationError",
+    # Utils
+    "clear_cache",
+]

steadycron/_config.py

@@ -0,0 +1,70 @@
+"""Module-level configuration and the configure() helper."""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+# ── Module-level settings ────────────────────────────────────────────────────
+
+api_key: Optional[str] = None
+api_url: str = "https://api.steadycron.com"
+ping_url: str = "https://ping.steadycron.com"
+environment: Optional[str] = None
+capture_errors: bool = False
+ping_timeout: float = 5.0
+resolve_cache_ttl: float = 3600.0
+monitors: dict[str, str] = {}  # key → direct ping token (hardened path)
+
+
+def configure(
+    *,
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    ping_url: Optional[str] = None,
+    environment: Optional[str] = None,
+    capture_errors: Optional[bool] = None,
+    ping_timeout: Optional[float] = None,
+    resolve_cache_ttl: Optional[float] = None,
+) -> None:
+    """Set one or more configuration values at once."""
+    import steadycron as _mod
+
+    if api_key is not None:
+        _mod.api_key = api_key
+    if api_url is not None:
+        _mod.api_url = api_url
+    if ping_url is not None:
+        _mod.ping_url = ping_url
+    if environment is not None:
+        _mod.environment = environment
+    if capture_errors is not None:
+        _mod.capture_errors = capture_errors
+    if ping_timeout is not None:
+        _mod.ping_timeout = ping_timeout
+    if resolve_cache_ttl is not None:
+        _mod.resolve_cache_ttl = resolve_cache_ttl
+
+
+def effective_api_key() -> Optional[str]:
+    """Return the configured API key, falling back to STEADYCRON_API_KEY env var."""
+    import steadycron as _mod
+
+    return _mod.api_key or os.environ.get("STEADYCRON_API_KEY")
+
+
+def effective_api_url() -> str:
+    import steadycron as _mod
+
+    return _mod.api_url or os.environ.get("STEADYCRON_API_URL") or "https://api.steadycron.com"
+
+
+def effective_ping_url() -> str:
+    import steadycron as _mod
+
+    return _mod.ping_url or os.environ.get("STEADYCRON_PING_URL") or "https://ping.steadycron.com"
+
+
+def effective_environment() -> Optional[str]:
+    import steadycron as _mod
+
+    return _mod.environment or os.environ.get("STEADYCRON_ENVIRONMENT")

steadycron/_exceptions.py

@@ -0,0 +1,57 @@
+"""Exceptions raised by the SteadyCron SDK."""
+from __future__ import annotations
+
+
+class MonitorNotFoundError(Exception):
+    """Raised when a job key is not found (resolve returned 404).
+
+    This is a developer/configuration error — verify the key matches
+    a job in the SteadyCron Dashboard.
+    """
+
+    def __init__(self, key: str) -> None:
+        self.key = key
+        super().__init__(
+            f"Job key '{key}' was not found. "
+            "Verify the key matches a job in the SteadyCron Dashboard."
+        )
+
+
+class AmbiguousJobKeyError(Exception):
+    """Raised when a key matches more than one job in the account (resolve returned 409).
+
+    Keys must be unique within the account for code monitoring to work.
+    """
+
+    def __init__(self, key: str) -> None:
+        self.key = key
+        super().__init__(
+            f"Job key '{key}' is ambiguous — it matches more than one job "
+            "in the account. Make the key unique in the SteadyCron Dashboard."
+        )
+
+
+class InvalidMonitorKindError(Exception):
+    """Raised when the resolved job has kind 'http' rather than 'heartbeat'.
+
+    HTTP jobs are executed server-side and cannot be pinged from user code.
+    """
+
+    def __init__(self, key: str, kind: str) -> None:
+        self.key = key
+        self.kind = kind
+        super().__init__(
+            f"Job '{key}' has kind '{kind}'. "
+            "Only 'heartbeat' jobs can be pinged from code."
+        )
+
+
+class ConfigurationError(Exception):
+    """Raised when neither a direct token nor an API key is available for a key."""
+
+    def __init__(self, key: str) -> None:
+        self.key = key
+        super().__init__(
+            f"No ping token or API key is configured for job '{key}'. "
+            "Either set steadycron.api_key or add an entry to steadycron.monitors."
+        )

steadycron/_monitor.py

@@ -0,0 +1,122 @@
+"""Monitor class, @job decorator, and monitor() context manager."""
+from __future__ import annotations
+
+import functools
+import uuid
+from contextlib import contextmanager
+from typing import Any, Callable, Generator, Optional, TypeVar
+
+from ._ping import send_ping
+from ._resolve import resolve_token
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+class Monitor:
+    """Represents a named SteadyCron monitor for manual ping control."""
+
+    def __init__(self, key: str) -> None:
+        self.key = key
+
+    def ping(
+        self,
+        state: str = "success",
+        message: Optional[str] = None,
+    ) -> None:
+        """Send a ping.
+
+        Args:
+            state: One of ``"start"``, ``"success"`` (default), or ``"fail"``.
+            message: Optional error message; sent only when ``state="fail"``
+                     (or always if explicitly provided).
+        """
+        import steadycron as _mod
+
+        token = resolve_token(self.key)
+        suffix = state if state != "success" else None
+        ping_url = (_mod.ping_url or __import__("os").environ.get("STEADYCRON_PING_URL") or "https://ping.steadycron.com")
+        env = _mod.environment or __import__("os").environ.get("STEADYCRON_ENVIRONMENT")
+        send_ping(
+            token,
+            suffix,
+            env=env,
+            message=message if (state == "fail" or message is not None) else None,
+            timeout=_mod.ping_timeout,
+            ping_url_base=ping_url,
+        )
+
+
+def _run_tracked(key: str, fn: Callable[..., Any], args: Any, kwargs: Any) -> Any:
+    """Core tracking logic shared by the decorator and context manager."""
+    import steadycron as _mod
+
+    token = resolve_token(key)
+    run_id = uuid.uuid4().hex
+    ping_url = (_mod.ping_url or __import__("os").environ.get("STEADYCRON_PING_URL") or "https://ping.steadycron.com")
+    env = _mod.environment or __import__("os").environ.get("STEADYCRON_ENVIRONMENT")
+    timeout = _mod.ping_timeout
+
+    send_ping(token, "start", env=env, run_id=run_id, timeout=timeout, ping_url_base=ping_url)
+    try:
+        result = fn(*args, **kwargs)
+        send_ping(token, None, env=env, run_id=run_id, timeout=timeout, ping_url_base=ping_url)
+        return result
+    except Exception:
+        msg: Optional[str] = None
+        if _mod.capture_errors:
+            import sys
+            exc = sys.exc_info()[1]
+            msg = str(exc) if exc is not None else None
+        send_ping(token, "fail", env=env, run_id=run_id, message=msg, timeout=timeout, ping_url_base=ping_url)
+        raise
+
+
+def job(key: str) -> Callable[[F], F]:
+    """Decorator: wrap a function with start/success/fail pings.
+
+    Usage::
+
+        @steadycron.job("nightly-db-backup")
+        def backup():
+            ...
+    """
+
+    def decorator(fn: F) -> F:
+        @functools.wraps(fn)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return _run_tracked(key, fn, args, kwargs)
+
+        return wrapper  # type: ignore[return-value]
+
+    return decorator
+
+
+@contextmanager
+def monitor(key: str) -> Generator[Monitor, None, None]:
+    """Context manager: wrap a block with start/success/fail pings.
+
+    Usage::
+
+        with steadycron.monitor("nightly-db-backup"):
+            run_backup()
+    """
+    import steadycron as _mod
+
+    token = resolve_token(key)
+    run_id = uuid.uuid4().hex
+    ping_url = (_mod.ping_url or __import__("os").environ.get("STEADYCRON_PING_URL") or "https://ping.steadycron.com")
+    env = _mod.environment or __import__("os").environ.get("STEADYCRON_ENVIRONMENT")
+    timeout = _mod.ping_timeout
+
+    send_ping(token, "start", env=env, run_id=run_id, timeout=timeout, ping_url_base=ping_url)
+    try:
+        yield Monitor(key)
+        send_ping(token, None, env=env, run_id=run_id, timeout=timeout, ping_url_base=ping_url)
+    except Exception:
+        msg2: Optional[str] = None
+        if _mod.capture_errors:
+            import sys
+            exc2 = sys.exc_info()[1]
+            msg2 = str(exc2) if exc2 is not None else None
+        send_ping(token, "fail", env=env, run_id=run_id, message=msg2, timeout=timeout, ping_url_base=ping_url)
+        raise

steadycron/_ping.py

@@ -0,0 +1,68 @@
+"""Ping transport: fire-and-forget HTTP pings, never raise."""
+from __future__ import annotations
+
+import logging
+import socket
+import urllib.error
+import urllib.request
+from typing import Optional
+from urllib.parse import urlencode
+
+_logger = logging.getLogger("steadycron")
+
+_ERROR_MESSAGE_MAX_BYTES = 1024
+
+
+def send_ping(
+    token: str,
+    suffix: Optional[str] = None,
+    *,
+    env: Optional[str] = None,
+    run_id: Optional[str] = None,
+    message: Optional[str] = None,
+    timeout: float = 5.0,
+    ping_url_base: str = "https://ping.steadycron.com",
+) -> None:
+    """Send a single ping. All errors are swallowed — never raises."""
+    base = ping_url_base.rstrip("/")
+    path = f"/{token}/{suffix}" if suffix else f"/{token}"
+    url = base + path
+
+    qs_parts: dict[str, str] = {}
+    if env:
+        qs_parts["env"] = env
+    if run_id:
+        qs_parts["run_id"] = run_id
+    if qs_parts:
+        url += "?" + urlencode(qs_parts)
+
+    body: Optional[bytes] = None
+    if message:
+        truncated = _truncate_utf8(message, _ERROR_MESSAGE_MAX_BYTES)
+        body = truncated.encode("utf-8")
+
+    req = urllib.request.Request(url, data=body or b"", method="POST")
+    if body:
+        req.add_header("Content-Type", "text/plain; charset=utf-8")
+
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            status = resp.status
+            if status >= 300:
+                _logger.debug("SteadyCron ping to %s returned HTTP %d.", url, status)
+    except TimeoutError:
+        _logger.warning("SteadyCron ping to %s timed out after %.1fs.", url, timeout)
+    except socket.timeout:
+        _logger.warning("SteadyCron ping to %s timed out after %.1fs.", url, timeout)
+    except urllib.error.URLError as exc:
+        _logger.warning("SteadyCron ping to %s failed: %s", url, exc.reason)
+    except Exception as exc:  # noqa: BLE001
+        _logger.warning("SteadyCron ping to %s failed unexpectedly: %s", url, exc)
+
+
+def _truncate_utf8(text: str, max_bytes: int) -> str:
+    encoded = text.encode("utf-8")
+    if len(encoded) <= max_bytes:
+        return text
+    truncated = encoded[: max_bytes - 3].decode("utf-8", errors="ignore")
+    return truncated + "..."

steadycron/_resolve.py

@@ -0,0 +1,97 @@
+"""Token resolution: resolve a monitor key to its ping token via the API."""
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+import urllib.error
+import urllib.request
+from typing import Optional
+from urllib.parse import urlencode
+
+from ._exceptions import (
+    AmbiguousJobKeyError,
+    ConfigurationError,
+    InvalidMonitorKindError,
+    MonitorNotFoundError,
+)
+
+_logger = logging.getLogger("steadycron")
+
+# Cache: key → (token, expires_at_unix)
+_cache: dict[str, tuple[str, float]] = {}
+_cache_lock = threading.Lock()
+
+
+def _cache_get(key: str) -> Optional[str]:
+    with _cache_lock:
+        entry = _cache.get(key)
+        if entry is not None and entry[1] > time.monotonic():
+            return entry[0]
+    return None
+
+
+def _cache_set(key: str, token: str, ttl: float) -> None:
+    with _cache_lock:
+        _cache[key] = (token, time.monotonic() + ttl)
+
+
+def clear_cache() -> None:
+    """Clear the entire resolution cache (useful in tests)."""
+    with _cache_lock:
+        _cache.clear()
+
+
+def resolve_token(key: str) -> str:
+    """Return the ping token for *key*, using cache or the resolve endpoint.
+
+    Raises:
+        ConfigurationError: if neither a direct token nor an API key is available.
+        MonitorNotFoundError: if the key is not found (404).
+        AmbiguousJobKeyError: if the key matches multiple monitors (409).
+        InvalidMonitorKindError: if the resolved monitor is not a heartbeat.
+    """
+    import steadycron as _mod
+
+    # 1. Direct token map (hardened path).
+    direct = _mod.monitors.get(key)
+    if direct:
+        return direct
+
+    # 2. Cache.
+    cached = _cache_get(key)
+    if cached is not None:
+        return cached
+
+    # 3. Resolve via API key.
+    api_key = _mod.api_key or __import__("os").environ.get("STEADYCRON_API_KEY")
+    if not api_key:
+        raise ConfigurationError(key)
+
+    api_url = (_mod.api_url or __import__("os").environ.get("STEADYCRON_API_URL") or "https://api.steadycron.com").rstrip("/")
+    params = urlencode({"key": key})
+    url = f"{api_url}/api/monitors/resolve?{params}"
+
+    req = urllib.request.Request(url, headers={"Authorization": f"Bearer {api_key}"})
+    try:
+        with urllib.request.urlopen(req) as resp:
+            body = json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        if exc.code == 404:
+            raise MonitorNotFoundError(key) from exc
+        if exc.code == 409:
+            raise AmbiguousJobKeyError(key) from exc
+        raise RuntimeError(f"Resolve returned HTTP {exc.code} for key '{key}'.") from exc
+
+    kind = body.get("kind", "")
+    if kind != "heartbeat":
+        raise InvalidMonitorKindError(key, kind)
+
+    ping_token: Optional[str] = body.get("ping_token")
+    if not ping_token:
+        raise RuntimeError(f"Resolve response missing ping_token for key '{key}'.")
+
+    ttl = _mod.resolve_cache_ttl
+    _cache_set(key, ping_token, ttl)
+    return ping_token

steadycron-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: steadycron
+Version: 0.1.0
+Summary: Code-monitoring SDK for SteadyCron — wrap your scheduled jobs with @steadycron.job to send start/success/fail pings automatically.
+Project-URL: Homepage, https://steadycron.com
+Project-URL: Repository, https://github.com/steadycron/steadycron-python
+Project-URL: Bug Tracker, https://github.com/steadycron/steadycron-python/issues
+Author: SteadyCron
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Software Development :: Libraries
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# SteadyCron Python SDK
+
+`steadycron` is the official Python code-monitoring SDK for [SteadyCron](https://steadycron.com).
+
+Wrap your scheduled jobs with `@steadycron.job` and SteadyCron will:
+- Know when a job **started**, **succeeded**, or **failed**
+- Alert you when a job **doesn't run** on time (missed heartbeat)
+- Detect **stuck runs** that start but never finish
+
+The monitor must already exist — create it in the Dashboard, via YAML manifest, or Terraform.
+The SDK never creates monitors. For a fully code-driven workflow, declare the monitor in your
+Terraform configuration or YAML manifest and reference it from your application by key:
+the cron schedule, alert rules, and SDK instrumentation all live in the same repository.
+
+---
+
+## Installation
+
+```bash
+pip install steadycron
+```
+
+No runtime dependencies — uses Python's standard library only.
+
+---
+
+## Quick start
+
+```python
+import steadycron
+
+steadycron.api_key = "sc_ro_..."  # read-only key; or set STEADYCRON_API_KEY env var
+
+@steadycron.job("nightly-db-backup")
+def backup():
+    run_backup()   # start on entry, success on return, fail (+re-raise) on exception
+```
+
+### Context manager
+
+```python
+with steadycron.monitor("nightly-db-backup"):
+    run_backup()
+```
+
+### Manual pings
+
+```python
+m = steadycron.Monitor("nightly-db-backup")
+m.ping()                           # bare success heartbeat
+m.ping(state="start")
+m.ping(state="fail", message="disk full")
+```
+
+---
+
+## Authentication
+
+The SDK uses a **read-only** API key to resolve monitor keys to ping tokens at startup. Create one in:
+
+**SteadyCron Dashboard → Settings → API keys → New key → Scope: Read-only**
+
+Set it via:
+- Environment variable: `STEADYCRON_API_KEY=sc_ro_...`
+- Module attribute: `steadycron.api_key = "sc_ro_..."`
+- `steadycron.configure(api_key="sc_ro_...")`
+
+---
+
+## Configuration
+
+```python
+import steadycron
+
+steadycron.configure(
+    api_key="sc_ro_...",
+    environment="production",   # optional — sent on every ping
+    capture_errors=True,        # include exception message on fail pings (default False)
+    ping_timeout=5.0,           # seconds (default 5)
+    resolve_cache_ttl=3600.0,   # seconds (default 3600 = 1 hour)
+)
+```
+
+| Setting | Default | Env var fallback |
+|---|---|---|
+| `api_key` | `None` | `STEADYCRON_API_KEY` |
+| `api_url` | `https://api.steadycron.com` | `STEADYCRON_API_URL` |
+| `ping_url` | `https://ping.steadycron.com` | `STEADYCRON_PING_URL` |
+| `environment` | `None` | `STEADYCRON_ENVIRONMENT` |
+| `capture_errors` | `False` | — |
+| `ping_timeout` | `5.0` s | — |
+| `resolve_cache_ttl` | `3600.0` s | — |
+
+---
+
+## How it works
+
+1. On first use, the SDK calls `GET /api/monitors/resolve?key=<your-key>` with the read-only API key to retrieve the ping token. The token is cached for 1 hour (configurable).
+2. All pings are fire-and-forget: a bounded `ping_timeout` is applied; any error is logged via `logging.getLogger("steadycron")` at WARNING and discarded. They never raise.
+3. Resolution errors (404 unknown key, 409 ambiguous key, wrong kind) raise immediately — they indicate misconfiguration.
+4. On exception, a `fail` ping is sent and the **original exception is re-raised unchanged**.
+
+---
+
+## Direct / token mode (hardened path)
+
+If you cannot use API key resolution (e.g. air-gapped environments), set the ping token directly:
+
+```python
+steadycron.monitors = {"nightly-db-backup": "hRkmWz8oZtlMFzvTAUdnRE"}
+```
+
+The token is visible via **Job detail → Code monitoring → Reveal ping token** in the Dashboard.
+
+---
+
+## Reliability contract
+
+- **Ping failures are never raised.** A transport error, timeout, or non-2xx response is logged and discarded.
+- **Resolution errors always raise.** A 404 or 409 from the resolve endpoint raises on first use; fix the key or remove the decorator.
+- **Original exceptions pass through unchanged.** The decorator and context manager do not wrap exceptions.
+- **No runtime dependencies.** The SDK uses `urllib.request` from the standard library.
+
+---
+
+## License
+
+MIT

steadycron-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+steadycron/__init__.py,sha256=YOD0touQBH4TBWjHZFjSIE8e5j96ftR4KvqucYxK4rg,1682
+steadycron/_config.py,sha256=szP8GE_rKQVYr4EfIES8G7SFDaV8U_P_ex9_QJNI2L4,2237
+steadycron/_exceptions.py,sha256=DG4NBjNijcncslmnku90mVnG1EY2BB5pDvWxli0jqX0,1833
+steadycron/_monitor.py,sha256=BP5AG8xLd90WTfcty2-33X-Gpsgv99gHzkGgCDkgkjo,4136
+steadycron/_ping.py,sha256=cLPG8bS3zKWB5FAjkwSbY8E7aJ43wi4zpLgqV0r6VY4,2211
+steadycron/_resolve.py,sha256=wBQ3pJ9ht2UuZDde5_bE_KXtEQXPNGOKt2fPD-nKRQE,2965
+steadycron/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+steadycron-0.1.0.dist-info/METADATA,sha256=boODK6T9ZLqUXg90zY0UR985W3wVA44MdbiIeNemtQA,5081
+steadycron-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+steadycron-0.1.0.dist-info/licenses/LICENSE,sha256=sAzhUjSXWkDJKX4EeGmAHvyyMa6A6fFbVhOYUsfu5yo,1067
+steadycron-0.1.0.dist-info/RECORD,,

steadycron-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

steadycron-0.1.0.dist-info/licenses/LICENSE

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