uncapped 0.1.0__tar.gz

uncapped-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+.venv/
+__pycache__/
+*.py[cod]
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.coverage
+htmlcov/
+.DS_Store

uncapped-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0
+
+First release.
+
+- `split()` and `asplit()`: cut a capped search into windows that each fit under the cap.
+- Dimensions: `Range` (numbers, any step), `DateRange` (dates and datetimes), `Values` (categories, one at a time or in groups).
+- Falls back to the next dimension when one can't be narrowed any further.
+- `fanout="auto"` sizes each split from how far over the cap a window is, to save count calls.
+- `merge=True` (default) joins neighbouring windows that together fit under the cap, so there are fewer windows to page through. It never merges across results no dimension could reach, so counts stay exact.
+- `cache=` keeps counts in any dict-like store (e.g. `shelve`) so an interrupted run resumes for free.
+- `run.stats` and `UncappedWarning` report windows still over the cap and results no dimension could reach.

uncapped-0.1.0/LICENSE

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

uncapped-0.1.0/PKG-INFO

@@ -0,0 +1,254 @@
+Metadata-Version: 2.5
+Name: uncapped
+Version: 0.1.0
+Summary: Get every result from APIs and sites that stop at 1,000 results, by splitting the search into windows that fit under the cap.
+Project-URL: Homepage, https://github.com/bhatti013/uncapped
+Project-URL: Issues, https://github.com/bhatti013/uncapped/issues
+Author: Abdul Wahab
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,crawler,data extraction,github search,pagination,result limit,scraping,search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# uncapped
+
+[![PyPI](https://img.shields.io/pypi/v/uncapped)](https://pypi.org/project/uncapped/)
+[![Python](https://img.shields.io/pypi/pyversions/uncapped)](https://pypi.org/project/uncapped/)
+[![CI](https://github.com/bhatti013/uncapped/actions/workflows/ci.yml/badge.svg)](https://github.com/bhatti013/uncapped/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/bhatti013/uncapped/blob/main/LICENSE)
+
+**Get every result from searches that stop at 1,000.**
+
+Lots of APIs and sites cut you off no matter how many results match:
+
+| Source | Most results per search |
+|---|---|
+| GitHub search API | 1,000 |
+| Algolia (default `paginationLimitedTo`) | 1,000 |
+| Elasticsearch / OpenSearch `from` + `size` (default `max_result_window`) | 10,000 |
+| Google Places text search | 60 |
+| Most listing, travel and job sites | a few hundred to ~1,000 |
+
+The fix is always the same: narrow the search with filters (price, date,
+category...) until each piece is under the limit, then page through every
+piece. uncapped does the narrowing for you, picks how finely to cut so you
+spend as few calls as possible, and tells you if anything still can't be
+reached.
+
+- Zero dependencies, Python 3.10+, fully typed
+- Works with any client: `requests`, `httpx`, an SDK, Scrapy, SQL
+- Sync and async
+- Splits on numbers, dates and categories, and falls back to the next filter when one runs out
+- Resumable: counts can be cached in any dict-like store
+
+## Install
+
+```bash
+pip install uncapped
+```
+
+## Example: every Rust repo with more than 1,000 stars
+
+GitHub's search finds 2,478 of them but will only ever return 1,000. You
+tell uncapped how to **count** results for a set of filters; it gives you back
+windows that each fit under the cap.
+
+```python
+import requests
+from uncapped import split, DateRange
+
+QUERY = "language:rust stars:>1000"
+
+def with_filters(filters):
+    if "created" not in filters:
+        return QUERY
+    lo, hi = filters["created"]
+    return f"{QUERY} created:{lo}..{hi}"
+
+def count(filters):
+    r = requests.get("https://api.github.com/search/repositories",
+                     params={"q": with_filters(filters), "per_page": 1})
+    return r.json()["total_count"]
+
+run = split(count, cap=1000, dims=[DateRange("created", "2008-01-01", "today")])
+
+for window in run:
+    print(window.filters["created"], window.count)
+    # page through with_filters(window.filters) as usual: it's under 1,000
+
+print(run.stats)
+```
+
+Real output (November 2026):
+
+```
+created                     repos
+2008-01-01 .. 2017-06-04      419
+2017-06-05 .. 2022-02-19      984
+2022-02-20 .. 2024-06-29      513
+2024-06-30 .. 2026-11-06      562
+
+2,478 repos match. Without uncapped you'd get 1,000.
+4 windows, 2,478 fetchable (100%), 7 count requests.
+```
+
+Paging through those 4 windows downloaded all 2,478 repos, with no duplicates.
+The runnable version, with rate-limit handling and download, is
+[`examples/github_repos.py`](https://github.com/bhatti013/uncapped/blob/main/examples/github_repos.py).
+
+## How it works
+
+1. Count the whole search. Under the cap? Done: one window, no filters.
+2. Over the cap? Cut the first dimension's range into parts. With the default
+   `fanout="auto"` the number of parts depends on how far over the cap it is
+   (5× over the cap → 7 parts), so you don't pay for many rounds of halving.
+3. Count each part. Parts under the cap become windows; parts over it are cut
+   again. Empty parts are dropped.
+4. When a dimension is down to a single value (every listing in this window
+   costs exactly 42) uncapped moves on to the next dimension.
+5. Neighbouring windows that together still fit under the cap are merged into
+   one wider window, so you page through fewer of them. Around a dense spot
+   (2,500 listings at one price) this turns 27 windows into 6. Merged counts
+   stay exact: uncapped never merges across results it couldn't reach. Pass
+   `merge=False` to keep every window as it was split.
+6. Windows come out in order while the plan is still being worked out, so you
+   can start fetching before it's finished.
+
+## Dimensions
+
+Your `count` function receives a dict keyed by dimension name. A dimension
+that hasn't been needed yet is **left out**, so filter on it only when it's there.
+
+```python
+from datetime import datetime, timedelta
+from uncapped import Range, DateRange, Values
+
+Range("price", 0, 5_000_000)                # filters["price"] == (0, 2_499_999), inclusive
+Range("rating", 0, 5, step=0.1)             # floats work; step is the smallest gap the source sees
+DateRange("listed", "2023-01-01", "today")  # filters["listed"] == (date(...), date(...)), inclusive
+DateRange("posted", datetime(2024, 1, 1), "now", step=timedelta(minutes=1))
+Values("type", ["apartment", "villa", "office"])            # one value at a time: filters["type"] == "villa"
+Values("lang", ["python", "go", "rust"], multi=True)         # groups: filters["lang"] == ("python", "go")
+```
+
+Give several dimensions in order of preference. uncapped splits on the first
+until it can't, then the second:
+
+```python
+split(count, cap=1000, dims=[
+    Range("price", 0, 10_000_000),
+    DateRange("listed", "2020-01-01", "today"),
+])
+```
+
+## Knowing what you didn't get
+
+uncapped never fails silently. After a run, `run.stats` has the numbers and an
+`UncappedWarning` is raised for anything you'd miss:
+
+```python
+Stats(total=48213, windows=61, fetchable=47650, capped_windows=1,
+      unaccounted=313, queries=74, cache_hits=0, max_depth=3)
+```
+
+- **`capped_windows`**: windows still over the cap after every dimension is
+  down to one value. They're yielded with `window.complete == False`; you can
+  fetch the first `cap` results of each. Add another dimension or a finer
+  `step`. Use `on_capped="raise"` to stop instead, or `"ignore"` to stay quiet.
+- **`unaccounted`**: the parts of a split added up to less than the whole.
+  That's almost always items with **no value** for the filter (a listing
+  without a price never matches any price range) or values outside the range
+  you gave. Widen the range, or fetch those items another way.
+
+## Async
+
+`count` can be async. Sibling counts run concurrently, up to `concurrency`:
+
+```python
+import httpx
+from uncapped import asplit, Range
+
+async def count(filters):
+    lo, hi = filters.get("price", (None, None))
+    r = await client.get("/search", params={"min_price": lo, "max_price": hi, "limit": 1})
+    return r.json()["total"]
+
+async for window in asplit(count, cap=1000, dims=[Range("price", 0, 10**7)], concurrency=8):
+    ...
+```
+
+## Resuming and saving calls
+
+Pass any dict-like object as `cache` and counts are stored there. With a
+persistent one, a crashed or repeated run re-plans without calling the API
+again:
+
+```python
+import shelve
+
+with shelve.open("counts") as cache:
+    for window in split(count, cap=1000, dims=dims, cache=cache):
+        ...
+```
+
+Counts are cached by their filters and don't expire. Delete the file when you
+want fresh numbers.
+
+## Recipes
+
+**Elasticsearch / OpenSearch** (when you can't use `search_after` or a point in time):
+
+```python
+def count(filters):
+    query = {"bool": {"filter": []}}
+    if "ts" in filters:
+        lo, hi = filters["ts"]
+        query["bool"]["filter"].append({"range": {"ts": {"gte": lo.isoformat(), "lte": hi.isoformat()}}})
+    return es.count(index="events", query=query)["count"]
+
+split(count, cap=10_000, dims=[DateRange("ts", datetime(2024, 1, 1), "now", step=timedelta(seconds=1))])
+```
+
+**A listing site's JSON API** with min/max price parameters:
+
+```python
+def count(filters):
+    params = {"category": "cars", "page_size": 1}
+    if "price" in filters:
+        params["price_min"], params["price_max"] = filters["price"]
+    return session.get(SEARCH_URL, params=params).json()["meta"]["total"]
+```
+
+## FAQ
+
+**Why not just ask for page 11?** The cap is enforced by the server. Past it
+you get an error or the same results again.
+
+**My source's counts are estimates.** Fine: windows are still correct, but
+`unaccounted` may show small numbers from rounding. Leave some headroom by
+passing a slightly smaller `cap` (e.g. `950`).
+
+**Data changes while I fetch.** Windows are planned from the counts at that
+moment. New items in a window may push it a little over the cap; a smaller
+`cap` gives you headroom here too.
+
+**Is this allowed?** uncapped only decides which searches to run. Respect the
+terms and rate limits of whatever you query.
+
+## License
+
+MIT

uncapped-0.1.0/README.md

@@ -0,0 +1,228 @@
+# uncapped
+
+[![PyPI](https://img.shields.io/pypi/v/uncapped)](https://pypi.org/project/uncapped/)
+[![Python](https://img.shields.io/pypi/pyversions/uncapped)](https://pypi.org/project/uncapped/)
+[![CI](https://github.com/bhatti013/uncapped/actions/workflows/ci.yml/badge.svg)](https://github.com/bhatti013/uncapped/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/bhatti013/uncapped/blob/main/LICENSE)
+
+**Get every result from searches that stop at 1,000.**
+
+Lots of APIs and sites cut you off no matter how many results match:
+
+| Source | Most results per search |
+|---|---|
+| GitHub search API | 1,000 |
+| Algolia (default `paginationLimitedTo`) | 1,000 |
+| Elasticsearch / OpenSearch `from` + `size` (default `max_result_window`) | 10,000 |
+| Google Places text search | 60 |
+| Most listing, travel and job sites | a few hundred to ~1,000 |
+
+The fix is always the same: narrow the search with filters (price, date,
+category...) until each piece is under the limit, then page through every
+piece. uncapped does the narrowing for you, picks how finely to cut so you
+spend as few calls as possible, and tells you if anything still can't be
+reached.
+
+- Zero dependencies, Python 3.10+, fully typed
+- Works with any client: `requests`, `httpx`, an SDK, Scrapy, SQL
+- Sync and async
+- Splits on numbers, dates and categories, and falls back to the next filter when one runs out
+- Resumable: counts can be cached in any dict-like store
+
+## Install
+
+```bash
+pip install uncapped
+```
+
+## Example: every Rust repo with more than 1,000 stars
+
+GitHub's search finds 2,478 of them but will only ever return 1,000. You
+tell uncapped how to **count** results for a set of filters; it gives you back
+windows that each fit under the cap.
+
+```python
+import requests
+from uncapped import split, DateRange
+
+QUERY = "language:rust stars:>1000"
+
+def with_filters(filters):
+    if "created" not in filters:
+        return QUERY
+    lo, hi = filters["created"]
+    return f"{QUERY} created:{lo}..{hi}"
+
+def count(filters):
+    r = requests.get("https://api.github.com/search/repositories",
+                     params={"q": with_filters(filters), "per_page": 1})
+    return r.json()["total_count"]
+
+run = split(count, cap=1000, dims=[DateRange("created", "2008-01-01", "today")])
+
+for window in run:
+    print(window.filters["created"], window.count)
+    # page through with_filters(window.filters) as usual: it's under 1,000
+
+print(run.stats)
+```
+
+Real output (November 2026):
+
+```
+created                     repos
+2008-01-01 .. 2017-06-04      419
+2017-06-05 .. 2022-02-19      984
+2022-02-20 .. 2024-06-29      513
+2024-06-30 .. 2026-11-06      562
+
+2,478 repos match. Without uncapped you'd get 1,000.
+4 windows, 2,478 fetchable (100%), 7 count requests.
+```
+
+Paging through those 4 windows downloaded all 2,478 repos, with no duplicates.
+The runnable version, with rate-limit handling and download, is
+[`examples/github_repos.py`](https://github.com/bhatti013/uncapped/blob/main/examples/github_repos.py).
+
+## How it works
+
+1. Count the whole search. Under the cap? Done: one window, no filters.
+2. Over the cap? Cut the first dimension's range into parts. With the default
+   `fanout="auto"` the number of parts depends on how far over the cap it is
+   (5× over the cap → 7 parts), so you don't pay for many rounds of halving.
+3. Count each part. Parts under the cap become windows; parts over it are cut
+   again. Empty parts are dropped.
+4. When a dimension is down to a single value (every listing in this window
+   costs exactly 42) uncapped moves on to the next dimension.
+5. Neighbouring windows that together still fit under the cap are merged into
+   one wider window, so you page through fewer of them. Around a dense spot
+   (2,500 listings at one price) this turns 27 windows into 6. Merged counts
+   stay exact: uncapped never merges across results it couldn't reach. Pass
+   `merge=False` to keep every window as it was split.
+6. Windows come out in order while the plan is still being worked out, so you
+   can start fetching before it's finished.
+
+## Dimensions
+
+Your `count` function receives a dict keyed by dimension name. A dimension
+that hasn't been needed yet is **left out**, so filter on it only when it's there.
+
+```python
+from datetime import datetime, timedelta
+from uncapped import Range, DateRange, Values
+
+Range("price", 0, 5_000_000)                # filters["price"] == (0, 2_499_999), inclusive
+Range("rating", 0, 5, step=0.1)             # floats work; step is the smallest gap the source sees
+DateRange("listed", "2023-01-01", "today")  # filters["listed"] == (date(...), date(...)), inclusive
+DateRange("posted", datetime(2024, 1, 1), "now", step=timedelta(minutes=1))
+Values("type", ["apartment", "villa", "office"])            # one value at a time: filters["type"] == "villa"
+Values("lang", ["python", "go", "rust"], multi=True)         # groups: filters["lang"] == ("python", "go")
+```
+
+Give several dimensions in order of preference. uncapped splits on the first
+until it can't, then the second:
+
+```python
+split(count, cap=1000, dims=[
+    Range("price", 0, 10_000_000),
+    DateRange("listed", "2020-01-01", "today"),
+])
+```
+
+## Knowing what you didn't get
+
+uncapped never fails silently. After a run, `run.stats` has the numbers and an
+`UncappedWarning` is raised for anything you'd miss:
+
+```python
+Stats(total=48213, windows=61, fetchable=47650, capped_windows=1,
+      unaccounted=313, queries=74, cache_hits=0, max_depth=3)
+```
+
+- **`capped_windows`**: windows still over the cap after every dimension is
+  down to one value. They're yielded with `window.complete == False`; you can
+  fetch the first `cap` results of each. Add another dimension or a finer
+  `step`. Use `on_capped="raise"` to stop instead, or `"ignore"` to stay quiet.
+- **`unaccounted`**: the parts of a split added up to less than the whole.
+  That's almost always items with **no value** for the filter (a listing
+  without a price never matches any price range) or values outside the range
+  you gave. Widen the range, or fetch those items another way.
+
+## Async
+
+`count` can be async. Sibling counts run concurrently, up to `concurrency`:
+
+```python
+import httpx
+from uncapped import asplit, Range
+
+async def count(filters):
+    lo, hi = filters.get("price", (None, None))
+    r = await client.get("/search", params={"min_price": lo, "max_price": hi, "limit": 1})
+    return r.json()["total"]
+
+async for window in asplit(count, cap=1000, dims=[Range("price", 0, 10**7)], concurrency=8):
+    ...
+```
+
+## Resuming and saving calls
+
+Pass any dict-like object as `cache` and counts are stored there. With a
+persistent one, a crashed or repeated run re-plans without calling the API
+again:
+
+```python
+import shelve
+
+with shelve.open("counts") as cache:
+    for window in split(count, cap=1000, dims=dims, cache=cache):
+        ...
+```
+
+Counts are cached by their filters and don't expire. Delete the file when you
+want fresh numbers.
+
+## Recipes
+
+**Elasticsearch / OpenSearch** (when you can't use `search_after` or a point in time):
+
+```python
+def count(filters):
+    query = {"bool": {"filter": []}}
+    if "ts" in filters:
+        lo, hi = filters["ts"]
+        query["bool"]["filter"].append({"range": {"ts": {"gte": lo.isoformat(), "lte": hi.isoformat()}}})
+    return es.count(index="events", query=query)["count"]
+
+split(count, cap=10_000, dims=[DateRange("ts", datetime(2024, 1, 1), "now", step=timedelta(seconds=1))])
+```
+
+**A listing site's JSON API** with min/max price parameters:
+
+```python
+def count(filters):
+    params = {"category": "cars", "page_size": 1}
+    if "price" in filters:
+        params["price_min"], params["price_max"] = filters["price"]
+    return session.get(SEARCH_URL, params=params).json()["meta"]["total"]
+```
+
+## FAQ
+
+**Why not just ask for page 11?** The cap is enforced by the server. Past it
+you get an error or the same results again.
+
+**My source's counts are estimates.** Fine: windows are still correct, but
+`unaccounted` may show small numbers from rounding. Leave some headroom by
+passing a slightly smaller `cap` (e.g. `950`).
+
+**Data changes while I fetch.** Windows are planned from the counts at that
+moment. New items in a window may push it a little over the cap; a smaller
+`cap` gives you headroom here too.
+
+**Is this allowed?** uncapped only decides which searches to run. Respect the
+terms and rate limits of whatever you query.
+
+## License
+
+MIT

uncapped-0.1.0/examples/github_repos.py

@@ -0,0 +1,99 @@
+"""Every repository matching a GitHub search, past GitHub's 1,000-result limit.
+
+GitHub's search API returns at most 1,000 results per query, however many
+match. This splits the query by creation date until every window fits, then
+(optionally) pages through each window.
+
+    python examples/github_repos.py "language:rust stars:>1000"
+    python examples/github_repos.py "language:rust stars:>1000" --fetch rust.jsonl
+
+Set GITHUB_TOKEN for a higher rate limit (30 searches/minute instead of 10).
+Standard library only, besides uncapped.
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from urllib.error import HTTPError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from uncapped import DateRange, split
+
+API = "https://api.github.com/search/repositories"
+CAP = 1000  # GitHub search never returns more than this
+PER_PAGE = 100
+
+
+def search(q, page=1, per_page=PER_PAGE):
+    headers = {"Accept": "application/vnd.github+json", "User-Agent": "uncapped-example"}
+    if os.environ.get("GITHUB_TOKEN"):
+        headers["Authorization"] = f"Bearer {os.environ['GITHUB_TOKEN']}"
+    url = f"{API}?{urlencode({'q': q, 'page': page, 'per_page': per_page})}"
+    while True:
+        try:
+            with urlopen(Request(url, headers=headers), timeout=30) as resp:
+                return json.load(resp)
+        except HTTPError as e:
+            if e.code not in (403, 429):
+                raise
+            wait = int(e.headers.get("retry-after") or 0)
+            if not wait and e.headers.get("x-ratelimit-remaining") == "0":
+                wait = int(e.headers["x-ratelimit-reset"]) - int(time.time()) + 1
+            if wait <= 0:
+                raise
+            print(f"  rate limited, waiting {wait}s", file=sys.stderr)
+            time.sleep(wait)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("query", help='GitHub search query, e.g. "language:rust stars:>1000"')
+    parser.add_argument("--since", default="2008-01-01", help="earliest creation date")
+    parser.add_argument("--fetch", metavar="FILE", help="also download every repo to this JSONL file")
+    args = parser.parse_args()
+
+    def with_filters(filters):
+        if "created" not in filters:
+            return args.query
+        lo, hi = filters["created"]
+        return f"{args.query} created:{lo}..{hi}"
+
+    def count(filters):
+        return search(with_filters(filters), per_page=1)["total_count"]
+
+    run = split(count, cap=CAP, dims=[DateRange("created", args.since, "today")])
+
+    print(f"{'created':<25} {'repos':>7}")
+    windows = []
+    for w in run:
+        lo, hi = w.filters.get("created", ("(all)", ""))
+        print(f"{lo!s:>10} .. {hi!s:<11} {w.count:>7,}")
+        windows.append(w)
+
+    s = run.stats
+    print(
+        f"\n{s.total:,} repos match. Without uncapped you'd get {min(s.total, CAP):,}.\n"
+        f"{s.windows} windows, {s.fetchable:,} fetchable ({s.coverage:.0%}), "
+        f"{s.queries} count requests."
+    )
+
+    if not args.fetch:
+        return
+    seen = set()
+    with open(args.fetch, "w") as out:
+        for w in windows:
+            q = with_filters(w.filters)
+            for page in range(1, -(-min(w.count, CAP) // PER_PAGE) + 1):
+                for repo in search(q, page=page)["items"]:
+                    if repo["id"] not in seen:
+                        seen.add(repo["id"])
+                        out.write(json.dumps(repo) + "\n")
+            print(f"  fetched {len(seen):,} / {s.total:,}", file=sys.stderr)
+    print(f"\nWrote {len(seen):,} unique repos to {args.fetch}")
+
+
+if __name__ == "__main__":
+    main()

uncapped-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "uncapped"
+dynamic = ["version"]
+description = "Get every result from APIs and sites that stop at 1,000 results, by splitting the search into windows that fit under the cap."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Abdul Wahab" }]
+keywords = ["pagination", "search", "api", "scraping", "result limit", "github search", "crawler", "data extraction"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/bhatti013/uncapped"
+Issues = "https://github.com/bhatti013/uncapped/issues"
+
+[tool.hatch.version]
+path = "src/uncapped/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "examples", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+filterwarnings = ["error"]