cygnet-orm 1.0.0__tar.gz

cygnet_orm-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,311 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  # Weekly audit run (S17).  Monday 04:00 UTC is a low-contention slot
+  # — post-weekend, before East-Coast business hours — so CVE findings
+  # land in inboxes before any reviewer is on shift.  The audit job
+  # runs on this trigger; the other jobs are gated below with
+  # `if: github.event_name != 'schedule'` so the cron doesn't burn CI
+  # minutes re-running unit / integration / build / bench against
+  # unchanged code.
+  schedule:
+    - cron: "0 4 * * 1"
+
+# Opt every JS-based action into Node 24 ahead of the September 2026
+# Node 20 removal.  GitHub honours this env var on the runner and
+# applies it to actions/checkout, actions/setup-python, codecov, etc.
+# without us needing to bump each action's major version individually.
+# Once the actions ship Node-24-native versions, this can come out.
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
+jobs:
+
+  # ── Unit tests (no database) ──────────────────────────────────────────────
+
+  unit:
+    name: Unit tests — Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    # Skip on the weekly schedule (audit-only trigger — see top-level
+    # `on:`).  Code hasn't changed since the last push, so re-running
+    # unit tests would be pure CI cost.
+    if: github.event_name != 'schedule'
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # OQ3 migration: uv is now canonical (justfile + ci.yml both run
+      # through it).  setup-uv@v6 installs uv, installs the matrix
+      # Python via uv, and caches the global uv download cache keyed on
+      # uv.lock so re-runs against unchanged deps are near-instant.
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+
+      - name: Install dependencies
+        # --locked: fail loudly if uv.lock drifted from pyproject.toml
+        # (CI should never silently resolve a different graph than what
+        # was committed).  --extra dev pulls in pytest / ruff / mypy /
+        # psycopg.
+        run: uv sync --locked --extra dev
+
+      - name: Format check
+        run: uv run ruff format --check cygnet tests
+
+      - name: Lint
+        run: uv run ruff check cygnet tests
+
+      - name: Type check
+        run: uv run mypy cygnet
+
+      - name: Unit tests
+        run: |
+          uv run pytest tests/ --ignore=tests/integration \
+            -v \
+            --cov=cygnet \
+            --cov-report=xml \
+            --cov-report=term-missing
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v4
+        if: matrix.python-version == '3.12'
+        with:
+          files: coverage.xml
+          fail_ci_if_error: false
+
+  # ── Integration tests (live PostgreSQL via Docker service) ────────────────
+
+  integration:
+    name: Integration tests — PG ${{ matrix.pg-version }}
+    runs-on: ubuntu-latest
+    if: github.event_name != 'schedule'
+    strategy:
+      fail-fast: false
+      matrix:
+        pg-version: ["14", "15", "16", "17", "18"]
+
+    services:
+      postgres:
+        image: postgres:${{ matrix.pg-version }}-alpine
+        env:
+          POSTGRES_USER: cygnet
+          POSTGRES_PASSWORD: cygnet
+          POSTGRES_DB: cygnet_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U cygnet"
+          --health-interval 5s
+          --health-timeout 3s
+          --health-retries 10
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --locked --extra dev
+
+      - name: Integration tests
+        env:
+          CYGNET_TEST_DSN: postgresql://cygnet:cygnet@localhost:5432/cygnet_test
+        run: |
+          uv run pytest tests/integration \
+            -v \
+            -m integration \
+            --cov=cygnet \
+            --cov-report=xml
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v4
+        if: matrix.pg-version == '16'
+        with:
+          files: coverage.xml
+          fail_ci_if_error: false
+
+  # ── Build check ───────────────────────────────────────────────────────────
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    needs: [unit, integration]
+    if: github.event_name != 'schedule'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+          enable-cache: true
+
+      # `uvx --from hatch hatch build` runs hatch in an ephemeral
+      # isolated environment — no need to install hatch into the
+      # project venv (the build job doesn't need the project's deps).
+      - name: Build wheel and sdist
+        run: uvx --from hatch hatch build
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  # ── Dependency audit ──────────────────────────────────────────────────────
+  # pip-audit scans installed dependencies (psycopg[binary] and dev tools)
+  # against the PyPI Advisory Database.  Runs on every push/PR so a CVE
+  # surface is caught before release.  Non-blocking exit so an advisory
+  # doesn't immediately wedge unrelated PRs — review the job log instead.
+
+  audit:
+    name: Dependency audit
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+          enable-cache: true
+
+      - name: Install dependencies
+        # pip-audit scans the project venv, so it needs to be installed
+        # alongside the project deps (not via uvx, which would isolate
+        # it from what we want to audit).
+        run: |
+          uv sync --locked --extra dev
+          uv pip install pip-audit
+
+      - name: Run pip-audit
+        # --skip-editable skips the local cygnet-orm editable install (it
+        # isn't on PyPI, so it can't be audited).  Without --strict the
+        # skipped editable is a notice rather than a hard failure, so the
+        # job exits non-zero ONLY when pip-audit actually finds a CVE in
+        # a dep — which is the point.  The previous `--strict || true`
+        # combo was contradictory: --strict failed on the editable skip,
+        # and `|| true` swallowed both that AND any real CVE.
+        run: uv run pip-audit --skip-editable
+
+  # ── Benchmarks (advisory) ─────────────────────────────────────────────────
+  # Runs the perf suite against a fresh PG instance and uploads the
+  # JSON output as an artifact.  Advisory-only: a regression doesn't
+  # block merge — the artifact (and the in-job summary table) are the
+  # signal.  PR comparisons against main's baseline are a separate
+  # follow-up; today the artifact is the source of truth.
+
+  bench:
+    name: Benchmarks (advisory)
+    runs-on: ubuntu-latest
+    needs: [unit, integration]
+    if: github.event_name != 'schedule'
+    # Job continues even if benchmarks regress or hit a transient
+    # variance issue; the artifact upload still happens via if: always().
+    continue-on-error: true
+
+    services:
+      postgres:
+        image: postgres:16-alpine
+        env:
+          POSTGRES_USER: cygnet
+          POSTGRES_PASSWORD: cygnet
+          POSTGRES_DB: cygnet_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U cygnet"
+          --health-interval 5s
+          --health-timeout 3s
+          --health-retries 10
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --locked --extra dev --extra bench
+
+      - name: Run benchmarks
+        env:
+          CYGNET_TEST_DSN: postgresql://cygnet:cygnet@localhost:5432/cygnet_test
+        run: |
+          uv run pytest bench/ \
+            --benchmark-only \
+            --benchmark-json=bench-result.json \
+            --benchmark-columns=median,min,max,iqr,ops \
+            --benchmark-sort=name
+
+      - name: Summary table in job output
+        if: always()
+        run: |
+          if [ -f bench-result.json ]; then
+            echo "## Benchmark results" >> $GITHUB_STEP_SUMMARY
+            uv run python -m bench._summary bench-result.json >> $GITHUB_STEP_SUMMARY
+          fi
+
+      # ── PR-only: pull main's last bench artifact and diff ──────────────
+      # On pull_request events, fetch the most recent successful main-branch
+      # bench-results artifact and emit a per-benchmark delta against the
+      # current run.  Graceful when the baseline is missing (first PR after
+      # a fresh repo, retention expired, etc.) — the `|| true` guarantees
+      # the step doesn't fail the job, in keeping with the advisory-only
+      # contract.
+
+      - name: Download main baseline (PR only)
+        if: github.event_name == 'pull_request'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          LATEST=$(gh run list \
+            --branch main \
+            --workflow CI \
+            --status success \
+            --limit 1 \
+            --json databaseId \
+            --jq '.[0].databaseId' || echo "")
+          if [ -n "$LATEST" ]; then
+            mkdir -p baseline
+            gh run download "$LATEST" --name bench-results --dir baseline \
+              --repo "${{ github.repository }}" \
+              || echo "no baseline artifact found"
+          fi
+
+      - name: Compare against baseline (PR only)
+        if: github.event_name == 'pull_request'
+        run: |
+          if [ -f baseline/bench-result.json ] && [ -f bench-result.json ]; then
+            echo "" >> $GITHUB_STEP_SUMMARY
+            echo "## Δ vs main baseline" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+            uv run python -m bench._compare \
+              baseline/bench-result.json \
+              bench-result.json \
+              >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+            echo "_Bold deltas indicate >15% slower than baseline; CI runner noise typically falls within ±10%._" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "_No main baseline available for comparison (first run, expired artifact, or upstream missing)._" >> $GITHUB_STEP_SUMMARY
+          fi
+
+      - name: Upload benchmark JSON
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: bench-results
+          path: bench-result.json

cygnet_orm-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,55 @@
+name: Publish to PyPI
+
+# Trusted publishing (OIDC): no API token is stored anywhere. The job mints a
+# short-lived OIDC identity token that PyPI exchanges for a one-shot upload
+# credential, and PEP 740 Sigstore attestations linking the artifacts to this
+# exact workflow run are generated automatically.
+#
+# Publishing a GitHub Release is the deliberate human gate on an irreversible
+# step: PyPI is append-only, so a given name==version (cygnet-orm==1.0.0) can
+# never be re-uploaded or replaced — only yanked. Creating the release is the
+# trigger; nothing publishes on a plain push.
+on:
+  release:
+    types: [published]
+
+# Match ci.yml: opt JS-based actions into Node 24 ahead of the Node 20 removal.
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
+jobs:
+  publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+
+    # The `pypi` environment must match the one named in the PyPI pending
+    # publisher. Scoping the job to an environment also lets you add required
+    # reviewers / branch rules to gate the publish in repo settings.
+    environment:
+      name: pypi
+      url: https://pypi.org/p/cygnet-orm
+
+    permissions:
+      # REQUIRED for trusted publishing — lets the job request the OIDC token.
+      # Without it there is no credential to exchange and the upload fails.
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+          enable-cache: true
+
+      # Build with the project's own backend (hatchling) via uv, so the release
+      # artifacts are produced exactly like `uv build` locally and the CI build
+      # job — sdist + wheel into dist/.
+      - name: Build sdist + wheel
+        run: uv build
+
+      # The blessed PyPA action consumes dist/ and uploads via trusted
+      # publishing. No `with: password:` — the OIDC token is the credential,
+      # and attestations are on by default.
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

cygnet_orm-1.0.0/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+.venv/
+*.egg
+
+# Environment
+.env
+
+# Test / coverage
+.pytest_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+# Mypy
+.mypy_cache/
+
+# Ruff
+.ruff_cache/
+
+# macOS
+.DS_Store
+
+# Editor
+.idea/
+.vscode/
+*.swp
+
+# Codebase-memory graph artifacts (ADR notes; graph DB lives in central store)
+.codebase-memory/
+
+# Local working artifacts: code-review outputs and superpowers plans/specs.
+# Design rationale worth keeping has been folded into THEORY.md.
+docs/

cygnet_orm-1.0.0/ARCHITECTURE.md

@@ -0,0 +1,97 @@
+# Architecture
+
+Cygnet is a small, async, **PostgreSQL-only** ORM that maps plain dataclasses to
+tables and keeps SQL visible. The one fact to hold first: there is no query DSL
+behind which SQL hides — every query verb builds an AST of **`SQLRenderable`**
+nodes that render, in a single left-to-right pass over one shared params list, to
+parameterised PG SQL (`$1, $2, …`). Almost everything else falls out of that.
+
+For *why* any of this is shaped the way it is, see [THEORY.md](THEORY.md). For
+install/build/test/usage, see [README.md](README.md). Open issues are tracked in the
+project's [GitHub issues](https://github.com/Xof/cygnet/issues).
+
+## Component map
+
+Authoritative module enumeration. Dependency direction is strictly downward at
+module load: `__init__` → `builders` → `executor` →
+`proxy`/`cte`/`predicate`/`expression` → `meta` → `annotations`, with no cycles.
+Would-be cycles are broken by *deferred* (in-function) imports instead of
+module-load ones — notably `executor.run_save` → `builders` (the save→builder
+edge) and `predicate.__invert__` → `expression.PrefixOp` (the reverse of
+`expression`'s module-load import of `Predicate`, needed only for `~`).
+
+| Module | Responsibility | Key symbols |
+|---|---|---|
+| `__init__.py` | Public API surface; query-verb factories | `Table`, `SELECT`/`INSERT`/`UPDATE`/`DELETE`/`TRUNCATE`, `get`/`save`/`create`/`follow`, `lit`/`op`/`ops`/`exists`, `transaction`, `cte`/`recursive_cte`/`lateral` |
+| `annotations.py` | Passive metadata markers, introspected by `meta` | `DBKey`, `AppKey`, `Column`, `ForeignKey`, `@table` |
+| `meta.py` | Dataclass → `TableMeta`/`FieldMeta` introspection | `TableMeta` (WeakValueDict-cached per class) |
+| `proxy.py` | Attribute access → predicate AST | `TableProxy[T]`, `ColumnProxy[FT]` (per-class singletons; `.AS()` bypasses cache) |
+| `predicate.py` | Comparison/predicate AST + the operator-overload menu | `Predicate`, `Literal`, `_All`, **`_InfixOps`** mixin |
+| `expression.py` | `SQLRenderable` protocol + expression nodes | `SQLRenderable`, `op`/`ops`, `PrefixOp`/`SuffixOp`, `FunctionCall`, `WindowExpression`, `_Exists`, `exists`/`not_exists` |
+| `builders.py` | Fluent, awaitable query builders | `SelectBuilder`, `InsertBuilder`, `UpdateBuilder`, `DeleteBuilder`, `_LockClause` |
+| `executor.py` | Render + execute each verb; row→object mapping | `render_*`/`run_*` per verb, hydration |
+| `cte.py` | WITH-clause / lateral sources that duck-type `TableProxy` | `CTE`, `RecursiveCTE`, `Lateral` |
+| `functions.py` | Curated PG function wrappers | `count`, `sum`, `coalesce`, `row_number`, `lag`/`lead`, … + `fn(name)` escape hatch |
+| `jsonb.py` / `arrays.py` / `fts.py` | Operator/function helpers for JSONB, arrays, full-text | `->`/`->>`/`@>`, `&&`/`ANY`/`ALL`, `to_tsvector`/`@@`/`ts_rank` |
+| `psycopg_db.py` | Reference psycopg3 adapter | `PsycopgDB` (the **only** module that imports psycopg; gated behind `[psycopg]` extra) |
+| `stubs.py` | `python -m cygnet.stubs` codegen for IDE autocomplete | — |
+| `py.typed` | PEP 561 typed-library marker | — |
+
+Tests: `tests/` unit suite against `tests/conftest.py:FakeDB` (no DB);
+`tests/integration/` real-PG round-trips (CI matrix PG 14–18); `bench/` advisory
+pytest-benchmark + cross-ORM comparison.
+
+## Invariants
+
+Load-bearing rules. THEORY.md §"Invariants, and why they hold" supplies the *why*;
+this is the enumeration.
+
+- **`UPDATE` and `DELETE` must call `.WHERE()`.** Breaks: raises `ValueError` at render *and* `.sql()` time. Opt out of the rail with `WHERE(cygnet.all)`; mixing `cygnet.all` with a real predicate also raises.
+- **`ColumnProxy.__eq__` (and `__ne__`/`__lt__`/arithmetic) return a `Predicate`, not a `bool`; `__hash__` is `None`.** Breaks: a proxy comparison used in a boolean/`if` context is always truthy (it's an AST node) — a silent logic bug, not an error. Proxies are unhashable on purpose (can't go in a set/dict key).
+- **One shared `params: list` threads through the whole render, numbered monotonically in document order (`$N = len(params)` after append).** Breaks: every renderable must append in left-to-right textual order; any out-of-order or two-pass rendering corrupts `$N` numbering and the adapter's `$N`→`%s` translation.
+- **Anything in a WHERE/SELECT-list/ORDER BY/HAVING/SET-RHS position must implement `render_sql(self, params) -> str`.** Breaks: non-renderables don't compose; this protocol is the only contract the executor relies on.
+- **`TableProxy`/`TableMeta` are per-class singletons (WeakValueDictionary); code compares them by identity (`b._table is X`).** Breaks: a non-singleton proxy fails identity checks in the executor. `.AS(alias)` deliberately returns a *fresh* proxy (self-joins need two); the canonical `Table(cls)` stays singleton.
+- **Exactly one `DBKey` or `AppKey` field per model.** Breaks: `meta._introspect` raises; composite PKs are unsupported by design.
+- **`DBKey` + `frozen=True` is rejected at introspection time.** Breaks: post-INSERT the executor `setattr`s the generated PK; a frozen instance would raise `FrozenInstanceError` deep in insert — caught early so the error names the model.
+- **`AppKey` + `None` at INSERT raises; empty `UPDATE … SET` raises; unknown `SET`/INSERT/`DO UPDATE` kwargs raise.** Breaks: these are anti-silent-no-op rails — a typo'd field name must fail loudly, not emit a no-op.
+- **The `db` object satisfies a duck-typed protocol — `execute`, `execute_one`, optional `stream`, and a `_in_transaction: bool` flag — and is per-task.** Breaks: `_in_transaction` is per-`db`-instance, not task-local; sharing one connection across `asyncio` tasks corrupts SAVEPOINT nesting.
+- **Core never imports a driver; only `psycopg_db.py` imports psycopg.** Breaks: pulling psycopg into core contradicts the bring-your-own-adapter design and the driver-free core install.
+
+## Landmines
+
+Non-obvious things a cold worker gets wrong. Each prevents a specific wrong action.
+
+- **`cygnet.lit(sql)` is raw, trusted, and *still* passes through the adapter's `$N`→`%s` regex.** A literal containing `$1` (or a `%`) gets rewritten. No parameter substitution happens inside `lit()` — it is a SQL-injection surface; never build it from untrusted input.
+- **Awaiting a builder twice re-renders and re-executes it.** Builders hold no rendered SQL/params between calls — intentional, so `.sql()`-then-`await` is safe, but a reused builder is a fresh query each time.
+- **`save()` does NOT refresh non-PK columns on the upsert branch.** `INSERT … ON CONFLICT DO UPDATE` emits no `RETURNING`; the in-memory object diverges from the row if the table has triggers / generated columns / `DEFAULT` on update. The *fresh-INSERT* branch does refresh. (Deferred tradeoff; OQ1 in the ADR.)
+- **`GROUP_BY` requires explicit columns: `SELECT(db, col1, …)`.** Bare `SELECT(db)` + `GROUP_BY` raises `ValueError`.
+- **Window-frame strings are interpolated verbatim** (e.g. `ROWS BETWEEN …`) — trusted, not parameterised. Another injection surface.
+- **`CTE`/`Lateral` duck-type `TableProxy`** by stamping `ColumnProxy` attrs on themselves with `# type: ignore`; they are not yet a formal `TableSourceProtocol` (OQ4). Treat `_sql_name`/`_meta`/`_alias` as the surface the executor reads.
+- **`_Exists` is dedicated, not `PrefixOp("EXISTS", …)`** — because `SelectBuilder.render_sql` already wraps itself in parens, reusing `PrefixOp` would emit `EXISTS ((SELECT …))`. `~exists(b)` toggles `EXISTS ↔ NOT EXISTS` rather than wrapping in `NOT (…)`.
+
+## Flow
+
+`cygnet.SELECT(db, …)` returns a `SelectBuilder`; fluent methods (`FROM`, `WHERE`,
+`JOIN`, `ORDER_BY`, …) mutate it and return `self`. The terminal action is
+`await builder` → `__await__` → `_execute()` → `Executor.render_<verb>(b, params)`
+(single pass, document order) → `db.execute(sql, params)` → row tuples →
+`Executor` maps rows back to dataclass instances (single-source) or
+`(left, right, …)` tuples (multi-source JOIN; `None` on a side signals an
+outer-join miss). `.sql()` renders without executing; `.stream()` async-iterates a
+server-side portal cursor instead of buffering. A `SelectBuilder` is itself a
+`SQLRenderable`, so it drops into any expression position as a subquery with no
+wrapper.
+
+## Where to change X
+
+- **Add a curated PG function** → `functions.py` (or reach `fn("name")` at call site).
+- **Add a JSONB / array / FTS operator** → `jsonb.py` / `arrays.py` / `fts.py`.
+- **Add or alter a SQL verb / clause** → fluent method in `builders.py` + render branch in `executor.py`.
+- **Change row→object hydration** → `executor.py` mapping path.
+- **Add a new expression node** → implement `render_sql(self, params)`; it composes everywhere automatically (the operator-overload menu is the `_InfixOps` mixin in `predicate.py`).
+- **Add PK/FK/column semantics** → marker in `annotations.py` + introspection in `meta.py`.
+- **Add a `db` adapter** → satisfy the four-method protocol; `psycopg_db.py` is the reference.
+
+---
+
+For the reasoning behind all of the above, see [THEORY.md](THEORY.md).

cygnet_orm-1.0.0/LICENSE

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