eyewright 0.3.0__py3-none-any.whl

eyewright/__init__.py

@@ -0,0 +1,6 @@
+"""eyewright - local decision core: the three-eye gate + one-call typed decisions."""
+
+from .decide import ask
+from .gate import decide_gate, load_key, systemone_http, systemone_ollama  # noqa: F401
+
+__version__ = "0.3.0"

eyewright/cli.py

@@ -0,0 +1,69 @@
+"""eyewright CLI: gate | ask | serve | mcp."""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .decide import ask
+from .gate import decide_gate
+
+
+def _load_cfg(path):
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="eyewright", description="eyewright - local decision core")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    g = sub.add_parser("gate", help="three-eye gate on a claim")
+    g.add_argument("--state", required=True)
+    g.add_argument("--question", required=True)
+    g.add_argument("--config", default="examples/gate.json")
+
+    a = sub.add_parser("ask", help="typed decision (yes/no, choice, or scale)")
+    a.add_argument("--state", required=True)
+    a.add_argument("--question", required=True)
+    a.add_argument("--choices", help="JSON object: option key -> description (choice)")
+    a.add_argument("--levels", help="JSON array of level descriptions (score)")
+    a.add_argument("--engine", default="typed", choices=["typed", "generative", "auto"],
+                   help="typed (decision models; default), generative (local LLM), or auto (typed, fall back)")
+    a.add_argument("--config", default="examples/gate.json")
+
+    s = sub.add_parser("serve", help="HTTP service (/v1/gate, /v1/ask)")
+    s.add_argument("--host", default="127.0.0.1")
+    s.add_argument("--port", type=int, default=8090)
+    s.add_argument("--config", default="examples/gate.json")
+
+    m = sub.add_parser("mcp", help="MCP stdio server (needs the mcp extra)")
+    m.add_argument("--config", default="examples/gate.json")
+
+    args = ap.parse_args(argv)
+    cfg = _load_cfg(args.config)
+
+    if args.cmd == "gate":
+        p, trace = decide_gate(cfg, args.state, args.question)
+        print(json.dumps({"p_done": round(p, 4), "decision": trace.get("decision"), "trace": trace}, indent=2))
+        return 0
+    if args.cmd == "ask":
+        choices = json.loads(args.choices) if args.choices else None
+        levels = json.loads(args.levels) if args.levels else None
+        engine = None if args.engine == "typed" else args.engine
+        print(json.dumps(ask(cfg, args.state, args.question, choices=choices, levels=levels, engine=engine), indent=2))
+        return 0
+    if args.cmd == "serve":
+        from .server import serve
+
+        serve(cfg, args.host, args.port)
+        return 0
+    if args.cmd == "mcp":
+        from .mcp_server import run
+
+        run(cfg)
+        return 0
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

eyewright/decide.py

@@ -0,0 +1,132 @@
+"""eyewright.ask - one call, any typed decision.
+
+eyewright's second face: not just the three-eye "done" gate, but a single
+callable for typed decisions:
+
+  - noul (no choices):     the three-eye gate policy on a yes/no question
+  - choice (choices dict): the primary decision model picks the option
+  - score (levels list):   the primary decision model rates on the scale
+
+Uniform answer: {"kind", "answer", "confidence", "probabilities"?, "trace"}.
+
+Any program can call this in-process (``from eyewright import ask``); ``eyewright
+serve`` exposes it over HTTP and ``eyewright mcp`` exposes it as MCP tools.
+"""
+
+import json
+import urllib.request
+
+from .gate import decide_gate, load_key
+
+
+def _post_json(url, payload, timeout=1800):
+    data = json.dumps(payload).encode()
+    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.loads(r.read().decode())
+
+
+def call_engine(entry, state, questions):
+    """One systemone call against a configured engine (an `entry` from the gate config)."""
+    t = entry.get("type")
+    if t == "systemone-http":
+        payload = {"state": state, "questions": questions}
+        if entry.get("model"):
+            payload["model"] = entry["model"]
+        req = urllib.request.Request(
+            entry["url"], data=json.dumps(payload).encode(),
+            headers={"Content-Type": "application/json"},
+        )
+        key = load_key(entry.get("key_file") or "")
+        if key:
+            req.add_header("Authorization", "Bearer " + key)
+        with urllib.request.urlopen(req, timeout=1800) as r:
+            return json.loads(r.read().decode())
+    if t == "systemone-ollama":
+        payload = {"model": entry["model"], "state": state, "questions": questions}
+        return _post_json("http://localhost:11434/v1/systemone", payload)
+    raise ValueError(f"unknown engine type {t!r}")
+
+
+def ask(cfg, state, question, choices=None, levels=None, engine=None, qid="q"):
+    """One decision. `choices` -> choice question; `levels` -> score; else yes/no (noul).
+
+    engine:
+      None / "typed" -> the decision models: noul runs the three-eye gate;
+                        choice/score use the primary engine.
+      "generative"   -> the local generative adjudicator (cfg["generative"]) answers
+                        with a strict JSON contract; its confidence is the model's
+                        own estimate (``"calibrated": false``).
+      "auto"         -> typed first; fall back to the generative engine when the
+                        typed path errors or has no signal (needs a generative block).
+    """
+    if choices:
+        questions = {qid: {"type": "choice", "instructions": question, "criteria": choices}}
+        kind = "choice"
+    elif levels:
+        questions = {qid: {"type": "score", "instructions": question, "criteria": levels}}
+        kind = "score"
+    else:
+        questions = {qid: {"type": "noul", "instructions": question}}
+        kind = "noul"
+
+    if engine == "generative":
+        from .generative import ask_generative
+
+        return ask_generative(cfg, state, question, choices=choices, levels=levels, kind=kind)
+
+    if kind == "noul":
+        p, trace = decide_gate(cfg, state, question)
+        out = {
+            "kind": "noul",
+            "answer": "yes" if p >= 0.5 else "no",
+            "confidence": round(max(p, 1 - p), 4),
+            "p_true": round(p, 4),
+            "trace": trace,
+        }
+        if engine == "auto" and trace.get("decision") == "none" and cfg.get("generative"):
+            from .generative import ask_generative
+
+            fb = ask_generative(cfg, state, question, choices=choices, levels=levels, kind=kind)
+            fb["fallback"] = "typed->generative"
+            return fb
+        return out
+
+    entry = cfg.get("primary")
+    if not entry:
+        raise ValueError("config has no primary engine")
+    try:
+        resp = call_engine(entry, state, questions)
+    except Exception as e:
+        if engine == "auto" and cfg.get("generative"):
+            from .generative import ask_generative
+
+            fb = ask_generative(cfg, state, question, choices=choices, levels=levels, kind=kind)
+            fb["fallback"] = "typed->generative"
+            return fb
+        return {"kind": kind, "answer": None, "confidence": None, "error": str(e)[:200]}
+    ans = (resp.get("answers") or {}).get(qid) or {}
+    probs = ans.get("probabilities") or {}
+    if kind == "choice":
+        answer = ans.get("choice") or (max(probs, key=probs.get) if probs else None)
+        conf = ans.get("confidence")
+        if conf is None and answer is not None:
+            conf = probs.get(answer, 0.0)
+    else:
+        answer = ans.get("score")
+        conf = ans.get("confidence")
+    out = {
+        "kind": kind,
+        "answer": answer,
+        "confidence": round(float(conf), 4) if conf is not None else None,
+        "probabilities": probs,
+        "model": resp.get("model"),
+        "trace": {"engine": entry.get("name") or entry.get("model") or entry.get("type")},
+    }
+    if engine == "auto" and out.get("answer") is None and cfg.get("generative"):
+        from .generative import ask_generative
+
+        fb = ask_generative(cfg, state, question, choices=choices, levels=levels, kind=kind)
+        fb["fallback"] = "typed->generative"
+        return fb
+    return out

eyewright/gate.py

@@ -0,0 +1,177 @@
+"""eyewright: the three-eye decision gate over cheap local decision models.
+
+Canonical policy implementation. Consumed by the orbit repo
+(``from eyewright.gate import decide_gate``) and validated by ``bench/``
+(THREE-EYE.md, GATE-ANALYSIS.md).
+
+Policy per question:
+  - primary (third eye) = laya-typed-decisions, usually via systemone-http
+  - p >= accept -> accept; p < consult -> review-low
+  - uncertain band [consult, accept) -> both consults answer
+      * >= 2 confident (max(p, 1-p) >= high) and same direction -> consensus
+      * exactly 1 confident, another consult within delta of main -> review-conflict
+      * otherwise -> review-weak / review-no-signal
+
+Decisions: accept | consensus-accept | consensus-reject | review-low |
+review-conflict | review-weak | review-no-signal | none. Returns (p_done, trace).
+"""
+
+import json
+import os
+import urllib.request
+from pathlib import Path
+
+
+def _post_json(url, payload, timeout=1800):
+    data = json.dumps(payload).encode()
+    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.loads(r.read().decode())
+
+
+def load_key(path):
+    """Read an API key file; relative paths resolve against the cwd."""
+    if not path:
+        return ""
+    p = Path(path)
+    if not p.is_absolute():
+        p = Path.cwd() / p
+    return p.read_text(encoding="utf-8").strip() if p.exists() else ""
+
+
+def systemone_ollama(stage, state, question):
+    payload = {
+        "model": stage["model"],
+        "state": state,
+        "questions": {"done": {"type": "noul", "instructions": question}},
+    }
+    resp = _post_json("http://localhost:11434/v1/systemone", payload)
+    return float(resp["answers"]["done"]["noul"])
+
+
+def systemone_http(url, key, state, question, model=None):
+    payload = {
+        "state": state,
+        "questions": {"done": {"type": "noul", "instructions": question}},
+    }
+    if model:
+        payload["model"] = model
+    req = urllib.request.Request(
+        url, data=json.dumps(payload).encode(),
+        headers={"Content-Type": "application/json"},
+    )
+    if key:
+        req.add_header("Authorization", "Bearer " + key)
+    with urllib.request.urlopen(req, timeout=1800) as r:
+        resp = json.loads(r.read().decode())
+    return float(resp["answers"]["done"]["noul"])
+
+
+def openrouter_decisions(entry, state, question):
+    """Native decisions API (Typesafe Jev on OpenRouter).
+
+    Same `state`/`questions` shape as systemone, so Jev plugs into the committee
+    as a drop-in eye. Set ``"zdr": true`` on the entry to route only to
+    zero-data-retention providers; the API key comes from the environment
+    (``key_env``, default ``OPENROUTER_API_KEY``).
+    """
+    url = entry.get("url") or "https://openrouter.ai/api/alpha/decisions"
+    payload = {
+        "model": entry["model"],
+        "state": state,
+        "questions": {"done": {"type": "noul", "instructions": question}},
+    }
+    if entry.get("zdr"):
+        payload["provider"] = {"zdr": True}
+    headers = {"Content-Type": "application/json"}
+    key = os.environ.get(entry.get("key_env") or "OPENROUTER_API_KEY", "")
+    if key:
+        headers["Authorization"] = "Bearer " + key
+    req = urllib.request.Request(url, data=json.dumps(payload).encode(), headers=headers)
+    with urllib.request.urlopen(req, timeout=180) as r:
+        resp = json.loads(r.read().decode())
+    return float((resp.get("answers") or {}).get("done", {}).get("noul"))
+
+
+def decide_gate(cfg, state, question):
+    """Three-eye gate. Primary first; in the uncertain band, consult the others.
+    Trust a consensus of >=2 confident consults; otherwise review (retry/gather evidence).
+
+    Decisions: accept | consensus | review-low | review-conflict | review-weak |
+    review-no-signal | none. Returns (p_done, trace).
+    """
+    accept = float(cfg.get("accept_threshold", 0.75))
+    consult = float(cfg.get("consult_threshold", 0.55))
+    high = float(cfg.get("high_confidence", 0.9))
+    delta = float(cfg.get("match_delta", 0.05))
+    trace = {"consults": {}}
+
+    def ask(entry):
+        t = entry.get("type")
+        if t == "systemone-http":
+            key = load_key(entry.get("key_file") or "")
+            return systemone_http(entry["url"], key, state, question, entry.get("model"))
+        if t == "systemone-ollama":
+            return systemone_ollama(entry, state, question)
+        if t == "openrouter-decisions":
+            return openrouter_decisions(entry, state, question)
+        raise ValueError("unknown consult type")
+
+    p1 = None
+    try:
+        p1 = ask(cfg.get("primary") or {})
+    except Exception as e:
+        trace["primary_error"] = str(e)[:140]
+    if p1 is None:
+        cons = cfg.get("consults") or []
+        if cons:
+            try:
+                p1 = ask(cons[0])
+                trace["primary_source"] = cons[0].get("name", "consult0")
+            except Exception as e:
+                trace["primary_error2"] = str(e)[:140]
+    if p1 is None:
+        trace["decision"] = "none"
+        return 0.0, trace
+    trace["primary"] = round(p1, 4)
+
+    if p1 >= accept:
+        trace["decision"] = "accept"
+        return p1, trace
+    if p1 < consult:
+        trace["decision"] = "review-low"
+        return p1, trace
+
+    ps = []
+    for c in (cfg.get("consults") or []):
+        name = c.get("name") or c.get("model") or "consult"
+        if trace.get("primary_source") == name:
+            continue
+        try:
+            p = ask(c)
+        except Exception as e:
+            p = None
+            trace["consults"][name + "_error"] = str(e)[:80]
+        trace["consults"][name] = None if p is None else round(p, 4)
+        if p is not None:
+            ps.append((name, p))
+
+    confident = [(n, p) for n, p in ps if max(p, 1 - p) >= high]
+    if len(confident) >= 2:
+        directions = {p >= 0.5 for _, p in confident}
+        if len(directions) == 1:
+            avg = sum(p for _, p in confident) / len(confident)
+            trace["decision"] = "consensus-accept" if avg >= 0.5 else "consensus-reject"
+            return avg, trace
+        trace["decision"] = "review-conflict"
+        return p1, trace
+    if len(confident) == 1:
+        cn, _ = confident[0]
+        others = [(n, p) for n, p in ps if n != cn]
+        if any(abs(p - p1) <= delta for _, p in others):
+            trace["decision"] = "review-conflict"
+        else:
+            trace["decision"] = "review-weak"
+        return p1, trace
+    trace["decision"] = "review-no-signal"
+    return p1, trace

eyewright/generative.py

@@ -0,0 +1,117 @@
+"""eyewright generative engine - a general-model adjudicator behind ``ask``.
+
+The typed engines (the laya/tev1 committee) answer the System One shape inside
+their training distribution. This engine covers questions outside it: a local
+generative model is asked with a strict JSON contract
+
+    {"answer": <"yes"|"no"|option key|level index>, "confidence": 0.0-1.0, "reason": "..."}
+
+Confidence is the model's own estimate -> **not calibrated yet**. Ticket path D
+(decide-engine shootout) covers post-hoc calibration; until then the result
+carries ``"calibrated": false`` so callers can treat it accordingly.
+
+Engine config (inside the gate config):
+
+    "generative": {"type": "ollama", "model": "gemma4:12b",
+                   "options": {"temperature": 0, "num_predict": 200},
+                   "think": false}
+"""
+
+import json
+import re
+
+from .decide import _post_json
+
+
+def _ollama_chat(model, messages, options=None, fmt="json", think=None, timeout=1800):
+    payload = {
+        "model": model,
+        "messages": messages,
+        "stream": False,
+        "format": fmt,
+        "options": {"temperature": 0, **(options or {})},
+    }
+    if think is not None:
+        payload["think"] = bool(think)
+    resp = _post_json("http://localhost:11434/api/chat", payload, timeout=timeout)
+    return (resp.get("message") or {}).get("content", "") or ""
+
+
+def _extract_json(text):
+    m = re.search(r"\{.*\}", text, re.S)
+    if not m:
+        return None
+    try:
+        return json.loads(m.group(0))
+    except Exception:
+        return None
+
+
+def _prompt(state, question, choices, levels):
+    if choices:
+        opts = "\n".join(f"- {k}: {v}" for k, v in choices.items())
+        answer_rule = "exactly one of these option keys: " + ", ".join(choices)
+    elif levels:
+        opts = "\n".join(f"- {i}: {v}" for i, v in enumerate(levels))
+        answer_rule = "the 0-based index of the best level"
+    else:
+        opts = "(none)"
+        answer_rule = '"yes" or "no"'
+    return (
+        "You are a decision engine. Answer with a single JSON object and nothing else:\n"
+        '{"answer": <answer>, "confidence": <0.0-1.0>, "reason": "<one short sentence>"}\n\n'
+        f'Rules: "answer" must be {answer_rule}. "confidence" is your estimated\n'
+        "probability that the answer is correct. Base the answer only on the state.\n\n"
+        f"STATE:\n{state}\n\nQUESTION:\n{question}\n\nOPTIONS:\n{opts}"
+    )
+
+
+def ask_generative(cfg, state, question, choices=None, levels=None, kind=None):
+    """One decision from the configured generative model (raw, uncalibrated)."""
+    g = cfg.get("generative") or {}
+    if not g:
+        raise ValueError("config has no 'generative' block")
+    kind = kind or ("choice" if choices else "score" if levels else "noul")
+    model = g.get("model") or "gemma4:12b"
+    content = _ollama_chat(
+        model,
+        [{"role": "user", "content": _prompt(state, question, choices, levels)}],
+        options=g.get("options"),
+        fmt=g.get("format", "json"),
+        think=g.get("think"),
+    )
+    obj = _extract_json(content) or {}
+    answer = obj.get("answer")
+    conf = obj.get("confidence")
+
+    if kind == "noul" and isinstance(answer, str):
+        a = answer.strip().lower()
+        if a.startswith("y"):
+            answer = "yes"
+        elif a.startswith("n"):
+            answer = "no"
+    if kind == "choice" and choices:
+        if isinstance(answer, str):
+            match = next((k for k in choices if k.lower() == answer.strip().lower()), None)
+            if match is None:
+                match = next((k for k in choices if k.lower() in answer.lower()), None)
+            answer = match
+    if kind == "score":
+        try:
+            answer = int(answer)
+        except (TypeError, ValueError):
+            pass
+    try:
+        conf = round(float(conf), 4) if conf is not None else None
+    except (TypeError, ValueError):
+        conf = None
+    return {
+        "kind": kind,
+        "answer": answer,
+        "confidence": conf,
+        "reason": obj.get("reason"),
+        "model": model,
+        "calibrated": False,
+        "engine": "generative",
+        "raw": content[:600],
+    }

eyewright/mcp_server.py

@@ -0,0 +1,45 @@
+"""eyewright mcp - eyewright as MCP tools for any AI harness.
+
+Tools:
+  eyewright_gate(state, question)          -> three-eye gate: p_done + decision + trace
+  eyewright_ask(state, question, choices?) -> typed decision (yes/no, or pick a choice)
+
+Run as a stdio MCP server: ``eyewright mcp`` (needs the ``mcp`` extra:
+``uv run --extra mcp eyewright mcp``).
+"""
+
+from mcp.server.mcpserver import MCPServer
+
+from .decide import ask
+from .gate import decide_gate
+
+
+def build(cfg):
+    mcp = MCPServer("eyewright")
+
+    @mcp.tool()
+    def eyewright_gate(state: str, question: str) -> dict:
+        """Gate a claim against the eyewright committee.
+
+        Returns p_done, the policy decision (accept / consensus-* / review-*),
+        and the full consult trace.
+        """
+        p, trace = decide_gate(cfg, state, question)
+        return {"p_done": round(p, 4), "decision": trace.get("decision"), "trace": trace}
+
+    @mcp.tool()
+    def eyewright_ask(state: str, question: str, choices: dict | None = None, engine: str | None = None) -> dict:
+        """Ask eyewright a typed decision.
+
+        With `choices` (option -> description) it picks an option; without, it is a
+        yes/no judgment. `engine`: None/typed (decision models), "generative" (local
+        LLM adjudicator, uncalibrated), or "auto" (typed, fall back to generative).
+        Returns answer, confidence, and the trace.
+        """
+        return ask(cfg, state, question, choices=choices, engine=engine)
+
+    return mcp
+
+
+def run(cfg):
+    build(cfg).run()

eyewright/server.py

@@ -0,0 +1,68 @@
+"""eyewright serve - one local HTTP endpoint for decisions.
+
+Endpoints:
+  GET  /health
+  POST /v1/gate   {"state": str, "question": str}                    -> {p_done, decision, trace}
+  POST /v1/ask    {"state": str, "question": str, "choices"?: {...}} -> answer dict
+
+Loopback-only by default (no auth on 127.0.0.1). Config is a JSON file with the
+gate config (primary + consults); see examples/gate.json.
+"""
+
+import json
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from . import __version__
+from .decide import ask
+from .gate import decide_gate
+
+
+def make_handler(cfg):
+    class Handler(BaseHTTPRequestHandler):
+        server_version = f"eyewright/{__version__}"
+
+        def _send(self, code, obj):
+            body = json.dumps(obj, ensure_ascii=False).encode()
+            self.send_response(code)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_GET(self):
+            if self.path in ("/health", "/"):
+                self._send(200, {"status": "ok", "service": "eyewright", "version": __version__})
+            else:
+                self._send(404, {"error": "not found"})
+
+        def do_POST(self):
+            try:
+                n = int(self.headers.get("Content-Length") or 0)
+                body = json.loads(self.rfile.read(n).decode() or "{}")
+            except Exception as e:
+                self._send(400, {"error": f"bad json: {e}"})
+                return
+            try:
+                if self.path == "/v1/gate":
+                    p, trace = decide_gate(cfg, body.get("state", ""), body.get("question", ""))
+                    self._send(200, {"p_done": round(p, 4), "decision": trace.get("decision"), "trace": trace})
+                elif self.path == "/v1/ask":
+                    out = ask(cfg, body.get("state", ""), body.get("question", ""),
+                              choices=body.get("choices"), levels=body.get("levels"),
+                              engine=body.get("engine"))
+                    self._send(200, out)
+                else:
+                    self._send(404, {"error": "not found"})
+            except Exception as e:
+                self._send(500, {"error": str(e)[:300]})
+
+        def log_message(self, fmt, *args):
+            print("[eyewright] " + fmt % args)
+
+    return Handler
+
+
+def serve(cfg, host="127.0.0.1", port=8090):
+    httpd = ThreadingHTTPServer((host, port), make_handler(cfg))
+    print(f"eyewright serving on http://{host}:{port}  (gate: /v1/gate, ask: /v1/ask)")
+    httpd.serve_forever()

eyewright-0.3.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.5
+Name: eyewright
+Version: 0.3.0
+Summary: eyewright - local decision core: three-eye gate + one-call typed decisions
+Requires-Python: >=3.12
+Provides-Extra: mcp
+Requires-Dist: mcp>=2; extra == 'mcp'

eyewright-0.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+eyewright/__init__.py,sha256=sh3Fc5Namc5qXprcmMnyPVxylTz6Ncp5gRwB_4LAQ-Y,221
+eyewright/cli.py,sha256=D3mV9EHmk2Ua8NYB5RUW8QMBl9TL9USHCeNTIIp4o0I,2557
+eyewright/decide.py,sha256=EcXlj_7EMBlrZHv54wa8kp8D_O5X056n964bs9I4cJ0,5419
+eyewright/gate.py,sha256=Bfxm4v9v2ML0E-a8zRDk-jYYrdFZCJiZ8R57u8r_kLM,6572
+eyewright/generative.py,sha256=3JcTla35LftIRM60rFkvIRA3AW37TmfBVMLWVRXGmkM,4172
+eyewright/mcp_server.py,sha256=LM-wKOWfk8NP7AKbJvS4_xAYwiH3szR38Cn_NIeTOEA,1531
+eyewright/server.py,sha256=us6MSj-N6EtsR-_8URk8XgkTSk7s_zHMzAbwi_48jzk,2664
+eyewright-0.3.0.dist-info/METADATA,sha256=jiBkZi3W9NJAawlW8MPQMgPxX3qy75sB_j-L5t8RyY4,219
+eyewright-0.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+eyewright-0.3.0.dist-info/entry_points.txt,sha256=JC9Ggj4qmC3mJXdbJn26NKekvbwUNgm_DqHzP9Dpde4,49
+eyewright-0.3.0.dist-info/RECORD,,

eyewright-0.3.0.dist-info/WHEEL

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

eyewright-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eyewright = eyewright.cli:main