doloopio 0.1.0__py3-none-any.whl

doloop/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

doloop/cli.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+doloop — the resistance machine, from the CLI.
+
+A thin client: it sends your AI's output to the doloop machine and gets back a
+deterministic verdict (same input, same verdict, every time). The donkey rules
+stay server-side; this client never holds them. Bring your own key.
+
+Install:  pip install doloopio
+Auth:     export DOLOOP_KEY=dlp_...        (get one at https://api.doloop.io/dashboard)
+Usage:
+  doloop loops                              # loops remaining on your key
+  doloop check "the answer your model produced"
+  doloop check -f answer.txt                # check a file
+  echo "..." | doloop check                 # check stdin
+  doloop check --donkey conversations "User: ...\nBot: ..."
+  doloop design https://example.com         # design review of a live URL (when live)
+"""
+import sys, os, json, urllib.request, urllib.error
+
+API = os.environ.get("DOLOOP_API", "https://api.doloop.io")
+KEY = os.environ.get("DOLOOP_KEY", "")
+
+
+def req(method, path, body=None):
+    data = json.dumps(body).encode() if body is not None else None
+    r = urllib.request.Request(API + path, data=data, method=method)
+    r.add_header("content-type", "application/json")
+    if KEY:
+        r.add_header("Authorization", "Bearer " + KEY)
+    try:
+        with urllib.request.urlopen(r, timeout=40) as resp:
+            return resp.status, json.loads(resp.read().decode() or "{}"), dict(resp.headers)
+    except urllib.error.HTTPError as e:
+        try:
+            return e.code, json.loads(e.read().decode() or "{}"), dict(e.headers)
+        except Exception:
+            return e.code, {}, {}
+    except Exception as e:
+        return 0, {"error": str(e)}, {}
+
+
+def _text(args):
+    if "-f" in args:
+        return open(args[args.index("-f") + 1], encoding="utf-8").read()
+    pos = [a for i, a in enumerate(args)
+           if not a.startswith("-") and (i == 0 or args[i - 1] not in ("-f", "--donkey"))]
+    if pos:
+        return pos[-1]
+    if not sys.stdin.isatty():
+        return sys.stdin.read()
+    return None
+
+
+def cmd_check(args):
+    donkey = args[args.index("--donkey") + 1] if "--donkey" in args else "writing"
+    text = _text(args)
+    if not text:
+        sys.exit("nothing to check. pass text, -f file, or pipe stdin.")
+    st, body, hdr = req("POST", "/v1/check", {"text": text, "donkey": donkey})
+    print(json.dumps(body, indent=2))
+    rem = hdr.get("x-doloop-loops-remaining") or hdr.get("X-Doloop-Loops-Remaining")
+    if rem:
+        print("loops remaining: " + rem, file=sys.stderr)
+    sys.exit(0 if body.get("verdict") == "pass" else 2)
+
+
+def cmd_design(args):
+    url = next((a for a in args if a.startswith("http")), None)
+    if not url:
+        sys.exit("usage: doloop design https://your-url")
+    st, body, _ = req("POST", "/v1/check-design", {"url": url})
+    if st == 404:
+        sys.exit("the design endpoint is not live yet on this machine.")
+    print(json.dumps(body, indent=2))
+    sys.exit(0 if body.get("verdict") == "pass" else 2)
+
+
+def cmd_loops(args):
+    if not KEY:
+        sys.exit("set DOLOOP_KEY=dlp_... (get one at https://api.doloop.io/dashboard)")
+    st, body, _ = req("GET", "/v1/balance")
+    if st == 401:
+        sys.exit("key not recognized. check DOLOOP_KEY.")
+    n = body.get("loops_remaining")
+    print(f"{n:,} loops remaining" if isinstance(n, int) else json.dumps(body))
+
+
+def main():
+    args = sys.argv[1:]
+    cmd = args[0] if args else "help"
+    rest = args[1:]
+    if cmd == "check":
+        cmd_check(rest)
+    elif cmd == "design":
+        cmd_design(rest)
+    elif cmd in ("loops", "balance"):
+        cmd_loops(rest)
+    else:
+        print(__doc__.strip())
+
+
+if __name__ == "__main__":
+    main()

doloopio-0.1.0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: doloopio
+Version: 0.1.0
+Summary: The doloop resistance machine: deterministic checks for AI output, from the CLI.
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# doloop machine
+
+An external, **deterministic** check you put between your AI and your users. Send it an output, get back an **objective verdict** — the same verdict every time. You bring your own model; the machine never touches it.
+
+> Docs only. No product code lives here — just how to call the machine and copy-paste examples.
+
+**Base URL:** `https://api.doloop.io`
+
+## Use doloop when…
+
+| Your problem | Call | What you get |
+|---|---|---|
+| Your agent **loops** or repeats itself | `POST /v1/check` | findings flag the repetition; `verdict: fail` (a model in a loop can't see its own loop — doloop can) |
+| Output **drifts** or slides back to a bug it just fixed | `POST /v1/check` | the drift caught from outside |
+| The model pads with **slop**, hedges, jargon | `POST /v1/check` | each tell flagged with a line |
+| A **number isn't in the source**, a total won't reconcile | `documents` donkey | tie-out failure |
+| You need the **same verdict every time** (audit) | `POST /v1/check` | `input_sha256` — reproducible, provable |
+| You want a human to review **only the failures** | gate on `verdict` | triage, not every line |
+
+## The four donkeys
+
+A donkey is a deterministic check for one kind of output.
+
+| Donkey | Catches | Surface |
+|---|---|---|
+| `writing` | de-slop: dead prose, jargon, self-management tics, flat cadence | https://writing.doloop.io |
+| `conversations` | de-sycophant, de-loop: agreement drift, dialogue going in circles | https://conversations.doloop.io |
+| `presentations` | land-the-finding: slides that bury the point or don't match the data | https://presentations.doloop.io |
+| `documents` | tie-out: a number not in the source, a total that won't reconcile | https://documents.doloop.io |
+
+```bash
+curl https://api.doloop.io/v1/donkeys
+```
+
+## Quickstart
+
+```bash
+curl https://api.doloop.io/v1/check \
+  -H 'content-type: application/json' \
+  -d '{"text": "the answer your model just produced"}'
+```
+
+```json
+{ "verdict": "pass", "finding_count": 0, "findings": [], "input_sha256": "..." }
+```
+
+Same text in, same verdict out, every time. `input_sha256` proves it: identical input gives an identical hash gives an identical verdict. **Objective, not subjective** — unlike an AI judge that scores the same answer 77% one run and 63% the next.
+
+## How people use it
+
+1. **Gate before ship** — check the output; if `verdict: fail`, don't ship it.
+2. **Self-heal loop** (the "doloop") — check → on fail, feed `findings` back to your model → re-check → ship on pass. See [`examples/loop.py`](examples/loop.py).
+3. **In-agent self-check** — the agent checks its own step output to catch the loop/drift it can't see itself. See [`examples/agent_check.py`](examples/agent_check.py).
+4. **BYOL proxy** — point an OpenAI-compatible `base_url` at the machine; the verdict rides back on every response. See [`examples/proxy.py`](examples/proxy.py).
+5. **CI gate** — run a corpus through the donkeys; fail the build on a regression. See [`examples/ci_check.sh`](examples/ci_check.sh).
+
+## Endpoints
+
+| Method | Path | Does |
+|---|---|---|
+| `POST` | `/v1/check` | deterministic verdict on text |
+| `GET` | `/v1/donkeys` | list the four donkeys |
+| `POST` | `/v1/chat/completions` | OpenAI-compatible BYOL proxy with the verdict attached |
+| `GET` | `/health` | liveness |
+
+Machine-readable spec: [`openapi.json`](openapi.json). LLM index: [`llms.txt`](llms.txt). Pricing and the loop calculator: [`PRICING.md`](PRICING.md).
+
+## What it is
+
+doloop is the **Deterministic Objective Loop**: the external checker a model can't be for itself, because a model in a loop can't see its own loop. Bring your model; doloop returns the verdict it can't give itself.

doloopio-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+doloop/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+doloop/cli.py,sha256=lTkpS379-v7b13xIEwogw2DTBnJjSTEh8Vzr8WBFrkM,3703
+doloopio-0.1.0.dist-info/licenses/LICENSE,sha256=kK6T4YXtbHYi3Ug0FvyXhzK8gS-9d-O_LOHBd5BbY2A,1071
+doloopio-0.1.0.dist-info/METADATA,sha256=7l_OMElULeFXHtIpVX8KyHd4wjG1makWwUWYLC4MYAw,3976
+doloopio-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+doloopio-0.1.0.dist-info/entry_points.txt,sha256=sGdmTntk1puGUriaeJOVoAzGUSPvv_qsu7e3GFGdSbs,43
+doloopio-0.1.0.dist-info/top_level.txt,sha256=IugLGCJg-Xvdv0H09PgoYj6uljcBXuRL9kym9RrlG5g,7
+doloopio-0.1.0.dist-info/RECORD,,

doloopio-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

doloopio-0.1.0.dist-info/entry_points.txt

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

doloopio-0.1.0.dist-info/licenses/LICENSE

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

doloopio-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+doloop