crosscheck-vision 0.1.0__py3-none-any.whl

crosscheck/__init__.py

@@ -0,0 +1,3 @@
+"""Crosscheck: several local vision models describe a photo; hear where they agree."""
+
+__version__ = "0.1.0"

crosscheck/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

crosscheck/cli.py

@@ -0,0 +1,120 @@
+"""Command line: `crosscheck serve` (the web app) and `crosscheck describe PHOTO`."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import webbrowser
+from pathlib import Path
+
+from . import __version__
+from .images import ImageError, check_image
+from .ollama import DEFAULT_URL, Ollama, OllamaError
+from .pipeline import run
+
+# Three model families, so their mistakes are less likely to be shared. All run on a 12-16 GB GPU
+# one at a time (Ollama swaps them), or on a CPU, slowly.
+DEFAULT_MODELS = ["qwen3-vl:4b-instruct", "gemma4:e4b", "granite3.2-vision:2b"]
+
+
+def _models(arg: str | None) -> list[str]:
+    raw = arg or os.environ.get("CROSSCHECK_MODELS") or ",".join(DEFAULT_MODELS)
+    models = [m.strip() for m in raw.split(",") if m.strip()]
+    return list(dict.fromkeys(models))
+
+
+def _check_installed(client: Ollama, models: list[str]) -> int:
+    try:
+        have = client.installed()
+    except OllamaError as e:
+        print(f"crosscheck: {e}. Start Ollama first (https://ollama.com).", file=sys.stderr)
+        return 2
+    missing = [m for m in models if m not in have]
+    if missing:
+        print("crosscheck: these models are not in Ollama yet:", file=sys.stderr)
+        for m in missing:
+            print(f"  ollama pull {m}", file=sys.stderr)
+        return 2
+    if len(models) < 2:
+        print("crosscheck: note: with one model nothing can be cross-checked.", file=sys.stderr)
+    return 0
+
+
+def cmd_serve(args: argparse.Namespace) -> int:
+    from .server import serve
+
+    client = Ollama(args.ollama)
+    models = _models(args.models)
+    if (code := _check_installed(client, models)) != 0:
+        return code
+    httpd = serve(client, models, args.port)
+    url = f"http://127.0.0.1:{httpd.server_address[1]}/"
+    print(f"Crosscheck is running at {url} with {', '.join(models)}. Press Ctrl+C to stop.")
+    if not args.no_browser:
+        webbrowser.open(url)
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+def cmd_describe(args: argparse.Namespace) -> int:
+    client = Ollama(args.ollama)
+    models = _models(args.models)
+    try:
+        image = check_image(Path(args.photo).read_bytes())
+    except (OSError, ImageError) as e:
+        print(f"crosscheck: {e}", file=sys.stderr)
+        return 2
+    if (code := _check_installed(client, models)) != 0:
+        return code
+    progress = None if args.json else (lambda msg: print(msg, file=sys.stderr))
+    result = run(client, image, models, args.question or "", progress=progress)
+    if args.json:
+        print(json.dumps(result.to_dict(), indent=2, ensure_ascii=False))
+        return 0
+    data = result.to_dict()
+    print(result.spoken)
+    for key, title in (("disputed", "Where the models disagree"), ("agreed", "What every model agrees on"),
+                       ("unconfirmed", "Details not every model could judge")):
+        if data[key]:
+            print(f"\n{title}:")
+            for f in data[key]:
+                print(f"- {f['text']}")
+                if key == "disputed":
+                    print("  " + "; ".join(f"{m}: {j}" for m, j in f["judgements"].items()))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="crosscheck", description="Several local vision models describe a photo; "
+                                "hear where they agree and where they disagree.")
+    p.add_argument("--version", action="version", version=f"crosscheck {__version__}")
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--ollama", default=os.environ.get("CROSSCHECK_OLLAMA", DEFAULT_URL), help="Ollama URL")
+    common.add_argument("--models", help=f"comma-separated Ollama models (default: {','.join(DEFAULT_MODELS)})")
+    sub = p.add_subparsers(dest="command", required=True)
+    s = sub.add_parser("serve", parents=[common], help="Start the web app on 127.0.0.1")
+    s.add_argument("--port", type=int, default=8765)
+    s.add_argument("--no-browser", action="store_true", help="Do not open a browser")
+    s.set_defaults(func=cmd_serve)
+    d = sub.add_parser("describe", parents=[common], help="Check one photo in the terminal")
+    d.add_argument("photo")
+    d.add_argument("--question", help="What you want to know, e.g. 'What does the label say?'")
+    d.add_argument("--json", action="store_true", help="Print the full result as JSON")
+    d.set_defaults(func=cmd_describe)
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except OllamaError as e:
+        print(f"crosscheck: {e}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 130

crosscheck/images.py

@@ -0,0 +1,27 @@
+"""Image checks without third-party packages."""
+
+from __future__ import annotations
+
+MAX_IMAGE = 20 * 1024 * 1024
+
+
+class ImageError(ValueError):
+    pass
+
+
+def kind(data: bytes) -> str | None:
+    if data[:3] == b"\xff\xd8\xff":
+        return "jpeg"
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        return "png"
+    return None
+
+
+def check_image(data: bytes) -> bytes:
+    if not data:
+        raise ImageError("no photo received")
+    if len(data) > MAX_IMAGE:
+        raise ImageError("the photo is too large (20 MB at most)")
+    if kind(data) is None:
+        raise ImageError("use a JPEG or PNG photo")
+    return data

crosscheck/ollama.py

@@ -0,0 +1,78 @@
+"""A minimal Ollama client: chat with an image and a JSON schema. Standard library only."""
+
+from __future__ import annotations
+
+import base64
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Any
+
+DEFAULT_URL = "http://127.0.0.1:11434"
+
+
+class OllamaError(Exception):
+    def __init__(self, message: str, status: int = 0):
+        super().__init__(message)
+        self.status = status
+
+
+@dataclass
+class Ollama:
+    url: str = DEFAULT_URL
+    timeout: float = 600.0
+
+    def _call(self, method: str, path: str, body: dict[str, Any] | None = None) -> Any:
+        data = json.dumps(body).encode() if body is not None else None
+        req = urllib.request.Request(self.url.rstrip("/") + path, data=data, method=method,
+                                     headers={"Content-Type": "application/json"})
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read() or b"null")
+        except urllib.error.HTTPError as e:
+            text = e.read().decode("utf-8", "replace")
+            try:
+                text = json.loads(text).get("error") or text
+            except (ValueError, AttributeError):
+                pass
+            raise OllamaError(str(text)[:300], e.code) from None
+        except (urllib.error.URLError, TimeoutError, ConnectionError) as e:
+            raise OllamaError(f"cannot reach Ollama at {self.url} ({getattr(e, 'reason', e)})") from None
+
+    def installed(self) -> set[str]:
+        """Model names Ollama has, with and without the ':latest' tag."""
+        names: set[str] = set()
+        for m in (self._call("GET", "/api/tags") or {}).get("models") or []:
+            name = m.get("name") or m.get("model") or ""
+            names.add(name)
+            if name.endswith(":latest"):
+                names.add(name[: -len(":latest")])
+        return names
+
+    def chat_json(self, model: str, prompt: str, image: bytes, schema: dict[str, Any]) -> tuple[Any, dict[str, Any]]:
+        """Ask about an image; returns (parsed JSON answer, timing info)."""
+        body = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt, "images": [base64.b64encode(image).decode("ascii")]}],
+            "format": schema,  # Ollama constrains the output to this JSON schema
+            "stream": False,
+            "think": False,
+            "options": {"temperature": 0},
+        }
+        last: Exception | None = None
+        for _ in range(2):  # one retry if the answer does not parse
+            resp = self._call("POST", "/api/chat", body)
+            content = ((resp or {}).get("message") or {}).get("content") or ""
+            try:
+                parsed = json.loads(content)
+            except ValueError as e:
+                last = e
+                continue
+            timing = {
+                "seconds": round((resp.get("total_duration") or 0) / 1e9, 2),
+                "load_seconds": round((resp.get("load_duration") or 0) / 1e9, 2),
+                "output_tokens": resp.get("eval_count"),
+            }
+            return parsed, timing
+        raise OllamaError(f"{model} did not return valid JSON ({last})")

crosscheck/pipeline.py

@@ -0,0 +1,230 @@
+"""Describe a photo with several vision models and find where they agree.
+
+1. Each model lists what it sees as short, separate facts (structured JSON output).
+2. Facts that say the same thing are merged; facts that differ in a number or in
+   quoted text are kept apart, because that is exactly where errors hide.
+3. Every model judges every fact it did not state: yes, no, or unsure.
+4. A fact is "agreed" when every model says yes, "disputed" when any says no,
+   and "unconfirmed" otherwise.
+
+Agreement is not proof: models can share a mistake. The wording never says
+"verified" or "correct".
+"""
+
+from __future__ import annotations
+
+import re
+import time
+import unicodedata
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from .ollama import Ollama, OllamaError
+
+DESCRIBE_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "summary": {"type": "string"},
+        "facts": {"type": "array", "items": {"type": "string"}, "maxItems": 15},
+    },
+    "required": ["summary", "facts"],
+}
+
+VERIFY_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "answers": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {"n": {"type": "integer"}, "answer": {"type": "string", "enum": ["yes", "no", "unsure"]}},
+                "required": ["n", "answer"],
+            },
+        }
+    },
+    "required": ["answers"],
+}
+
+DESCRIBE_PROMPT = """You are helping a blind person understand a photo they took.{question}
+List what you can see as short, separate facts, one fact per item. Start with the most important:
+what the main object or scene is, and any text you can read, quoted exactly. Include colours,
+positions, quantities and anything that matters for safety. Only state what is visible. If
+something is unclear, blurry or cut off, say so in the fact instead of guessing.
+Also write a one-sentence summary."""
+
+VERIFY_PROMPT = """Another assistant described this photo with the numbered statements below. Look at the
+photo yourself and judge each statement. Answer "yes" if the photo clearly shows it, "no" if the
+photo shows something different, and "unsure" if you cannot tell from the photo.
+
+{statements}"""
+
+_WORD = re.compile(r"\w+", re.UNICODE)
+_NUMBER = re.compile(r"\d+(?:[.,]\d+)?")
+_QUOTED = re.compile(r"[\"“”'‘’«»]([^\"“”'‘’«»]{2,})[\"“”'‘’«»]")
+
+
+def _norm(text: str) -> str:
+    return unicodedata.normalize("NFKC", text).casefold()
+
+
+def _f1(a: str, b: str) -> float:
+    x, y = _WORD.findall(_norm(a)), _WORD.findall(_norm(b))
+    if not x or not y:
+        return 0.0
+    common = sum((Counter(x) & Counter(y)).values())
+    if not common:
+        return 0.0
+    p, r = common / len(y), common / len(x)
+    return 2 * p * r / (p + r)
+
+
+def _anchors(text: str) -> tuple[frozenset[str], frozenset[str]]:
+    t = _norm(text)
+    return frozenset(_NUMBER.findall(t)), frozenset(q.strip() for q in _QUOTED.findall(t))
+
+
+def same_fact(a: str, b: str, threshold: float = 0.6) -> bool:
+    """Near-duplicates only if numbers and quoted text match too."""
+    return _anchors(a) == _anchors(b) and _f1(a, b) >= threshold
+
+
+@dataclass
+class Fact:
+    text: str
+    sources: list[str]  # models that stated it
+    votes: dict[str, str] = field(default_factory=dict)  # model -> yes/no/unsure
+
+    def status(self, models: list[str]) -> str:
+        answers = [("yes" if m in self.sources else self.votes.get(m, "unsure")) for m in models]
+        if "no" in answers:
+            return "disputed"
+        if all(a == "yes" for a in answers):
+            return "agreed"
+        return "unconfirmed"
+
+
+@dataclass
+class Result:
+    models: list[str]
+    summary: str
+    spoken: str
+    facts: list[Fact]
+    descriptions: dict[str, dict[str, Any]]
+    failed: dict[str, str]
+    seconds: float
+
+    def to_dict(self) -> dict[str, Any]:
+        groups: dict[str, list[dict[str, Any]]] = {"agreed": [], "disputed": [], "unconfirmed": []}
+        for f in self.facts:
+            groups[f.status(self.models)].append({
+                "text": f.text,
+                "stated_by": f.sources,
+                "judgements": {m: ("stated it" if m in f.sources else f.votes.get(m, "no answer")) for m in self.models},
+            })
+        return {"models": self.models, "summary": self.summary, "spoken": self.spoken, **groups,
+                "descriptions": self.descriptions, "failed": self.failed, "seconds": self.seconds}
+
+
+Progress = Callable[[str], None]
+
+
+def _short(text: str, limit: int = 90) -> str:
+    text = text.strip().rstrip(".")
+    return text if len(text) <= limit else text[: limit - 1].rsplit(" ", 1)[0] + "…"
+
+
+def spoken_summary(summary: str, facts: list[Fact], models: list[str], failed: dict[str, str]) -> str:
+    agreed = [f for f in facts if f.status(models) == "agreed"]
+    disputed = [f for f in facts if f.status(models) == "disputed"]
+    parts = [summary.strip().rstrip(".") + "."] if summary.strip() else []
+    if len(models) < 2:
+        parts.append("Only one model answered, so nothing could be cross-checked.")
+    else:
+        parts.append(f"The {len(models)} models agree on {len(agreed)} of {len(facts)} details.")
+        if disputed:
+            listed = "; ".join(_short(f.text) for f in disputed[:3])
+            more = f", and {len(disputed) - 3} more" if len(disputed) > 3 else ""
+            parts.append(f"They disagree about: {listed}{more}.")
+        else:
+            parts.append("No model contradicted another.")
+    if failed:
+        parts.append(f"{len(failed)} model{'s' if len(failed) > 1 else ''} did not answer.")
+    return " ".join(parts)
+
+
+def run(client: Ollama, image: bytes, models: list[str], question: str = "",
+        progress: Progress | None = None) -> Result:
+    started = time.monotonic()
+    say = progress or (lambda _msg: None)
+    q = f"\nThe person asks: {question.strip()}\nAnswer that first, then describe the rest." if question.strip() else ""
+    descriptions: dict[str, dict[str, Any]] = {}
+    failed: dict[str, str] = {}
+
+    for i, model in enumerate(models, start=1):
+        say(f"Model {i} of {len(models)} is describing the photo.")
+        try:
+            out, timing = client.chat_json(model, DESCRIBE_PROMPT.format(question=q), image, DESCRIBE_SCHEMA)
+        except OllamaError as e:
+            failed[model] = str(e)
+            continue
+        facts = [str(x).strip() for x in (out.get("facts") or []) if str(x).strip()][:15]
+        descriptions[model] = {"summary": str(out.get("summary") or "").strip(), "facts": facts, **timing}
+
+    answered = [m for m in models if m in descriptions]
+    merged: list[Fact] = []
+    for model in answered:
+        for text in descriptions[model]["facts"]:
+            match = next((f for f in merged if same_fact(f.text, text)), None)
+            if match:
+                if model not in match.sources:
+                    match.sources.append(model)
+            else:
+                merged.append(Fact(text=text, sources=[model]))
+
+    if len(answered) > 1:
+        # Judge in reverse order so the model loaded last goes first (fewer model swaps).
+        for i, model in enumerate(reversed(answered), start=1):
+            todo = [f for f in merged if model not in f.sources]
+            if not todo:
+                continue
+            say(f"Model {i} of {len(answered)} is checking the other models' details.")
+            statements = "\n".join(f"{n}. {f.text}" for n, f in enumerate(todo, start=1))
+            try:
+                out, timing = client.chat_json(model, VERIFY_PROMPT.format(statements=statements), image, VERIFY_SCHEMA)
+            except OllamaError as e:
+                failed[model] = f"while checking: {e}"
+                continue
+            descriptions[model]["check_seconds"] = timing["seconds"]
+            for a in out.get("answers") or []:
+                try:
+                    n = int(a.get("n"))
+                except (TypeError, ValueError):
+                    continue
+                if 1 <= n <= len(todo) and a.get("answer") in ("yes", "no", "unsure"):
+                    todo[n - 1].votes[model] = a["answer"]
+
+    order = {"disputed": 0, "agreed": 1, "unconfirmed": 2}
+    merged.sort(key=lambda f: order[f.status(answered)])
+    summary = _best_summary(descriptions, merged, answered)
+    return Result(
+        models=answered,
+        summary=summary,
+        spoken=spoken_summary(summary, merged, answered, failed) if answered else
+        "No model could describe the photo. " + "; ".join(f"{m}: {e}" for m, e in failed.items()),
+        facts=merged,
+        descriptions=descriptions,
+        failed=failed,
+        seconds=round(time.monotonic() - started, 1),
+    )
+
+
+def _best_summary(descriptions: dict[str, dict[str, Any]], facts: list[Fact], models: list[str]) -> str:
+    """The summary from the model whose own facts the others agreed with most."""
+    best, best_score = "", -1.0
+    for m in models:
+        own = [f for f in facts if m in f.sources]
+        score = sum(1 for f in own if f.status(models) == "agreed") / max(1, len(own))
+        if score > best_score and descriptions[m]["summary"]:
+            best, best_score = descriptions[m]["summary"], score
+    return best

crosscheck/server.py

@@ -0,0 +1,197 @@
+"""The local web app: upload a photo, hear where the models agree.
+
+Runs on 127.0.0.1 only. Requests must carry a local Host header (no DNS rebinding)
+and, for POSTs, a same-origin Origin (no cross-site requests). Photos stay in
+memory and go only to your Ollama.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import json
+import secrets
+import threading
+import time
+from collections import OrderedDict
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from importlib import resources
+from queue import Queue
+from typing import Any
+from urllib.parse import urlsplit
+
+from . import __version__
+from .images import ImageError, check_image
+from .ollama import Ollama
+from .pipeline import run
+
+MAX_BODY = 25 * 1024 * 1024
+MAX_JOBS = 20
+JOB_TTL = 30 * 60
+STATIC = {"/": ("index.html", "text/html; charset=utf-8"),
+          "/app.js": ("app.js", "text/javascript; charset=utf-8"),
+          "/app.css": ("app.css", "text/css; charset=utf-8")}
+CSP = ("default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' blob: data:; connect-src 'self'; "
+       "form-action 'self'; base-uri 'none'; frame-ancestors 'none'")
+LOCAL_HOSTS = ("localhost", "127.0.0.1", "[::1]")
+
+
+class Jobs:
+    """Photos are checked one at a time (the GPU is the bottleneck)."""
+
+    def __init__(self, client: Ollama, models: list[str]):
+        self.client, self.models = client, models
+        self.jobs: OrderedDict[str, dict[str, Any]] = OrderedDict()
+        self.lock = threading.Lock()
+        self.queue: Queue[str] = Queue()
+        threading.Thread(target=self._worker, daemon=True).start()
+
+    def submit(self, image: bytes, question: str) -> str | None:
+        with self.lock:
+            self._expire()
+            if sum(1 for j in self.jobs.values() if j["state"] in ("queued", "running")) >= MAX_JOBS:
+                return None
+            job_id = secrets.token_urlsafe(12)
+            self.jobs[job_id] = {"state": "queued", "message": "Waiting for the previous photo to finish.",
+                                 "created": time.time(), "image": image, "question": question}
+        self.queue.put(job_id)
+        return job_id
+
+    def get(self, job_id: str) -> dict[str, Any] | None:
+        with self.lock:
+            job = self.jobs.get(job_id)
+            if job is None:
+                return None
+            out = {k: v for k, v in job.items() if k not in ("image", "question", "created")}
+            if job["state"] == "queued":
+                ahead = 0
+                for jid, j in self.jobs.items():
+                    if jid == job_id:
+                        break
+                    if j["state"] in ("queued", "running"):
+                        ahead += 1
+                out["ahead"] = ahead
+            return out
+
+    def _expire(self) -> None:
+        now = time.time()
+        for jid in [j for j, v in self.jobs.items() if now - v["created"] > JOB_TTL and v["state"] in ("done", "error")]:
+            del self.jobs[jid]
+
+    def _set(self, job_id: str, **kw: Any) -> None:
+        with self.lock:
+            if job_id in self.jobs:
+                self.jobs[job_id].update(kw)
+
+    def _worker(self) -> None:
+        while True:
+            job_id = self.queue.get()
+            with self.lock:
+                job = self.jobs.get(job_id)
+                if not job:
+                    continue
+                image, question = job.pop("image"), job.pop("question")
+            self._set(job_id, state="running", message="Starting.")
+            try:
+                result = run(self.client, image, self.models, question,
+                             progress=lambda msg: self._set(job_id, message=msg))
+                self._set(job_id, state="done", message="Done.", result=result.to_dict())
+            except Exception as e:  # report, never crash the worker
+                self._set(job_id, state="error", message=f"Something went wrong: {e}")
+
+
+def make_handler(jobs: Jobs, port: int):
+    allowed_hosts = {f"{h}:{port}" for h in LOCAL_HOSTS}
+    allowed_origins = {f"http://{h}" for h in allowed_hosts}
+
+    class Handler(BaseHTTPRequestHandler):
+        server_version = f"crosscheck/{__version__}"
+        sys_version = ""
+
+        def log_message(self, fmt: str, *args: Any) -> None:  # no photo data or questions in logs
+            pass
+
+        def _send(self, status: int, body: bytes, ctype: str = "application/json") -> None:
+            self.send_response(status)
+            self.send_header("Content-Type", ctype)
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Content-Security-Policy", CSP)
+            self.send_header("X-Content-Type-Options", "nosniff")
+            self.send_header("Referrer-Policy", "no-referrer")
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+
+        def _json(self, status: int, obj: Any) -> None:
+            self._send(status, json.dumps(obj).encode())
+
+        def _host_ok(self) -> bool:
+            if self.headers.get("Host", "") not in allowed_hosts:
+                self._json(HTTPStatus.FORBIDDEN, {"error": "host not allowed"})
+                return False
+            return True
+
+        def do_GET(self) -> None:
+            if not self._host_ok():
+                return
+            path = urlsplit(self.path).path
+            if path in STATIC:
+                name, ctype = STATIC[path]
+                self._send(HTTPStatus.OK, (resources.files("crosscheck") / "static" / name).read_bytes(), ctype)
+            elif path.startswith("/api/jobs/"):
+                job = jobs.get(path.rsplit("/", 1)[-1])
+                self._json(HTTPStatus.OK if job else HTTPStatus.NOT_FOUND, job or {"error": "unknown job"})
+            elif path == "/api/info":
+                self._json(HTTPStatus.OK, {"models": jobs.models, "version": __version__})
+            else:
+                self._json(HTTPStatus.NOT_FOUND, {"error": "not found"})
+
+        def do_POST(self) -> None:
+            if not self._host_ok():
+                return
+            origin = self.headers.get("Origin")
+            if origin is not None and origin not in allowed_origins:
+                self._json(HTTPStatus.FORBIDDEN, {"error": "cross-origin request refused"})
+                return
+            if urlsplit(self.path).path != "/api/check":
+                self._json(HTTPStatus.NOT_FOUND, {"error": "not found"})
+                return
+            if "application/json" not in (self.headers.get("Content-Type") or ""):
+                self._json(HTTPStatus.UNSUPPORTED_MEDIA_TYPE, {"error": "send JSON"})
+                return
+            try:
+                length = int(self.headers.get("Content-Length") or 0)
+            except ValueError:
+                length = -1
+            if length <= 0 or length > MAX_BODY:
+                self._json(HTTPStatus.REQUEST_ENTITY_TOO_LARGE, {"error": "the photo is too large (25 MB at most)"})
+                return
+            try:
+                body = json.loads(self.rfile.read(length))
+                data = str(body.get("image") or "")
+                if data.startswith("data:"):
+                    data = data.split(",", 1)[-1]
+                image = check_image(base64.b64decode(data, validate=True))
+                question = str(body.get("question") or "")[:500]
+            except ImageError as e:  # a ValueError too, so it comes first
+                self._json(HTTPStatus.BAD_REQUEST, {"error": str(e)})
+                return
+            except (ValueError, AttributeError, binascii.Error):
+                self._json(HTTPStatus.BAD_REQUEST, {"error": "expected JSON with a base64 image"})
+                return
+            job_id = jobs.submit(image, question)
+            if job_id is None:
+                self._json(HTTPStatus.TOO_MANY_REQUESTS, {"error": "too many photos waiting; try again shortly"})
+                return
+            self._json(HTTPStatus.ACCEPTED, {"job": job_id})
+
+    return Handler
+
+
+def serve(client: Ollama, models: list[str], port: int = 8765) -> ThreadingHTTPServer:
+    jobs = Jobs(client, models)
+    httpd = ThreadingHTTPServer(("127.0.0.1", port), make_handler(jobs, port))
+    if port == 0:  # tests: bind first, then learn the port
+        httpd.RequestHandlerClass = make_handler(jobs, httpd.server_address[1])
+    return httpd

crosscheck/static/app.css

@@ -0,0 +1,57 @@
+:root {
+  color-scheme: light dark;
+  --bg: #ffffff;
+  --fg: #111111;
+  --muted: #3d3d3d;
+  --line: #8a8a8a;
+  --accent: #0b4fb3;
+  --focus: #b35900;
+  --surface: #f2f2f2;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #111111;
+    --fg: #f5f5f5;
+    --muted: #d0d0d0;
+    --line: #8a8a8a;
+    --accent: #8fb8ff;
+    --focus: #ffb366;
+    --surface: #1f1f1f;
+  }
+}
+* { box-sizing: border-box; }
+html { font-size: 112.5%; }
+body { margin: 0; background: var(--bg); color: var(--fg); font: 1rem/1.6 system-ui, -apple-system, "Segoe UI", sans-serif; }
+main { max-width: 46rem; margin: 0 auto; padding: 2rem 1rem 4rem; }
+h1 { font-size: 2rem; margin: 0 0 .25rem; }
+h2 { font-size: 1.5rem; margin: 2rem 0 .5rem; }
+h3 { font-size: 1.15rem; margin: 1.5rem 0 .25rem; }
+h4 { font-size: 1rem; margin: 1rem 0 .25rem; }
+.lead { color: var(--muted); margin-top: 0; }
+.field { margin: 1.25rem 0; }
+.field label { display: block; font-weight: 600; margin-bottom: .25rem; }
+.field.check { display: flex; gap: .6rem; align-items: center; }
+.field.check label { margin: 0; font-weight: 400; }
+.optional, .help { color: var(--muted); font-weight: 400; }
+.help { margin: .25rem 0 0; font-size: .9rem; }
+input[type="text"], input[type="file"] {
+  width: 100%; font: inherit; color: inherit; background: var(--bg);
+  border: 2px solid var(--line); border-radius: 6px; padding: .6rem .7rem;
+}
+input[type="checkbox"] { width: 1.3rem; height: 1.3rem; accent-color: var(--accent); }
+button {
+  font: inherit; font-weight: 600; color: var(--bg); background: var(--accent);
+  border: 0; border-radius: 6px; padding: .8rem 1.4rem; cursor: pointer; min-height: 48px;
+}
+button:disabled { opacity: .6; cursor: progress; }
+:focus-visible { outline: 3px solid var(--focus); outline-offset: 3px; }
+#status { min-height: 1.6em; font-weight: 600; margin: 1.5rem 0 0; }
+#result { margin-top: 1rem; }
+#result:focus { outline: none; }
+.spoken { font-size: 1.15rem; background: var(--surface); border-left: 4px solid var(--accent); padding: .8rem 1rem; }
+ul { padding-left: 1.25rem; }
+li { margin: .35rem 0; }
+.who { color: var(--muted); font-size: .9rem; }
+details { margin-top: 1.5rem; border: 2px solid var(--line); border-radius: 6px; padding: .5rem 1rem; }
+summary { cursor: pointer; font-weight: 600; min-height: 44px; display: flex; align-items: center; }
+.note { margin-top: 3rem; color: var(--muted); border-top: 1px solid var(--line); padding-top: 1rem; }

crosscheck/static/app.js

@@ -0,0 +1,145 @@
+"use strict";
+
+// Everything from the server is inserted with textContent, never as HTML.
+const $ = (id) => document.getElementById(id);
+const MAX_SIDE = 1600;
+
+function setStatus(text) {
+  const el = $("status");
+  if (el.textContent !== text) el.textContent = text; // repeat nothing to screen readers
+}
+
+// Downscale and re-encode as JPEG in the browser: smaller uploads, and the photo's
+// metadata (such as GPS location) is dropped.
+async function preparePhoto(file) {
+  let bitmap;
+  try {
+    bitmap = await createImageBitmap(file, { imageOrientation: "from-image" });
+  } catch {
+    throw new Error("This browser cannot open that photo. Try a JPEG or PNG.");
+  }
+  const scale = Math.min(1, MAX_SIDE / Math.max(bitmap.width, bitmap.height));
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.round(bitmap.width * scale);
+  canvas.height = Math.round(bitmap.height * scale);
+  canvas.getContext("2d").drawImage(bitmap, 0, 0, canvas.width, canvas.height);
+  const blob = await new Promise((resolve) => canvas.toBlob(resolve, "image/jpeg", 0.9));
+  return await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(new Error("Could not read the photo."));
+    reader.readAsDataURL(blob);
+  });
+}
+
+function fillList(id, items, models) {
+  const list = $(id);
+  list.replaceChildren();
+  const heading = $(id + "-heading");
+  if (!items.length) {
+    const li = document.createElement("li");
+    li.textContent = "None.";
+    list.append(li);
+    return;
+  }
+  for (const item of items) {
+    const li = document.createElement("li");
+    const text = document.createElement("span");
+    text.className = "fact";
+    text.textContent = item.text;
+    li.append(text);
+    if (models.length > 1) {
+      const who = document.createElement("span");
+      who.className = "who";
+      who.textContent = " (" + models.map((m) => m + ": " + item.judgements[m]).join("; ") + ")";
+      li.append(who);
+    }
+    list.append(li);
+  }
+  heading.textContent = heading.textContent.replace(/ \(\d+\)$/, "") + " (" + items.length + ")";
+}
+
+function showResult(result) {
+  $("spoken").textContent = result.spoken;
+  fillList("disputed", result.disputed, result.models);
+  fillList("agreed", result.agreed, result.models);
+  fillList("unconfirmed", result.unconfirmed, result.models);
+  const box = $("descriptions");
+  box.replaceChildren();
+  for (const [model, d] of Object.entries(result.descriptions)) {
+    const h = document.createElement("h4");
+    h.textContent = model;
+    const p = document.createElement("p");
+    p.textContent = d.summary;
+    const ul = document.createElement("ul");
+    for (const f of d.facts) {
+      const li = document.createElement("li");
+      li.textContent = f;
+      ul.append(li);
+    }
+    box.append(h, p, ul);
+  }
+  for (const [model, err] of Object.entries(result.failed)) {
+    const p = document.createElement("p");
+    p.textContent = model + " did not answer: " + err;
+    box.append(p);
+  }
+  $("timing").textContent = result.seconds < 1 ? "Took under a second." : "Took " + Math.round(result.seconds) + " seconds.";
+  const section = $("result");
+  section.hidden = false;
+  section.focus(); // screen readers start at the result
+  if ($("speak").checked && "speechSynthesis" in window) {
+    const utterance = new SpeechSynthesisUtterance(result.spoken);
+    const local = speechSynthesis.getVoices().find((v) => v.localService && v.lang.startsWith(document.documentElement.lang));
+    if (local) utterance.voice = local; // prefer a voice that runs on this device
+    speechSynthesis.cancel();
+    speechSynthesis.speak(utterance);
+  }
+}
+
+async function poll(job) {
+  for (;;) {
+    await new Promise((r) => setTimeout(r, 1000));
+    const resp = await fetch("/api/jobs/" + encodeURIComponent(job));
+    const data = await resp.json();
+    if (data.state === "done") return data.result;
+    if (data.state === "error" || !resp.ok) throw new Error(data.message || data.error || "Something went wrong.");
+    setStatus(data.state === "queued" && data.ahead ? `Waiting: ${data.ahead} photo(s) ahead.` : data.message);
+  }
+}
+
+async function onSubmit(event) {
+  event.preventDefault();
+  const file = $("photo").files[0];
+  if (!file) {
+    setStatus("Choose a photo first.");
+    $("photo").focus();
+    return;
+  }
+  const button = $("submit");
+  button.disabled = true;
+  $("result").hidden = true;
+  try {
+    setStatus("Preparing the photo.");
+    const image = await preparePhoto(file);
+    setStatus("Sending the photo to the models. This can take a minute.");
+    const resp = await fetch("/api/check", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ image, question: $("question").value }),
+    });
+    const data = await resp.json();
+    if (!resp.ok) throw new Error(data.error || "The photo was not accepted.");
+    const result = await poll(data.job);
+    setStatus("Result ready.");
+    showResult(result);
+  } catch (err) {
+    setStatus(err.message);
+  } finally {
+    button.disabled = false;
+  }
+}
+
+document.addEventListener("DOMContentLoaded", () => {
+  $("form").addEventListener("submit", onSubmit);
+});

crosscheck/static/index.html

@@ -0,0 +1,62 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<title>Crosscheck</title>
+<meta name="description" content="Several local vision models describe a photo; hear where they agree and where they disagree.">
+<link rel="stylesheet" href="/app.css">
+<script src="/app.js" defer></script>
+</head>
+<body>
+<main>
+  <h1>Crosscheck</h1>
+  <p class="lead">Several AI models describe your photo. You hear what they agree on, and where they disagree.</p>
+
+  <form id="form" novalidate>
+    <div class="field">
+      <label for="photo">Photo</label>
+      <input id="photo" name="photo" type="file" accept="image/jpeg,image/png,image/*" aria-describedby="photo-help">
+      <p id="photo-help" class="help">JPEG or PNG. The photo stays on this computer.</p>
+    </div>
+    <div class="field">
+      <label for="question">Question <span class="optional">(optional)</span></label>
+      <input id="question" name="question" type="text" maxlength="500" autocomplete="off"
+             aria-describedby="question-help">
+      <p id="question-help" class="help">For example: What does the label say?</p>
+    </div>
+    <div class="field check">
+      <input id="speak" type="checkbox">
+      <label for="speak">Also read the result aloud with this browser's voice</label>
+    </div>
+    <button id="submit" type="submit">Check photo</button>
+  </form>
+
+  <p id="status" role="status" aria-live="polite" aria-atomic="true"></p>
+
+  <section id="result" tabindex="-1" aria-labelledby="result-heading" hidden>
+    <h2 id="result-heading">Result</h2>
+    <p id="spoken" class="spoken"></p>
+
+    <h3 id="disputed-heading">Where the models disagree</h3>
+    <ul id="disputed" aria-labelledby="disputed-heading"></ul>
+
+    <h3 id="agreed-heading">What every model agrees on</h3>
+    <ul id="agreed" aria-labelledby="agreed-heading"></ul>
+
+    <h3 id="unconfirmed-heading">Details not every model could judge</h3>
+    <ul id="unconfirmed" aria-labelledby="unconfirmed-heading"></ul>
+
+    <details>
+      <summary>Each model's own description</summary>
+      <div id="descriptions"></div>
+    </details>
+    <p id="timing" class="help"></p>
+  </section>
+
+  <p class="note">Agreement is not proof: models can make the same mistake. For anything that matters,
+  such as medicine, money or safety, confirm with a person or another trusted source.</p>
+</main>
+</body>
+</html>

crosscheck_vision-0.1.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: crosscheck-vision
+Version: 0.1.0
+Summary: Several local vision models describe a photo; hear where they agree and where they disagree. For blind and low-vision users.
+Keywords: accessibility,blind,low-vision,image-description,ollama,vision-language-model
+Author: Rush Labs
+Author-email: Rush Labs <admin@rushlabs.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Adaptive Technologies
+Requires-Python: >=3.10
+Project-URL: Homepage, https://rushlabs.ai/lab
+Project-URL: Source, https://github.com/rushlabs-ai/crosscheck
+Project-URL: Issues, https://github.com/rushlabs-ai/crosscheck/issues
+Description-Content-Type: text/markdown
+
+# Crosscheck
+
+**A second opinion for AI photo descriptions.** Several vision models, running on your own
+computer, describe the same photo. Crosscheck tells you what they all agree on, and, first and
+most clearly, where they disagree.
+
+Built for blind and low-vision people, who use AI descriptions for labels, medicine, mail and
+screens but have no easy way to tell when a description is wrong.
+
+## Why
+
+A single AI description sounds equally confident when it is right and when it is wrong. A study
+at ASSETS 2025, [*Surfacing Variations to Calibrate Perceived Reliability of MLLM-generated Image
+Descriptions*](https://arxiv.org/abs/2507.15692) (Meng Chen, Akhil Iyer, Amy Pavel), found that
+when blind and low-vision participants were shown where several models' descriptions varied,
+they spotted **4.9 times as many unreliable claims** as with a single description (2.62 against
+0.53 per image). 11 of 15 participants ranked that presentation as their favourite, and all of
+them wanted to use it in the future.
+
+Crosscheck brings that idea to models that run locally through [Ollama](https://ollama.com):
+free, offline, and the photo never leaves your computer.
+
+## How it works
+
+1. Each model lists what it sees as short, separate facts, and quotes any text it can read.
+2. Facts that say the same thing are merged. Facts that differ in a **number or quoted text**
+   ("Ibuprofen 200 mg" against "400 mg") are kept apart, because that is where errors hide.
+3. Every model looks at the photo again and judges each fact the others stated: yes, no, or unsure.
+4. You hear a short summary first, for example:
+
+   > A pill bottle on a wooden table. The 3 models agree on 6 of 9 details. They disagree about:
+   > The label says "Ibuprofen 200 mg"; The label says "Ibuprofen 400 mg".
+
+   Then, on demand: what every model agrees on, where they disagree (and which model said what),
+   and details not every model could judge.
+
+**Agreement is not proof.** Models can make the same mistake. For medicine, money or safety,
+confirm with a person or another trusted source. Crosscheck never says "verified".
+
+## Install
+
+1. Install [Ollama](https://ollama.com) and pull three vision models from different families
+   (different families make different mistakes):
+
+   ```sh
+   ollama pull qwen3-vl:4b-instruct
+   ollama pull gemma4:e4b
+   ollama pull granite3.2-vision:2b
+   ```
+
+2. Install and start Crosscheck (Python 3.10+, no other dependencies):
+
+   ```sh
+   uv tool install crosscheck-vision      # or: pipx install crosscheck-vision
+   crosscheck serve
+   ```
+
+   It opens http://127.0.0.1:8765 in your browser.
+
+Choose other models with `--models a,b,c` (or `CROSSCHECK_MODELS`). With a 12–16 GB GPU, expect
+about 30–90 seconds per photo while Ollama swaps the models in and out; a CPU works, slowly.
+
+## Using it
+
+- **Web app**: choose a photo, optionally ask a question ("What does the label say?"), press
+  *Check photo*. Progress is announced; when the result is ready, focus moves to it. Everything
+  works with the keyboard and a screen reader. A checkbox can also read the result aloud with
+  the browser's own voice.
+- **Terminal**: `crosscheck describe photo.jpg --question "What does the label say?"`, or `--json`
+  for the full result.
+
+The web app shrinks the photo in your browser before sending it, which also removes metadata
+such as GPS location.
+
+## Privacy and security
+
+- Runs on 127.0.0.1 only. Photos stay in memory and go only to your Ollama. Nothing is logged.
+- Requests must come from the app itself: a non-local `Host` (DNS rebinding) or a foreign
+  `Origin` (another website) is refused. A strict Content-Security-Policy blocks outside content.
+- Model output is shown as text, never as HTML.
+
+## Status and limits
+
+- v0.1, for desktop browsers on the same computer. Using a phone camera over Wi-Fi needs HTTPS
+  and is planned for v0.2.
+- Merging facts across models uses word overlap, so two phrasings of one fact are sometimes
+  listed separately; each still gets judged.
+- Small local models are weaker than the cloud models in the study. We are measuring how well
+  their disagreement predicts real errors on photos taken by blind people (VizWiz), and will
+  publish the results and timings here.
+
+Feedback from blind and low-vision users matters most: please open an issue or email
+admin@rushlabs.ai.
+
+## Development
+
+```sh
+python -m unittest discover -s tests -v
+```
+
+Tests run against a fake Ollama: merging and judging, a failing model, the web app's security
+checks, the job queue and the CLI.
+
+## Licence
+
+Apache-2.0. Built by [Rush Labs](https://rushlabs.ai), an applied AI lab. The models keep their
+own licences (all three defaults are Apache-2.0).

crosscheck_vision-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+crosscheck/__init__.py,sha256=ABDA4N3bHyLAMg-QTV0r9FD6hSgNvNAS3TJ5dRQxVro,110
+crosscheck/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+crosscheck/cli.py,sha256=079hZJob6HVfWrYrQqWc5SWUKopD9JflBcx3_N5UnA4,4748
+crosscheck/images.py,sha256=DvcXcW08cxxtzHwRY42wJO1Ng53Uop5sjISiU3S6UoQ,627
+crosscheck/ollama.py,sha256=Q94TAb9N_hd23xY508hASUpfpM1tXPDy1RHy2omPgdg,3221
+crosscheck/pipeline.py,sha256=rSz21xfK2-SAo52D-8d21wj8zbMIuip0mLlcX0BVVgg,9267
+crosscheck/server.py,sha256=Bn6TfRaQzVjTLwzPlqU5n2UqxMRRvp3oY_-hC4Q08Bw,8408
+crosscheck/static/app.css,sha256=bFbwy6yYUqVkItB2MFLmS84jJmZHHIGj0VpfoKSL-Z8,2438
+crosscheck/static/app.js,sha256=A6eRXogALkCmlmmTnqb3PL2dJfgbQVGX9zSeKQVrnKA,5250
+crosscheck/static/index.html,sha256=aTi9-F1pwlm486to17hKacAypSjQhdRE_bk5ZQai6rg,2472
+crosscheck_vision-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+crosscheck_vision-0.1.0.dist-info/WHEEL,sha256=3NO1oYsF7mANFUWVdyEQLM-zmecczWWEmmF5rEbXrWk,80
+crosscheck_vision-0.1.0.dist-info/entry_points.txt,sha256=TZzklRC2lXr7w-j3cAP7IUMKSZnpHLy0MyTIHkZwXcA,52
+crosscheck_vision-0.1.0.dist-info/METADATA,sha256=vqiE5eiir9hYewCvzWzYBPgQGsKNIapJv5gFU98T3dc,5615
+crosscheck_vision-0.1.0.dist-info/RECORD,,

crosscheck_vision-0.1.0.dist-info/WHEEL

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

crosscheck_vision-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+crosscheck = crosscheck.cli:main
+

crosscheck_vision-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.