datasheets-md 2.0.0a11__tar.gz

datasheets_md-2.0.0a11/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: datasheets-md
+Version: 2.0.0a11
+Summary: dsmd: a git-like working copy of your datasheets.md workspace (parameters, pins, CAD config, KiCad library)
+Author: datasheets.md
+License-Expression: MIT
+Project-URL: Homepage, https://datasheets.md
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Requires-Dist: packaging>=22
+Requires-Dist: platformdirs>=3
+Requires-Dist: pyyaml>=6
+Requires-Dist: tomli>=2; python_version < "3.11"
+Provides-Extra: gui
+Requires-Dist: PySide6>=6.6; extra == "gui"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+
+# datasheets-md (`dsmd`, dBsync)
+
+A git-like working copy of your [datasheets.md](https://datasheets.md) workspace:
+the parts' unified parameters, pin tables and CAD configuration as plain text
+files you can grep, edit and push back, plus the workspace's KiCad library.
+
+```bash
+pip install datasheets-md             # the dsmd CLI
+pip install datasheets-md-gui         # CLI + the dBsync desktop app (adds PySide6 to an existing install)
+```
+
+Ubuntu/Debian refuse a system-wide `pip install` ("externally-managed-environment").
+Install into a venv and link the command onto your PATH:
+
+```bash
+python3 -m venv ~/.venvs/dsmd && ~/.venvs/dsmd/bin/pip install datasheets-md
+ln -s ~/.venvs/dsmd/bin/dsmd ~/.local/bin/dsmd
+```
+
+or let pipx do both: `pipx install datasheets-md`.
+
+`dsmd` looks for a new release once a day and prints one line when there is
+one. `dsmd self-update` upgrades the install the way it was made (pipx, uv tool,
+or the pip of its venv). Set `DSMD_NO_UPDATE_CHECK=1` to turn the check off; it
+also stays off under `CI`, with `--json` or `--quiet`, and when stderr is not a
+terminal.
+
+A clone of a large workspace can stop part way (network, Ctrl-C, a closed laptop)
+without losing what it downloaded: files reach the disk as they arrive, and running
+the same `dsmd clone` command again continues it. Until it finishes, `dsmd status`
+says so and `fetch`, `pull` and `push` refuse. If only the library step fails, the
+parts and datasheets are in place, `dsmd` exits with code 2, and `dsmd pull --library`
+(or the next `dsmd pull`) builds `library/`.
+
+## Use
+
+```bash
+dsmd login                            # browser sign-in (DSMD_TOKEN=dsh_... for headless use)
+dsmd workspaces                       # pick one
+dsmd clone "My workspace" lib && cd lib
+dsmd status                           # what you changed
+dsmd diff                             # ... as a diff
+dsmd push -m "Fix VOH typ from page 5"
+dsmd pull                             # server changes, merged row by row
+dsmd log [PART]                       # server-side history
+dsmd part add SN74HC00N [--manufacturer TI]
+dsmd part rm SN74HC00N
+dsmd pdf SN74HC00N                    # PDF into .dsmd/cache/
+dsmd open SN74HC00N                   # the part's web page
+dsmd categories                       # catalogue category ids, for settings/mapping.yaml
+dsmd feedback "a setting I need"      # tell the datasheets.md team (--kind bug|suggestion)
+dsmd gui                              # the desktop app (needs datasheets-md-gui)
+dsmd self-update                      # upgrade to the latest release (--check only asks)
+dsmd help agents                      # the guide for AI agents
+```
+
+Every command takes `--json`, `--quiet` and `-C <dir>`. Exit codes: `0` ok,
+`1` error, `2` done but with conflicts or stale/rejected parts.
+
+`DSMD_SERVER` (or `--server`) points at another instance, e.g.
+`https://api-dev.datasheets.md`.
+
+## The working copy
+
+```
+.dsmd/                        state, pristine base copies, cache (gitignored)
+dsmd.toml                     what to pull, which library outputs to build
+settings/mapping.yaml         workspace mapping (categories, parameter names, CAD fields) -- editable, admin
+settings/symbol_style.yaml    symbol generation settings and reference designators     -- editable, admin
+parts/<MFR>/<PN>/
+  part.yaml                   identity, and `datasheet:` -> its datasheet.md (read-only)
+  parameters.jsonl            unified parameters, one row per line  -- editable
+  pins.csv                    physical pins, one per line           -- editable
+  cad.yaml                    CAD configuration                     -- editable
+datasheets/<MFR>/<PDF name>/  one per family, shared by its parts
+  datasheet.md                digitised datasheet with its element ids (read-only)
+  images/                     the figures datasheet.md links to (read-only)
+library/                      generated KiCad library (rebuilt on pull)
+  datasheets.sqlite, datasheets.kicad_dbl, datasheets.kicad_sym,
+  datasheets.pretty/, sym-lib-table, fp-lib-table
+```
+
+How it differs from git: one remote, no branches, no staging or local commits.
+`push` is applied atomically per part; the server may normalise what you
+pushed and sends the result straight back. Merges are by row key (`k`) and pin
+`id`, so edits to different rows never conflict. History lives on the server.
+
+To use the library in KiCad, open `library/` as a project folder (the lib
+tables point at the symbols and footprints) or add `datasheets.kicad_dbl`
+as a database library (needs the SQLite ODBC driver).
+
+## Develop
+
+```bash
+pip install -e ".[gui,test]"
+pytest
+```
+
+Standalone dBsync binaries (no Python needed) are built by
+`.github/workflows/build.yml` with PyInstaller from `packaging/dbsync.py`.

datasheets_md-2.0.0a11/README.md

@@ -0,0 +1,100 @@
+# datasheets-md (`dsmd`, dBsync)
+
+A git-like working copy of your [datasheets.md](https://datasheets.md) workspace:
+the parts' unified parameters, pin tables and CAD configuration as plain text
+files you can grep, edit and push back, plus the workspace's KiCad library.
+
+```bash
+pip install datasheets-md             # the dsmd CLI
+pip install datasheets-md-gui         # CLI + the dBsync desktop app (adds PySide6 to an existing install)
+```
+
+Ubuntu/Debian refuse a system-wide `pip install` ("externally-managed-environment").
+Install into a venv and link the command onto your PATH:
+
+```bash
+python3 -m venv ~/.venvs/dsmd && ~/.venvs/dsmd/bin/pip install datasheets-md
+ln -s ~/.venvs/dsmd/bin/dsmd ~/.local/bin/dsmd
+```
+
+or let pipx do both: `pipx install datasheets-md`.
+
+`dsmd` looks for a new release once a day and prints one line when there is
+one. `dsmd self-update` upgrades the install the way it was made (pipx, uv tool,
+or the pip of its venv). Set `DSMD_NO_UPDATE_CHECK=1` to turn the check off; it
+also stays off under `CI`, with `--json` or `--quiet`, and when stderr is not a
+terminal.
+
+A clone of a large workspace can stop part way (network, Ctrl-C, a closed laptop)
+without losing what it downloaded: files reach the disk as they arrive, and running
+the same `dsmd clone` command again continues it. Until it finishes, `dsmd status`
+says so and `fetch`, `pull` and `push` refuse. If only the library step fails, the
+parts and datasheets are in place, `dsmd` exits with code 2, and `dsmd pull --library`
+(or the next `dsmd pull`) builds `library/`.
+
+## Use
+
+```bash
+dsmd login                            # browser sign-in (DSMD_TOKEN=dsh_... for headless use)
+dsmd workspaces                       # pick one
+dsmd clone "My workspace" lib && cd lib
+dsmd status                           # what you changed
+dsmd diff                             # ... as a diff
+dsmd push -m "Fix VOH typ from page 5"
+dsmd pull                             # server changes, merged row by row
+dsmd log [PART]                       # server-side history
+dsmd part add SN74HC00N [--manufacturer TI]
+dsmd part rm SN74HC00N
+dsmd pdf SN74HC00N                    # PDF into .dsmd/cache/
+dsmd open SN74HC00N                   # the part's web page
+dsmd categories                       # catalogue category ids, for settings/mapping.yaml
+dsmd feedback "a setting I need"      # tell the datasheets.md team (--kind bug|suggestion)
+dsmd gui                              # the desktop app (needs datasheets-md-gui)
+dsmd self-update                      # upgrade to the latest release (--check only asks)
+dsmd help agents                      # the guide for AI agents
+```
+
+Every command takes `--json`, `--quiet` and `-C <dir>`. Exit codes: `0` ok,
+`1` error, `2` done but with conflicts or stale/rejected parts.
+
+`DSMD_SERVER` (or `--server`) points at another instance, e.g.
+`https://api-dev.datasheets.md`.
+
+## The working copy
+
+```
+.dsmd/                        state, pristine base copies, cache (gitignored)
+dsmd.toml                     what to pull, which library outputs to build
+settings/mapping.yaml         workspace mapping (categories, parameter names, CAD fields) -- editable, admin
+settings/symbol_style.yaml    symbol generation settings and reference designators     -- editable, admin
+parts/<MFR>/<PN>/
+  part.yaml                   identity, and `datasheet:` -> its datasheet.md (read-only)
+  parameters.jsonl            unified parameters, one row per line  -- editable
+  pins.csv                    physical pins, one per line           -- editable
+  cad.yaml                    CAD configuration                     -- editable
+datasheets/<MFR>/<PDF name>/  one per family, shared by its parts
+  datasheet.md                digitised datasheet with its element ids (read-only)
+  images/                     the figures datasheet.md links to (read-only)
+library/                      generated KiCad library (rebuilt on pull)
+  datasheets.sqlite, datasheets.kicad_dbl, datasheets.kicad_sym,
+  datasheets.pretty/, sym-lib-table, fp-lib-table
+```
+
+How it differs from git: one remote, no branches, no staging or local commits.
+`push` is applied atomically per part; the server may normalise what you
+pushed and sends the result straight back. Merges are by row key (`k`) and pin
+`id`, so edits to different rows never conflict. History lives on the server.
+
+To use the library in KiCad, open `library/` as a project folder (the lib
+tables point at the symbols and footprints) or add `datasheets.kicad_dbl`
+as a database library (needs the SQLite ODBC driver).
+
+## Develop
+
+```bash
+pip install -e ".[gui,test]"
+pytest
+```
+
+Standalone dBsync binaries (no Python needed) are built by
+`.github/workflows/build.yml` with PyInstaller from `packaging/dbsync.py`.

datasheets_md-2.0.0a11/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "datasheets-md"
+dynamic = ["version"]
+description = "dsmd: a git-like working copy of your datasheets.md workspace (parameters, pins, CAD config, KiCad library)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "datasheets.md" }]
+dependencies = [
+    "requests>=2.31",
+    "packaging>=22",
+    "platformdirs>=3",
+    "pyyaml>=6",
+    "tomli>=2; python_version < '3.11'",
+]
+
+[project.optional-dependencies]
+gui = ["PySide6>=6.6"]
+test = ["pytest>=8"]
+
+[project.scripts]
+dsmd = "datasheets_md.cli:main"
+datasheets-md = "datasheets_md.cli:main"
+
+[project.urls]
+Homepage = "https://datasheets.md"
+
+[tool.setuptools.dynamic]
+version = { attr = "datasheets_md.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+datasheets_md = ["agents.md", "gui/icon.png"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

datasheets_md-2.0.0a11/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

datasheets_md-2.0.0a11/src/datasheets_md/__init__.py

@@ -0,0 +1,4 @@
+"""datasheets-md: the `dsmd` CLI and the dBsync GUI on one sync engine."""
+
+__version__ = "2.0.0a11"
+APP_NAME = "dBsync"

datasheets_md-2.0.0a11/src/datasheets_md/agents.md

@@ -0,0 +1,88 @@
+# dsmd for agents
+
+`dsmd` keeps a folder in sync with a datasheets.md workspace. Use it from a
+shell; add `--json` to any command for machine-readable output.
+
+## Loop
+
+1. `dsmd pull` -- bring the working copy up to date.
+2. Find what to change with grep, e.g. `grep -rn '"VOH"' parts/`.
+3. Edit only these files:
+   - `parts/<MFR>/<PN>/parameters.jsonl` -- one parameter row per line.
+   - `parts/<MFR>/<PN>/pins.csv` -- one physical pin per line.
+   - `parts/<MFR>/<PN>/cad.yaml` -- the part's CAD configuration.
+   - `settings/mapping.yaml`, `settings/symbol_style.yaml` -- the workspace's
+     settings (see below; owner or admin only).
+4. `dsmd diff` -- and show the diff to the user before pushing.
+5. `dsmd push -m "<what changed and why>"`.
+6. Exit code 2 from `clone` or `pull` with a `library/ was not built` warning means the parts and
+   datasheets are in place; run `dsmd pull --library` to retry. A clone that stopped continues when you
+   run the same command again. Exit code 2 from `push` means some parts were not applied: read the per-part lines
+   (`stale` -> run `dsmd pull`, then push again; `rejected` -> fix the named
+   `file:line` and push again).
+
+## Rules
+
+- Keep `k` (parameters.jsonl) and `id` (pins.csv) unchanged on rows you edit;
+  they are how the server knows which row you mean. A new row has no `k`; a
+  new pin has an empty `id`.
+- A part's digitised PDF is the `datasheet.md` that `datasheet:` in its
+  `part.yaml` points at (`datasheets/<manufacturer>/<pdf name>/`, one per
+  family, shared by every part of it; null until the PDF is digitised). Its
+  `{{para:<id> ...}}`, `{{table:<id> ...}}`, `{{row:<id> ...}}` and
+  `{{figure:<id> ...}}` markers carry the element ids that a row's
+  `source.element_id` cites; figures are PNGs in `images/` next to it.
+  `dsmd pdf <part>` downloads the original PDF.
+- When you correct a value, set `source` to the element you read it from:
+  `"source": {"element_id": "<id>"}`.
+- To confirm a row is right, change its `review` from `unchecked` to
+  `confirmed`. Unconfirming is not supported.
+- Never edit `library/` (generated), `part.yaml` or `datasheet.md`
+  (read-only); `push` refuses them. `dsmd restore <path>` undoes a local edit.
+- Conflict markers (`<<<<<<< local` / `=======` / `>>>>>>> server`) after a
+  pull surround one row (or, in a YAML file, the whole file): keep the right
+  side, delete the markers, push.
+
+## Workspace settings
+
+Both files are YAML, pushed with the parts (settings first, so a category you
+add is there for the parts in the same push). The server validates them like
+the web settings pages and answers `rejected` with the reason.
+
+`settings/mapping.yaml` -- how the workspace names and groups things (it
+drives the web app, comparisons, the API, the MCP server and the CAD exports
+listed in `used_by`):
+- `custom_categories`: your category names; `category_parents`:
+  `{child: parent}` to nest them.
+- `category_map`: `{catalogue category id: your category}`. `dsmd categories`
+  lists the catalogue's ids and names.
+- `parameter_map`: `{your category: {parameter: {name, unit, export, ...}}}`
+  -- rename a parameter, set its unit, choose whether it is exported; a
+  column you invent has `custom: true` and may carry a fixed `value`.
+- `custom_parameters`: `{name: {unit, units?, kind?, shortcut?}}`;
+  `custom_units`: `[{symbol, name?}]`.
+- `cad_fields`: `{kicad: [...]}` -- the properties each KiCad symbol gets.
+- `used_by`: which outputs use this mapping (`web_app`, `comparisons`,
+  `kicad_export`, `concept_hdl_export`, `altium_export`, `rest_api`,
+  `mcp_server`).
+
+`settings/symbol_style.yaml` -- how symbols are generated:
+- `style`: the workspace's overrides of `reference.system_style` (only the
+  keys you want different; unknown keys are rejected).
+- `categories`: `{category: style overrides}` for one category; an empty
+  value removes the override. Category names are your mapping's categories
+  or catalogue category names.
+- `designator_options`: the reference designators the workspace uses,
+  `[{id, say, value?}]` (`value` = the parameter shown as the symbol's
+  Value), or null for `reference.system_designator_options`.
+- `reference_designators`: `{category: designator}`.
+- `version` and `reference` are for reading only.
+
+## When something is missing
+
+If a setting, parameter, category or command you need does not exist, or the
+server refuses something that should work, tell the datasheets.md team:
+
+    dsmd feedback --kind suggestion "what you tried, what you needed"
+
+Use `--kind bug` for something broken. Then tell the user you sent it.

datasheets_md-2.0.0a11/src/datasheets_md/auth.py

@@ -0,0 +1,216 @@
+"""Sign-in for dsmd and the GUI (Spec 27a 3.2).
+
+Browser OAuth against main-api's authorization server: dynamic client
+registration once per server, PKCE S256, and a loopback redirect on a free
+port. Credentials live in the user config dir (mode 0600), keyed by server.
+`DSMD_TOKEN` (a `dsh_` key) overrides them for headless use, `DSMD_SERVER`
+the server.
+"""
+import base64
+import hashlib
+import http.server
+import json
+import os
+import secrets
+import threading
+import time
+import urllib.parse
+import webbrowser
+from pathlib import Path
+
+import platformdirs
+import requests
+
+DEFAULT_SERVER = "https://api.datasheets.md"
+CLIENT_NAME = "dsmd"
+REDIRECT_PATH = "/callback"
+LOGIN_TIMEOUT = 300
+# Refresh this long before the access token expires.
+EXPIRY_MARGIN = 60
+
+
+class AuthError(Exception):
+    pass
+
+
+def credentials_path():
+    return Path(platformdirs.user_config_dir("datasheets-md")) / "credentials.json"
+
+
+def _load():
+    path = credentials_path()
+    try:
+        return json.loads(path.read_text())
+    except (OSError, ValueError):
+        return {"servers": {}}
+
+
+def _save(data):
+    path = credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as fh:
+        json.dump(data, fh, indent=2)
+    os.replace(tmp, path)
+
+
+def default_server(explicit=None):
+    """--server, else DSMD_SERVER, else the server last signed in to, else production."""
+    return (explicit or os.environ.get("DSMD_SERVER") or _load().get("default_server") or DEFAULT_SERVER).rstrip("/")
+
+
+def metadata(server):
+    resp = requests.get(f"{server}/.well-known/oauth-authorization-server", timeout=30)
+    if resp.status_code != 200:
+        raise AuthError(f"{server} does not offer sign-in (HTTP {resp.status_code})")
+    return resp.json()
+
+
+class Credentials:
+    """The bearer for one server: DSMD_TOKEN when set, else the stored OAuth tokens."""
+
+    def __init__(self, server):
+        self.server = server.rstrip("/")
+        self.env_token = os.environ.get("DSMD_TOKEN") or None
+
+    def stored(self):
+        return _load().get("servers", {}).get(self.server)
+
+    def token(self):
+        if self.env_token:
+            return self.env_token
+        entry = self.stored()
+        if not entry:
+            raise AuthError(f"not signed in to {self.server}; run dsmd login --server {self.server}")
+        if entry.get("expires_at", 0) - EXPIRY_MARGIN < time.time():
+            self.refresh()
+            entry = self.stored() or entry
+        return entry["access_token"]
+
+    def refresh(self):
+        """Renew the access token with the refresh token; False when there is nothing to renew with."""
+        if self.env_token:
+            return False
+        data = _load()
+        entry = data.get("servers", {}).get(self.server)
+        if not entry or not entry.get("refresh_token"):
+            return False
+        resp = requests.post(entry["token_endpoint"], data={
+            "grant_type": "refresh_token", "refresh_token": entry["refresh_token"],
+            "client_id": entry["client_id"]}, timeout=30)
+        if resp.status_code != 200:
+            return False
+        _store_tokens(data, self.server, entry, resp.json())
+        return True
+
+
+def _store_tokens(data, server, entry, tokens):
+    entry.update(access_token=tokens["access_token"],
+                 refresh_token=tokens.get("refresh_token") or entry.get("refresh_token"),
+                 expires_at=int(time.time()) + int(tokens.get("expires_in") or 3600))
+    data.setdefault("servers", {})[server] = entry
+    data["default_server"] = server
+    _save(data)
+
+
+def _pkce():
+    verifier = secrets.token_urlsafe(64)
+    challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).rstrip(b"=").decode()
+    return verifier, challenge
+
+
+class _Callback(http.server.BaseHTTPRequestHandler):
+    result = None
+
+    def do_GET(self):  # noqa: N802 -- http.server's name
+        parsed = urllib.parse.urlparse(self.path)
+        if parsed.path != REDIRECT_PATH:
+            self.send_response(404)
+            self.end_headers()
+            return
+        type(self).result = dict(urllib.parse.parse_qsl(parsed.query))
+        body = b"<html><body><h3>dsmd is signed in.</h3>You can close this window.</body></html>"
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, *args):
+        pass
+
+
+def login(server, *, open_browser=True, say=print):
+    """The browser flow. Returns the stored entry (without tokens)."""
+    server = server.rstrip("/")
+    meta = metadata(server)
+    data = _load()
+    entry = dict(data.get("servers", {}).get(server) or {})
+    if not entry.get("client_id"):
+        resp = requests.post(meta["registration_endpoint"], json={
+            "client_name": CLIENT_NAME, "redirect_uris": [f"http://127.0.0.1{REDIRECT_PATH}"],
+            "grant_types": ["authorization_code", "refresh_token"], "token_endpoint_auth_method": "none",
+        }, timeout=30)
+        if resp.status_code not in (200, 201):
+            raise AuthError(f"client registration failed (HTTP {resp.status_code}): {resp.text[:200]}")
+        entry["client_id"] = resp.json()["client_id"]
+    entry.update(token_endpoint=meta["token_endpoint"], revocation_endpoint=meta.get("revocation_endpoint"))
+
+    handler = type("Callback", (_Callback,), {"result": None})
+    httpd = http.server.HTTPServer(("127.0.0.1", 0), handler)
+    redirect_uri = f"http://127.0.0.1:{httpd.server_port}{REDIRECT_PATH}"
+    verifier, challenge = _pkce()
+    state = secrets.token_urlsafe(16)
+    url = meta["authorization_endpoint"] + "?" + urllib.parse.urlencode({
+        "response_type": "code", "client_id": entry["client_id"], "redirect_uri": redirect_uri,
+        "code_challenge": challenge, "code_challenge_method": "S256", "state": state})
+    say(f"Opening the browser to sign in. If it does not open, visit:\n  {url}")
+    if open_browser:
+        webbrowser.open(url)
+    thread = threading.Thread(target=_serve_until_called, args=(httpd, handler), daemon=True)
+    thread.start()
+    thread.join(LOGIN_TIMEOUT)
+    httpd.server_close()
+    result = handler.result
+    if not result:
+        raise AuthError("timed out waiting for the browser sign-in")
+    if result.get("state") != state:
+        raise AuthError("sign-in answered with the wrong state; try again")
+    if "code" not in result:
+        raise AuthError(f"sign-in refused: {result.get('error', 'no code returned')}")
+    resp = requests.post(meta["token_endpoint"], data={
+        "grant_type": "authorization_code", "code": result["code"], "redirect_uri": redirect_uri,
+        "client_id": entry["client_id"], "code_verifier": verifier}, timeout=30)
+    if resp.status_code != 200:
+        raise AuthError(f"token exchange failed (HTTP {resp.status_code}): {resp.text[:200]}")
+    _store_tokens(data, server, entry, resp.json())
+    return {"server": server, "client_id": entry["client_id"]}
+
+
+def _serve_until_called(httpd, handler):
+    deadline = time.time() + LOGIN_TIMEOUT
+    httpd.timeout = 1
+    while handler.result is None and time.time() < deadline:
+        httpd.handle_request()
+
+
+def logout(server):
+    """Revoke the refresh token and forget the server's credentials. True when there were any."""
+    server = server.rstrip("/")
+    data = _load()
+    entry = data.get("servers", {}).pop(server, None)
+    if entry is None:
+        return False
+    if entry.get("revocation_endpoint") and entry.get("refresh_token"):
+        try:
+            requests.post(entry["revocation_endpoint"], data={"token": entry["refresh_token"]}, timeout=15)
+        except requests.RequestException:
+            pass
+    if data.get("default_server") == server:
+        data.pop("default_server")
+    if data.get("servers"):
+        _save(data)
+    else:
+        credentials_path().unlink(missing_ok=True)
+    return True