getdocs 0.1.0__py3-none-any.whl

getdocs/scope.py

@@ -0,0 +1,84 @@
+"""Scope: decides whether a discovered URL belongs to a Crawl.
+
+Default: same host + path prefix of each Seed URL, loosened by explicit
+overrides. Discovery method never matters — Scope gates fetching no matter
+how a URL was found.
+"""
+
+from dataclasses import dataclass
+from fnmatch import fnmatch
+from urllib.parse import urlsplit
+
+
+def _segments(path: str) -> list[str]:
+    return [s for s in path.split("/") if s]
+
+
+@dataclass(frozen=True)
+class _SeedRule:
+    host: str
+    path_segments: tuple[str, ...]
+
+    def matches_host(self, host: str, allow_subdomains: bool) -> bool:
+        if host == self.host:
+            return True
+        return allow_subdomains and host.endswith("." + self.host)
+
+    def matches_path(self, segments: list[str], allow_backward: bool) -> bool:
+        if allow_backward:
+            return True
+        return tuple(segments[: len(self.path_segments)]) == self.path_segments
+
+
+@dataclass(frozen=True)
+class Scope:
+    rules: tuple[_SeedRule, ...]
+    allow_backward: bool = False
+    allow_subdomains: bool = False
+    include_paths: tuple[str, ...] = ()
+    exclude_paths: tuple[str, ...] = ()
+
+    @classmethod
+    def from_seeds(
+        cls,
+        seeds: list[str],
+        allow_backward: bool = False,
+        allow_subdomains: bool = False,
+        include_paths: list[str] | tuple[str, ...] = (),
+        exclude_paths: list[str] | tuple[str, ...] = (),
+    ) -> "Scope":
+        rules = []
+        for seed in seeds:
+            parts = urlsplit(seed)
+            rules.append(
+                _SeedRule(host=parts.netloc.lower(), path_segments=tuple(_segments(parts.path)))
+            )
+        return cls(
+            rules=tuple(rules),
+            allow_backward=allow_backward,
+            allow_subdomains=allow_subdomains,
+            include_paths=tuple(include_paths),
+            exclude_paths=tuple(exclude_paths),
+        )
+
+    def allows(self, url: str) -> bool:
+        parts = urlsplit(url)
+        if parts.scheme not in ("http", "https"):
+            return False
+        host = parts.netloc.lower()
+        segments = _segments(parts.path)
+
+        in_seed_scope = any(
+            rule.matches_host(host, self.allow_subdomains)
+            and rule.matches_path(segments, self.allow_backward)
+            for rule in self.rules
+        )
+        if not in_seed_scope:
+            return False
+
+        path = parts.path or "/"
+        if self.include_paths and not any(fnmatch(path, g) for g in self.include_paths):
+            return False
+        if any(fnmatch(path, g) for g in self.exclude_paths):
+            return False
+        return True

getdocs/sitemap.py

@@ -0,0 +1,35 @@
+"""Sitemap parsing: urlsets, sitemap indexes, and robots.txt Sitemap lines.
+
+Discovery only — Scope decides what actually gets fetched.
+"""
+
+import xml.etree.ElementTree as ET
+
+
+def parse_sitemap_xml(body: str) -> tuple[list[str], list[str]]:
+    """Returns (page_urls, nested_sitemap_urls)."""
+    try:
+        root = ET.fromstring(body)
+    except ET.ParseError:
+        return [], []
+
+    tag = root.tag.rpartition("}")[2]
+    locs = [
+        loc.text.strip()
+        for loc in root.iter()
+        if loc.tag.rpartition("}")[2] == "loc" and loc.text and loc.text.strip()
+    ]
+    if tag == "urlset":
+        return locs, []
+    if tag == "sitemapindex":
+        return [], locs
+    return [], []
+
+
+def parse_robots_sitemaps(robots_txt: str) -> list[str]:
+    sitemaps = []
+    for line in robots_txt.splitlines():
+        key, _, value = line.partition(":")
+        if key.strip().lower() == "sitemap" and value.strip():
+            sitemaps.append(value.strip())
+    return sitemaps

getdocs/source.py

@@ -0,0 +1,238 @@
+"""Source-first: before crawling, check whether the docs site is open-source.
+
+Most documentation generators embed a link back to the repository that hosts
+the docs source — MkDocs/Material and Docusaurus render an "Edit this page"
+link, Sphinx/Read-the-Docs an "Edit on GitHub". When we can find that repo we
+clone it and write an mkdocs.yml so the docs can be served locally, which is
+faster and higher-fidelity than crawling the rendered HTML.
+
+Detection is a pure function over the seed page's HTML (`detect_repo`); the
+network and git side-effects live in `fetch_html`, `clone_repo`, and the
+`clone_source_for` orchestrator the CLI calls before `run_crawl`.
+"""
+
+import importlib.util
+import shutil
+import subprocess
+import sys
+import urllib.request
+from pathlib import Path
+from urllib.parse import urljoin, urlsplit
+
+import yaml
+from bs4 import BeautifulSoup
+
+from getdocs.config import CrawlConfig
+from getdocs.identity import build_user_agent
+
+# Hosts whose /ORG/REPO paths we recognize as clonable repositories.
+_GIT_HOSTS = {"github.com", "gitlab.com", "bitbucket.org", "codeberg.org"}
+
+# First path segments on github.com that are product pages, not orgs/users.
+_RESERVED_OWNERS = {
+    "about", "apps", "collections", "contact", "customer-stories", "explore",
+    "features", "join", "login", "marketplace", "new", "notifications",
+    "organizations", "orgs", "pricing", "readme", "security", "settings",
+    "site", "sponsors", "topics",
+}
+
+# Sub-paths a repo URL deep-links through (github.com/o/r/edit/main/docs/x.md).
+_REPO_SUBPATHS = {"edit", "blob", "tree", "raw", "commits", "blame", "wiki"}
+
+# Where doc sources commonly live inside a repo, in preference order.
+_DOCS_CANDIDATES = ["docs", "doc", "documentation", "site/docs", "website/docs", "content"]
+
+
+def repo_root_from_url(url: str) -> str | None:
+    """Reduce any URL on a known Git host to its canonical repo root, or None.
+
+    https://github.com/org/repo/edit/main/docs/x.md -> https://github.com/org/repo
+    Anything off a known host, or shallower than /ORG/REPO, returns None.
+    """
+    parts = urlsplit(url)
+    if parts.scheme not in ("http", "https"):
+        return None
+    host = parts.netloc.lower().rsplit("@", 1)[-1].split(":", 1)[0]
+    if host.startswith("www."):
+        host = host[4:]
+    if host not in _GIT_HOSTS:
+        return None
+    segments = [s for s in parts.path.split("/") if s]
+    if len(segments) < 2:
+        return None
+    owner, repo = segments[0], segments[1]
+    if owner.lower() in _RESERVED_OWNERS:
+        return None
+    if repo.endswith(".git"):
+        repo = repo[:-4]
+    if not repo:
+        return None
+    return f"https://{host}/{owner}/{repo}"
+
+
+def _link_score(url: str, blob: str) -> int:
+    """Rank a repo link by how strongly it signals 'this is the docs source'.
+
+    An explicit "edit this page" affordance is the gold signal; a "source"/
+    "github" label is next; a bare deep-link into the repo beats a plain
+    repo-root link that might just be a footer cross-reference.
+    """
+    if "edit" in blob:
+        return 100
+    if any(word in blob for word in ("source", "github", "gitlab", "view on", "improve")):
+        return 80
+    segments = [s for s in urlsplit(url).path.split("/") if s]
+    if len(segments) >= 3 and segments[2] in _REPO_SUBPATHS:
+        return 60
+    return 20
+
+
+def detect_repo(html: str, base_url: str = "") -> str | None:
+    """Find the repository a docs page links back to, as a canonical repo URL.
+
+    Scans anchors for links onto a known Git host, scores each by how clearly
+    it names the docs source, and returns the highest-scoring repo root
+    (ties broken by how often that repo is linked). None when nothing matches.
+    """
+    soup = BeautifulSoup(html, "html.parser")
+    # root -> [best score seen, link count]
+    candidates: dict[str, list[int]] = {}
+    for anchor in soup.find_all("a", href=True):
+        href = anchor["href"].strip()
+        if base_url and not urlsplit(href).scheme:
+            href = urljoin(base_url, href)
+        root = repo_root_from_url(href)
+        if not root:
+            continue
+        blob = " ".join([
+            anchor.get_text(" ", strip=True),
+            anchor.get("title", ""),
+            " ".join(anchor.get("class") or []),
+            " ".join(anchor.get("rel") or []),
+            anchor.get("aria-label", ""),
+        ]).lower()
+        score = _link_score(href, blob)
+        entry = candidates.setdefault(root, [0, 0])
+        entry[0] = max(entry[0], score)
+        entry[1] += 1
+    if not candidates:
+        return None
+    return max(candidates, key=lambda root: (candidates[root][0], candidates[root][1]))
+
+
+def fetch_html(
+    url: str, user_agent: str | None = None,
+    timeout: float = 15.0, max_bytes: int = 3_000_000,
+) -> str | None:
+    """Fetch a single page's HTML for detection; None on any error/non-HTML."""
+    request = urllib.request.Request(
+        url, headers={"User-Agent": user_agent or build_user_agent()}
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:  # noqa: S310
+            content_type = response.headers.get("Content-Type", "").lower()
+            if any(kind in content_type for kind in ("json", "image/", "pdf", "octet-stream")):
+                return None
+            data = response.read(max_bytes)
+    except Exception:
+        return None
+    return data.decode("utf-8", errors="replace")
+
+
+def clone_repo(repo_url: str, dest_parent: Path, timeout: float = 180.0) -> Path | None:
+    """Shallow-clone repo_url under dest_parent; return the clone dir or None.
+
+    Returns an existing clone untouched (idempotent for re-runs); None when git
+    is missing or the clone fails.
+    """
+    if shutil.which("git") is None:
+        return None
+    name = repo_url.rstrip("/").rsplit("/", 1)[-1]
+    if name.endswith(".git"):
+        name = name[:-4]
+    dest = dest_parent / name
+    if dest.exists():
+        return dest if (dest / ".git").exists() else None
+    clone_url = repo_url if repo_url.endswith(".git") else repo_url + ".git"
+    dest_parent.mkdir(parents=True, exist_ok=True)
+    try:
+        subprocess.run(
+            ["git", "clone", "--depth", "1", clone_url, str(dest)],
+            check=True, capture_output=True, timeout=timeout,
+        )
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+        return None
+    return dest
+
+
+def find_docs_dir(repo_dir: Path) -> Path | None:
+    """Locate the markdown docs source inside a cloned repo, or None."""
+    for candidate in _DOCS_CANDIDATES:
+        path = repo_dir / candidate
+        if path.is_dir() and (any(path.rglob("*.md")) or any(path.rglob("*.mdx"))):
+            return path
+    if any(repo_dir.glob("*.md")):
+        return repo_dir
+    return None
+
+
+def write_mkdocs_config(output_dir: Path, docs_dir: Path, site_name: str) -> Path:
+    """Write an mkdocs.yml in output_dir that serves docs_dir locally."""
+    output_dir.mkdir(parents=True, exist_ok=True)
+    theme = "material" if importlib.util.find_spec("material") else "mkdocs"
+    config = {
+        "site_name": site_name,
+        "docs_dir": str(docs_dir.resolve()),
+        "theme": {"name": theme},
+        "use_directory_urls": True,
+    }
+    path = output_dir / "mkdocs.yml"
+    path.write_text(yaml.safe_dump(config, sort_keys=False, allow_unicode=True))
+    return path
+
+
+def clone_source_for(config: CrawlConfig) -> Path | None:
+    """Try to satisfy a crawl by cloning the docs' source repo instead.
+
+    Returns the clone directory when the site is open-source and was cloned
+    (the caller should then skip crawling); None to fall back to crawling.
+    Progress and outcomes are reported on stderr (stdout is the jsonl stream).
+    """
+    if not config.seeds:
+        return None
+    seed = config.seeds[0]
+    if urlsplit(seed).scheme not in ("http", "https"):
+        return None
+
+    host = urlsplit(seed).netloc or seed
+    print(f"checking whether {host} is open-source…", file=sys.stderr)
+    html = fetch_html(seed, build_user_agent(config.contact, config.user_agent))
+    if html is None:
+        print("could not fetch the seed page — crawling instead", file=sys.stderr)
+        return None
+    repo_url = detect_repo(html, seed)
+    if repo_url is None:
+        print("no source repository linked from the page — crawling instead", file=sys.stderr)
+        return None
+
+    print(f"found source repository {repo_url} — cloning…", file=sys.stderr)
+    repo_dir = clone_repo(repo_url, config.output_dir)
+    if repo_dir is None:
+        print("clone failed (git missing or repo unreachable) — crawling instead", file=sys.stderr)
+        return None
+
+    own_config = repo_dir / "mkdocs.yml"
+    if own_config.exists():
+        print(f"cloned to {repo_dir} (ships its own mkdocs.yml)", file=sys.stderr)
+        print(f"serve it with: mkdocs serve -f {own_config}", file=sys.stderr)
+        return repo_dir
+
+    docs_dir = find_docs_dir(repo_dir)
+    if docs_dir is None:
+        print(f"cloned to {repo_dir}, but found no markdown docs to serve", file=sys.stderr)
+        return repo_dir
+
+    written = write_mkdocs_config(config.output_dir, docs_dir, host)
+    print(f"cloned to {repo_dir}; wrote {written}", file=sys.stderr)
+    print(f"serve it with: mkdocs serve -f {written}", file=sys.stderr)
+    return repo_dir

getdocs/urlnorm.py

@@ -0,0 +1,34 @@
+"""URL normalization for frontier dedup.
+
+Two URLs that normalize identically are the same Page. rel=canonical is
+deliberately NOT part of this (ADR-0003).
+"""
+
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+_TRACKING_PREFIXES = ("utm_",)
+_TRACKING_PARAMS = {"fbclid", "gclid", "msclkid", "mc_cid", "mc_eid"}
+_DEFAULT_PORTS = {"http": "80", "https": "443"}
+
+
+def _is_tracking(param: str) -> bool:
+    return param in _TRACKING_PARAMS or param.startswith(_TRACKING_PREFIXES)
+
+
+def normalize(url: str) -> str:
+    parts = urlsplit(url)
+    scheme = parts.scheme.lower()
+
+    host = parts.hostname.lower() if parts.hostname else ""
+    if parts.port is not None and str(parts.port) != _DEFAULT_PORTS.get(scheme):
+        host = f"{host}:{parts.port}"
+
+    path = parts.path
+    if path.endswith("/"):
+        path = path.rstrip("/")
+
+    query = urlencode(
+        sorted((k, v) for k, v in parse_qsl(parts.query, keep_blank_values=True) if not _is_tracking(k))
+    )
+
+    return urlunsplit((scheme, host, path, query, ""))

getdocs-0.1.0.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: getdocs
+Version: 0.1.0
+Summary: Documentation crawler: recursively crawl a docs site and emit clean markdown
+Author-email: jonbakerfish <jonbakerfish@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jonbakerfish/getdocs
+Project-URL: Repository, https://github.com/jonbakerfish/getdocs
+Project-URL: Issues, https://github.com/jonbakerfish/getdocs/issues
+Project-URL: Documentation, https://github.com/jonbakerfish/getdocs/blob/main/docs/USAGE.md
+Keywords: documentation,crawler,scraper,markdown,docs,llm,agents,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scrapy>=2.11
+Requires-Dist: markdownify>=0.13
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: trafilatura>=1.12
+Requires-Dist: scrapy-playwright>=0.0.40
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110; extra == "server"
+Requires-Dist: uvicorn>=0.27; extra == "server"
+Requires-Dist: httpx>=0.27; extra == "server"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+Requires-Dist: uvicorn>=0.27; extra == "dev"
+Dynamic: license-file
+
+# getdocs
+
+**Turn any documentation site into a clean, local markdown copy your coding agent can actually read.**
+
+```bash
+getdocs crawl https://example.com/docs -o ./out
+```
+
+Coding agents are only as good as the docs they can see. Pointing an agent at a
+live docs URL means it burns tokens on nav bars, cookie banners, and HTML
+chrome — or can't reach the page at all. `getdocs` gives the agent a local,
+offline, markdown mirror instead: the actual content, structured to match the
+original site, ready to drop into a repo or feed to a model.
+
+## Why getdocs
+
+- **Richer context for coding agents.** A local copy is greppable, indexable,
+  and always available — the agent reads the whole library at once instead of
+  fetching one rendered page at a time. No rate limits, no network flakiness,
+  no JS that won't hydrate.
+- **Clean markdown → fewer tokens.** Each page is reduced to its content (the
+  nav, headers, footers, and ad chrome stripped) and written as plain markdown.
+  Agents consume it directly, and you spend tokens on docs, not `<div>` soup.
+- **Structure preserved.** Files mirror the URL hierarchy
+  (`example.com/docs/auth` → `out/docs/auth.md`), each with YAML frontmatter
+  (`url`, `title`, `crawled_at`, `status`), plus a `crawl.json` Manifest that
+  captures the site's nav order and reading order — so an agent can follow the
+  docs in the order the authors intended.
+- **Source-first: clone over crawl.** If the docs site is open-source, getdocs
+  detects the "Edit this page" link, clones the repo, and serves you the
+  original markdown source instead of scraping HTML — the highest-fidelity copy
+  there is. Falls back to crawling automatically when there's no repo.
+
+## When to reach for it
+
+- **Coding against an unfamiliar library or API.** Mirror its docs into your
+  repo (or a scratch dir) so your agent can ground its answers in the real
+  reference instead of hallucinating from memory.
+- **RAG / knowledge bases.** Get a clean markdown corpus to chunk and embed,
+  without writing a bespoke scraper-and-cleaner for every site.
+- **Offline or air-gapped work.** Take a docs set with you; read and search it
+  with no network.
+- **Pinning a version.** Snapshot today's docs so your agent isn't tripped up
+  when the upstream site changes underneath you.
+- **Migrating or archiving docs.** Pull an entire site down as markdown to move,
+  diff, or keep.
+
+## Output
+
+```
+out/
+├── crawl.json            ← the Manifest: nav order, reading order, what ran
+└── docs/
+    ├── index.md
+    ├── auth.md
+    └── guide/
+        └── intro.md
+```
+
+```markdown
+---
+url: https://example.com/docs/auth
+title: Authentication
+status: 200
+crawled_at: 2026-06-12T10:00:00Z
+---
+
+# Authentication
+...
+```
+
+Sitemap discovery, JavaScript rendering, source-repo cloning, polite
+throttling, JSONL output, and resumable crawls are all built in — see
+[docs/USAGE.md](docs/USAGE.md).
+
+## Install
+
+Requires **Python 3.12+**.
+
+```bash
+pip install getdocs
+```
+
+Or from source, for the latest unreleased changes:
+
+```bash
+git clone https://github.com/jonbakerfish/getdocs
+cd getdocs
+pip install -e .
+```
+
+That's enough to crawl. Two optional pieces unlock more:
+
+```bash
+# JavaScript rendering — the headless browser used to hydrate SPA docs
+playwright install chromium
+
+# Serve a crawled/cloned copy locally as a browsable site
+pip install mkdocs mkdocs-material
+```
+
+**`git`** must be on your `PATH` for source-first cloning (it almost always
+already is); without it, getdocs simply falls back to crawling. To run the
+optional API service, install the server extra: `pip install "getdocs[server]"`.
+
+## Development
+
+```bash
+git clone https://github.com/jonbakerfish/getdocs
+cd getdocs
+pip install -e ".[dev]"
+pytest
+```
+
+## Responsible use
+
+getdocs is a tool; how you point it is on you. By default it **honors
+`robots.txt`**, throttles itself politely, and **identifies itself honestly**
+in the `User-Agent` (`getdocs/<version> (+project-url)`) — please keep it that
+way. For high-volume crawls, add `--contact you@example.com` so site operators
+can reach you (it's appended to the User-Agent; optional but courteous).
+
+getdocs is intended for personal, reference, and agent/RAG use on documentation
+you have the right to access. **You are solely responsible for complying with
+each site's Terms of Service, its `robots.txt`, applicable law, and the
+copyright of the content you fetch** — getdocs is provided as-is, with no
+warranty (see [LICENSE](LICENSE)). Crawled documentation belongs to its authors:
+use it for your own reference, but don't redistribute someone else's docs as
+your own. Crawl only what you have the right to.

getdocs-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+getdocs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+getdocs/__main__.py,sha256=_Tn13GrLH9DQGu82AfWWm7dShwaORqV5PnRTfl7Q03Q,55
+getdocs/api.py,sha256=y-jNi2-OJ7iQFlMPyxc5AeX5Cg1yo-r6eI3gLn3b0d0,3098
+getdocs/cli.py,sha256=fNQz2hv0EijfaqYOH4kfifA9_k9lQnDZs8KqmLkHA0M,8794
+getdocs/config.py,sha256=c1DHYj5OheMEQJqQVUjc85Y1S8kM5CMIrlsakiQSh64,1671
+getdocs/engine.py,sha256=jNaAcfXiz8BGNzvu_5ohbDA_pf_7Ubitw5GkJk1K978,17814
+getdocs/extract.py,sha256=EBkzt8w9z1Fr_ZRc6IEFYBDn68L4SsyL7xiOeCw8j28,6671
+getdocs/identity.py,sha256=5g8tZmgzlzCWqWQNDWVnTe9k2xVz_bSBYvmLoXh8OUE,1228
+getdocs/jobs.py,sha256=SC6c2Isfn_nyFSTsGfJOGLvGsr5_RLHJa5G1uUhoJYk,7371
+getdocs/navharvest.py,sha256=Ol0coVL4Z_HlZCarotADf09t2eCGq80NkHt6eVWIxcI,8510
+getdocs/output.py,sha256=FPvCFTzL4m9HT1MsqRc8NBfnESGvOIMPWdmfPEDE-rM,6105
+getdocs/scope.py,sha256=lrPOsxtQIrg7HrV87qf7tnXwTAXlV0yY0mBhyNciG3c,2622
+getdocs/sitemap.py,sha256=buPx7HteGLnba-8ZdvE2nR8WHHcZVJKKq859K8Ap4Yw,992
+getdocs/source.py,sha256=AJOhOosaZ9PTbvix8ob3BB3Fnuvk-DUrAm-AkRJX6wc,9354
+getdocs/urlnorm.py,sha256=6EQicHbfKmW0ZtXeT5SgpVTBADXNg6kFRNP5sm50uFY,1043
+getdocs-0.1.0.dist-info/licenses/LICENSE,sha256=Rccj8_h8ZBIXibP7auL1DDSOPRlZhYRMeVxLqbtsFRI,1069
+getdocs-0.1.0.dist-info/METADATA,sha256=lJ90Zf55F27iI6u5cOXB3wRNVIOo7N55dmT5Dm5BApY,6382
+getdocs-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+getdocs-0.1.0.dist-info/entry_points.txt,sha256=OTldHBzF-MGYD2brSgt7FOTQZ5rimQkDn6ghb3UujXg,45
+getdocs-0.1.0.dist-info/top_level.txt,sha256=KMBRopk15nwErQ-PZQSe8xAQiHhLuRdQU1qJzeYpVIQ,8
+getdocs-0.1.0.dist-info/RECORD,,

getdocs-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
+

getdocs-0.1.0.dist-info/entry_points.txt

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

getdocs-0.1.0.dist-info/licenses/LICENSE

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

getdocs-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+getdocs