praiser 0.1.0__py3-none-any.whl

praiser/__init__.py

@@ -0,0 +1,7 @@
+"""praiser — record the popular projects a GitHub user has an elevated role in.
+
+Elevated roles are maintainer / code owner / steering-council member /
+standards author. Plain contributors are intentionally excluded.
+"""
+
+__version__ = "0.1.0"

praiser/__main__.py

@@ -0,0 +1,6 @@
+"""Allow `python -m praiser`."""
+
+from praiser.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

praiser/cache.py

@@ -0,0 +1,60 @@
+"""Dead-simple file-based JSON cache keyed by a request hash.
+
+Re-runs and LLM steps reuse cached payloads instead of re-fetching. Values
+must be JSON-serialisable. A ``None`` value is stored faithfully and returned
+as ``None`` on hit, so callers distinguish hit-with-None from miss via
+``has()`` or the ``default`` sentinel.
+"""
+
+import hashlib
+import json
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+_MISS = object()
+
+
+class Cache:
+    def __init__(self, directory: Path | str, ttl: float | None = None) -> None:
+        self.dir = Path(directory)
+        self.ttl = ttl  # seconds; None = never expire
+        self.dir.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def key(*parts: Any) -> str:
+        blob = json.dumps(parts, sort_keys=True, default=str)
+        return hashlib.sha256(blob.encode("utf-8")).hexdigest()
+
+    def _path(self, key: str) -> Path:
+        return self.dir / f"{key}.json"
+
+    def has(self, key: str) -> bool:
+        return self.get(key, default=_MISS) is not _MISS
+
+    def get(self, key: str, default: Any = None) -> Any:
+        path = self._path(key)
+        if not path.exists():
+            return default
+        try:
+            with path.open(encoding="utf-8") as fh:
+                record = json.load(fh)
+        except (json.JSONDecodeError, OSError):
+            return default
+        if self.ttl is not None and time.time() - record.get("ts", 0) > self.ttl:
+            return default
+        return record.get("value")
+
+    def set(self, key: str, value: Any) -> None:
+        path = self._path(key)
+        # Unique temp name per writer so concurrent writes (threads) to the same
+        # key don't clobber each other's temp file; the final replace is atomic.
+        tmp = path.with_suffix(f".{os.getpid()}.{threading.get_ident()}.tmp")
+        try:
+            with tmp.open("w", encoding="utf-8") as fh:
+                json.dump({"ts": time.time(), "value": value}, fh)
+            tmp.replace(path)
+        finally:
+            tmp.unlink(missing_ok=True)

praiser/cli.py

@@ -0,0 +1,285 @@
+"""Command-line entry point: ``praiser <username> [...]``."""
+
+import argparse
+import os
+import sys
+
+from . import __version__
+from . import llm as _llm
+from .config import Config, resolve_token
+from .github_client import RateLimitError
+from .pipeline import _humanize, run
+from .render import render, render_highlights
+
+# Shown when Anthropic credentials are needed (LLM features).
+ANTHROPIC_HELP = (
+    "Use EITHER an API key — https://console.anthropic.com/settings/keys, then "
+    "`export ANTHROPIC_API_KEY=<key>` (pay-as-you-go) — OR your Claude "
+    "subscription: run `claude setup-token` and "
+    "`export CLAUDE_CODE_OAUTH_TOKEN=<token>`. Also install the extra: "
+    "pip install 'praiser[llm]'."
+)
+
+# Shown whenever a token would help. Public-data discovery needs no scopes; add
+# `repo` + `read:org` to reach private repos and resolve org/team membership.
+TOKEN_HELP = (
+    "Get a token at https://github.com/settings/tokens (classic: no scopes "
+    "needed for public data; add 'repo' and 'read:org' for private/org access; "
+    "fine-grained: read-only 'Contents' + 'Members'), then run "
+    "`export GITHUB_TOKEN=<token>` or pass --token. Or just `gh auth login`."
+)
+
+
+def _token_hint(token_source: str) -> str:
+    """A leading-newline hint about tokens, tailored to where ours came from."""
+    if token_source == "none":
+        return (
+            "\nA token raises the limit from ~60 to 5,000 requests/hour. "
+            + TOKEN_HELP
+        )
+    if token_source == "gh":
+        return (
+            "\nYou're authenticated via the gh CLI (already 5,000 requests/hour), "
+            "so a different token won't raise the limit — just wait and re-run. "
+            "To use an explicit token instead, set GITHUB_TOKEN: " + TOKEN_HELP
+        )
+    # flag / env: the user already supplied a token; 5,000/hr is the ceiling.
+    return ""
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="praiser",
+        description="Record the popular projects a user maintains, steers, or "
+                    "authors standards for (contributors excluded). Scans GitHub "
+                    "by default, or Codeberg / GitLab via --forge.",
+    )
+    p.add_argument("username", help="login to investigate (on the chosen --forge)")
+    p.add_argument("--forge",
+                   choices=["github", "codeberg", "gitlab", "gitee", "bitbucket",
+                            "cgit"],
+                   default="github",
+                   help="code host to scan (default: github); 'codeberg' uses "
+                        "the Gitea/Forgejo API, 'gitlab' the GitLab API, 'gitee' "
+                        "the Gitee API, 'bitbucket' the Bitbucket API, 'cgit' an "
+                        "API-less cgit host (e.g. kernel.org, Savannah) via "
+                        "--forge-url + --add-repo")
+    p.add_argument("--forge-url", default=None, metavar="URL",
+                   help="base URL of a self-hosted instance for --forge "
+                        "gitlab|codeberg (e.g. https://gitlab.gnome.org or a "
+                        "private Gitea); default: the public host")
+    p.add_argument("--forge-name", default=None, metavar="LABEL",
+                   help="short label for the --forge-url instance (default: the "
+                        "forge's own name)")
+    p.add_argument("--cross-forge", action="store_true",
+                   help="follow verified cross-links on the user's profile to "
+                        "their accounts on other forges (bidirectional only) and "
+                        "scan them all into one merged record")
+    p.add_argument("--also-forge", action="append", default=[],
+                   metavar="FORGE:LOGIN", dest="also_forge",
+                   help="also scan this identity on another forge (repeatable), "
+                        "e.g. --also-forge gitlab:johnsmith; merged into one record")
+    p.add_argument("--min-stars", type=int, default=50,
+                   help="popularity threshold (default: 50); high-signal roles "
+                        "and registry overrides survive regardless")
+    p.add_argument("--format", choices=["md", "json"], default=None,
+                   dest="fmt",
+                   help="emit the full report as md or json (default output is "
+                        "the highlights summary)")
+    p.add_argument("--highlights", nargs="?", type=int, const=8, default=None,
+                   metavar="N",
+                   help="top-N highlights, one line each (this is the default "
+                        "view; N defaults to 8)")
+    p.add_argument("--token", default=None,
+                   help="GitHub token (or set GITHUB_TOKEN / GH_TOKEN)")
+    p.add_argument("--cache-dir", default=None,
+                   help="cache directory (default: ~/.cache/praiser)")
+    p.add_argument("--registry", default=None, dest="registry_path",
+                   help="known-projects JSON file, merged over the seed "
+                        "(default: ~/.local/share/praiser/known_projects.json)")
+    p.add_argument("--save-registry", action=argparse.BooleanOptionalAction,
+                   default=True,
+                   help="persist observed popularity and web-discovered role "
+                        "sources to the registry (default: on)")
+    p.add_argument("--no-llm", action="store_true",
+                   help="disable all Claude features (prose fallback + role "
+                        "discovery)")
+    p.add_argument("--discover-roles", action=argparse.BooleanOptionalAction,
+                   default=True,
+                   help="for popular repos, use Claude + web search to find "
+                        "official team/governance pages AND to identify the "
+                        "project's founder(s)/creator(s) (default: on when LLM "
+                        "credentials are available; needs the llm extra + an API "
+                        "key or Claude subscription)")
+    p.add_argument("--wikidata", action=argparse.BooleanOptionalAction,
+                   default=True,
+                   help="derive creator/founder/developer roles for popular "
+                        "projects from Wikidata (handle-matched; default: on)")
+    p.add_argument("--package-registries", action=argparse.BooleanOptionalAction,
+                   default=True,
+                   help="also look up the user on PyPI, npm and crates.io to "
+                        "credit packages they maintain/author and surface the "
+                        "repos those ship from (default: on)")
+    p.add_argument("--add-repo", action="append", default=[],
+                   metavar="OWNER/REPO[:PATH]", dest="extra_repos",
+                   help="also scan this repo even if discovery missed it "
+                        "(repeatable); append :PATH to credit a subcomponent "
+                        "(e.g. numpy/numpy:numpy/f2py). Role detected automatically")
+    p.add_argument("--include-private", action="store_true",
+                   help="also scan private repos (default: skip them)")
+    p.add_argument("--contributor-pages", type=int, default=2, metavar="N",
+                   help="contributors API pages to fetch per repo, 100 each "
+                        "(default: 2; lower = faster cold runs, may miss "
+                        "deep-ranked contributors)")
+    p.add_argument("-j", "--jobs", type=int, default=8, metavar="N",
+                   help="candidates scanned concurrently (default: 8)")
+    p.add_argument("-o", "--output", default=None,
+                   help="write output to a file instead of stdout")
+    p.add_argument("-v", "--verbose", action="store_true",
+                   help="detailed per-repo logging to stderr")
+    p.add_argument("-q", "--quiet", action="store_true",
+                   help="suppress the live progress display")
+    p.add_argument("--version", action="version",
+                   version=f"praiser {__version__}")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    if args.forge == "github":
+        token, token_source = resolve_token(args.token)
+        if not token:
+            print(
+                "warning: no GitHub token found; discovery and rate limits will be "
+                "severely restricted (~60 requests/hour).\n" + TOKEN_HELP,
+                file=sys.stderr,
+            )
+    else:  # codeberg / gitlab — public data works unauthenticated
+        token_envs = {
+            "codeberg": ("CODEBERG_TOKEN", "FORGEJO_TOKEN"),
+            "gitlab": ("GITLAB_TOKEN",),
+            "gitee": ("GITEE_TOKEN",),
+            "bitbucket": ("BITBUCKET_TOKEN",),
+        }.get(args.forge, ())
+        env_token = next((v for e in token_envs if (v := os.environ.get(e))), None)
+        token = args.token or env_token
+        token_source = "flag" if args.token else ("env" if token else "none")
+        if args.forge == "bitbucket" and not token:
+            print(
+                "warning: Bitbucket's anonymous rate limit is very low (~60 "
+                "requests/hour) — a multi-repo scan will be throttled. Set "
+                "BITBUCKET_TOKEN (an app password or access token) or pass "
+                "--token for a usable scan.",
+                file=sys.stderr,
+            )
+
+    # Role discovery is on by default; only nag about missing creds/conflicts
+    # when the user EXPLICITLY asked for it (default-on degrades silently).
+    argv_tokens = argv if argv is not None else sys.argv[1:]
+    if args.discover_roles and "--discover-roles" in argv_tokens:
+        if args.no_llm:
+            print("warning: --discover-roles needs the LLM, but --no-llm was "
+                  "given; role discovery is off.", file=sys.stderr)
+        else:
+            reason = _llm.availability()
+            if reason:
+                print(f"warning: --discover-roles is on but {reason}; role "
+                      f"discovery is off.\n{ANTHROPIC_HELP}", file=sys.stderr)
+
+    # Split --add-repo values: "owner/repo" or "owner/repo:subpath".
+    extra_repos: list[str] = []
+    extra_subcomponents: dict[str, list[str]] = {}
+    for item in args.extra_repos:
+        repo, sep, path = item.partition(":")
+        if "/" not in repo:
+            continue
+        extra_repos.append(repo)
+        if sep and path:
+            extra_subcomponents.setdefault(repo, []).append(path)
+
+    # Highlights is the default view; --format md|json switches to the full report.
+    highlights = args.highlights
+    if highlights is None and args.fmt is None:
+        highlights = 8
+
+    if args.forge_url and args.forge == "github":
+        print("warning: --forge-url is ignored for --forge github (github.com "
+              "is the only GitHub host praiser supports).", file=sys.stderr)
+
+    config = Config(
+        username=args.username,
+        forge=args.forge,
+        forge_url=args.forge_url,
+        forge_name=args.forge_name,
+        cross_forge=args.cross_forge,
+        also_forge=args.also_forge,
+        token=token,
+        min_stars=args.min_stars,
+        fmt=args.fmt or "md",
+        highlights=highlights,
+        cache_dir=args.cache_dir,
+        use_llm=not args.no_llm,
+        registry_path=args.registry_path,
+        save_registry=args.save_registry,
+        verbose=args.verbose,
+        quiet=args.quiet,
+        include_private=args.include_private,
+        contributor_pages=args.contributor_pages,
+        jobs=args.jobs,
+        discover_roles=args.discover_roles,
+        use_wikidata=args.wikidata,
+        use_package_registries=args.package_registries,
+        extra_repos=extra_repos,
+        extra_subcomponents=extra_subcomponents,
+    )
+
+    try:
+        result = run(config)
+    except KeyboardInterrupt:
+        # Cancelled by the user (Ctrl-C): exit quietly, no stack trace. The
+        # cache keeps whatever already succeeded, so a re-run resumes.
+        print("\ncancelled (partial work is cached; re-run to continue).",
+              file=sys.stderr)
+        return 130
+    except RateLimitError as exc:
+        print(
+            "error: GitHub rate limit reached before discovery could run; "
+            f"wait {_humanize(exc.reset_in)} for it to reset."
+            + _token_hint(token_source),
+            file=sys.stderr,
+        )
+        return 1
+    except Exception as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    if result.partial_reset_in is not None:
+        print(
+            "warning: GitHub rate limit reached during the run — results are "
+            "PARTIAL (some repos were not fully scanned). Wait "
+            f"{_humanize(result.partial_reset_in)} for the limit to reset, then "
+            "re-run to finish; the cache preserves what already succeeded."
+            + _token_hint(token_source),
+            file=sys.stderr,
+        )
+
+    if config.highlights is not None:
+        output = render_highlights(
+            config.username, result.records, config.highlights, result.secondary
+        )
+    else:
+        output = render(
+            config.username, result.records, config.fmt, result.secondary
+        )
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as fh:
+            fh.write(output + "\n")
+        print(f"wrote {args.output}", file=sys.stderr)
+    else:
+        print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

praiser/config.py

@@ -0,0 +1,86 @@
+"""Runtime configuration: token, thresholds, paths."""
+
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def default_cache_dir() -> Path:
+    base = os.environ.get("XDG_CACHE_HOME") or os.path.expanduser("~/.cache")
+    return Path(base) / "praiser"
+
+
+def default_registry_path() -> Path:
+    # The learned/curated registry lives in a data dir (not the cache, which is
+    # safe to wipe) so discovered role sources and popularity persist.
+    base = os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share")
+    return Path(base) / "praiser" / "known_projects.json"
+
+
+def resolve_token(explicit: str | None) -> tuple[str | None, str]:
+    """Return (token, source). source is one of: flag, env, gh, none."""
+    if explicit:
+        return explicit, "flag"
+    for var in ("GITHUB_TOKEN", "GH_TOKEN"):
+        val = os.environ.get(var)
+        if val:
+            return val, "env"
+    gh = _gh_cli_token()
+    if gh:
+        return gh, "gh"
+    return None, "none"
+
+
+def _gh_cli_token() -> str | None:
+    """Fall back to the GitHub CLI's token if `gh` is installed and logged in."""
+    if not shutil.which("gh"):
+        return None
+    try:
+        out = subprocess.run(
+            ["gh", "auth", "token"],
+            capture_output=True, text=True, timeout=5,
+        )
+    except Exception:
+        return None
+    token = out.stdout.strip()
+    return token or None
+
+
+@dataclass
+class Config:
+    username: str
+    forge: str = "github"           # "github" | "codeberg" | "gitlab" | ...
+    forge_url: str | None = None    # base URL of a self-hosted instance
+    forge_name: str | None = None   # short label for that instance
+    cross_forge: bool = False       # follow verified profile links to other forges
+    also_forge: list[str] = field(default_factory=list)  # extra "forge:login" ids
+    token: str | None = None
+    min_stars: int = 50
+    fmt: str = "md"                 # "md" | "json"
+    highlights: int | None = None   # if set, print only the top-N highlights
+    cache_dir: Path | None = None
+    use_llm: bool = True
+    registry_path: Path | None = None   # user known-projects file (defaults below)
+    save_registry: bool = True          # persist learned popularity + role sources
+    verbose: bool = False
+    quiet: bool = False                  # suppress the default progress display
+    include_private: bool = False        # scan private repos too (default: skip)
+    contributor_pages: int = 2           # contributors API pages (100 each)
+    jobs: int = 8                        # concurrent candidates during attribution
+    discover_roles: bool = True          # find role pages via LLM + web search
+    use_wikidata: bool = True            # derive creator/developer roles via Wikidata
+    use_package_registries: bool = True  # discover roles via PyPI/npm/crates.io
+    extra_repos: list[str] = field(default_factory=list)  # user-supplied owner/repo
+    # user-supplied subcomponents: owner/repo -> [paths]
+    extra_subcomponents: dict[str, list[str]] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.cache_dir is None:
+            self.cache_dir = default_cache_dir()
+        self.cache_dir = Path(self.cache_dir)
+        self.registry_path = (
+            default_registry_path() if self.registry_path is None
+            else Path(self.registry_path)
+        )

praiser/crossforge.py

@@ -0,0 +1,188 @@
+"""Cross-forge identity resolution (issues #18, #25).
+
+From a single anchor account, discover the person's accounts on *other* forges,
+confirming each in one of two false-merge-resistant ways:
+
+* **Bidirectional profile links** (#18): the candidate's profile links back to an
+  already-confirmed account. A false merge would need two different people to
+  link to each other.
+* **Personal-site hub** (#25): people often list their accounts on a personal
+  site rather than in a forge bio. When a confirmed profile links to a non-forge
+  URL, we fetch that page (one hop, cached) and, if it's an *owned* hub (it also
+  links back to a confirmed account), accept the other forge accounts it lists —
+  provided the candidate shares the handle or display name. A link-farm guard
+  skips hubs that reference many distinct accounts.
+
+Under-merge (someone who didn't cross-link at all) is safe; over-merge is
+refused. The traversal is forge-agnostic (operates on ``Forge.profile_links`` +
+a URL parser + ``Forge.get_url`` for the hub), so it's unit-testable with fakes.
+"""
+
+import re
+
+from .forge import Forge
+from .forge._http import extract_urls
+from .models import FORGE_WEB_HOSTS, Identity
+
+# A personal-site hub linking to more distinct forge accounts than this is
+# probably a directory/link-farm, not one person's identity page — skip it.
+_MAX_HUB_ACCOUNTS = 6
+
+# host (no scheme, no www.) -> forge name
+_HOST_FORGE = {
+    host.split("://", 1)[1].lower(): name for name, host in FORGE_WEB_HOSTS.items()
+}
+# First-path-segment values that are never a user profile.
+_NON_PROFILE = {
+    "sponsors", "orgs", "users", "topics", "features", "about", "settings",
+    "marketplace", "apps", "explore", "help", "pricing", "-", "dashboard",
+}
+# A profile URL is host + exactly ONE path segment (the login).
+_PROFILE_RE = re.compile(r"https?://([^/\s]+)/([^/?#\s]+)/?(?:[?#].*)?$")
+
+
+def parse_profile_url(url: str) -> tuple[str, str] | None:
+    """``(forge_name, login)`` for a profile URL on a known host, else None.
+
+    Only single-segment paths match (a profile), so repo/group links like
+    ``github.com/owner/repo`` are ignored.
+    """
+    if not url:
+        return None
+    m = _PROFILE_RE.match(url.strip())
+    if not m:
+        return None
+    host, seg = m.group(1).lower(), m.group(2)
+    if host.startswith("www."):
+        host = host[4:]
+    forge = _HOST_FORGE.get(host)
+    if forge is None:
+        return None
+    if not seg or seg.lower() in _NON_PROFILE or "." in seg:  # skip *.git, files
+        return None
+    return (forge, seg)
+
+
+def resolve_cross_forge(
+    anchor: Forge,
+    anchor_login: str,
+    forge_factory,
+    *,
+    max_accounts: int = 8,
+) -> tuple[Identity, list[tuple[str, str]]]:
+    """Resolve the person's accounts across forges from an anchor account.
+
+    ``forge_factory(forge_name) -> Forge | None`` builds a forge for a name
+    (None if unsupported). Returns the merged ``Identity`` and the confirmed
+    ``[(forge_name, login), …]`` (anchor included), for the executor to scan.
+    """
+    forges: dict[str, Forge] = {anchor.name: anchor}
+    confirmed: dict[tuple[str, str], str] = {(anchor.name, anchor_login.lower()): anchor_login}
+    names: set[str] = set()
+    visited: set[tuple[str, str]] = set()
+    visited_hubs: set[str] = set()
+
+    def links_of(forge: Forge, login: str) -> list[str]:
+        # A throttled/flaky forge contributes no links rather than aborting the
+        # whole resolution (best-effort, like discovery).
+        try:
+            return forge.profile_links(login)
+        except Exception:
+            return []
+
+    def note_name(forge: Forge, login: str) -> None:
+        try:
+            user = forge.resolve_user(login)
+        except Exception:
+            return
+        if user and user.name:
+            names.add(user.name)
+
+    def get_forge(fname: str) -> Forge | None:
+        if fname not in forges:
+            cforge = forge_factory(fname)
+            if cforge is None:
+                return None
+            forges[fname] = cforge
+        return forges[fname]
+
+    def confirm(cforge: Forge, clogin: str) -> None:
+        confirmed[(cforge.name, clogin.lower())] = clogin
+        note_name(cforge, clogin)
+        queue.append((cforge, clogin))
+
+    def name_matches(cforge: Forge, clogin: str) -> bool:
+        try:
+            user = cforge.resolve_user(clogin)
+        except Exception:
+            return False
+        lowered = {n.strip().lower() for n in names}
+        return bool(user and user.name and user.name.strip().lower() in lowered)
+
+    note_name(anchor, anchor_login)
+    queue: list[tuple[Forge, str]] = [(anchor, anchor_login)]
+    while queue and len(confirmed) < max_accounts:
+        forge, login = queue.pop(0)
+        if (forge.name, login.lower()) in visited:
+            continue
+        visited.add((forge.name, login.lower()))
+
+        forge_targets: list[tuple[str, str]] = []
+        hub_urls: list[str] = []
+        for url in links_of(forge, login):
+            parsed = parse_profile_url(url)
+            if parsed is not None:
+                forge_targets.append(parsed)
+            elif url.strip().lower().startswith(("http://", "https://")):
+                hub_urls.append(url.strip())
+
+        # 1. Direct bidirectional: the candidate's profile links back.
+        for fname, clogin in forge_targets:
+            if (fname, clogin.lower()) in confirmed:
+                continue
+            cforge = get_forge(fname)
+            if cforge is None:
+                continue
+            back = {
+                (f, ll.lower()) for u2 in links_of(cforge, clogin)
+                if (p := parse_profile_url(u2)) for f, ll in [p]
+            }
+            if set(confirmed) & back:
+                confirm(cforge, clogin)
+
+        # 2. Personal-site hub (#25): fetch the site, and if it's an owned hub
+        # (links back to a confirmed account), accept the accounts it lists that
+        # share the handle or display name.
+        for hub in hub_urls:
+            if hub in visited_hubs:
+                continue
+            visited_hubs.add(hub)
+            try:
+                page = forge.get_url(hub)
+            except Exception:
+                page = None
+            hub_accounts = {
+                p for u2 in extract_urls(page or "") if (p := parse_profile_url(u2))
+            }
+            if not hub_accounts or len(hub_accounts) > _MAX_HUB_ACCOUNTS:
+                continue  # empty, or a link-farm — not a personal identity hub
+            hub_keys = {(f, ll.lower()) for f, ll in hub_accounts}
+            if not (set(confirmed) & hub_keys):
+                continue  # not reached-from + links-back: not the person's own hub
+            confirmed_logins = {cl for (_, cl) in confirmed}
+            for fname, clogin in hub_accounts:
+                if (fname, clogin.lower()) in confirmed:
+                    continue
+                cforge = get_forge(fname)
+                if cforge is None:
+                    continue
+                if clogin.lower() in confirmed_logins or name_matches(cforge, clogin):
+                    confirm(cforge, clogin)
+
+    identity = Identity(
+        primary_login=anchor_login,
+        logins=set(confirmed.values()),
+        names=names,
+    )
+    ids = [(fname, login) for (fname, _), login in confirmed.items()]
+    return identity, ids

praiser/data/__init__.py

@@ -0,0 +1 @@
+# Marks praiser.data as a package so importlib.resources can read bundled files.