reqstorm 2.0.1__py3-none-any.whl

reqstorm/_limits.py

@@ -0,0 +1,73 @@
+"""Per-host request rate limiting."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+import time
+from typing import Dict, Optional, Tuple, Union
+
+from yarl import URL
+
+
+def host_key(url: str) -> Optional[str]:
+    """``host:port`` of a URL, or None when it has no host (the request will fail anyway)."""
+    try:
+        parsed = URL(url)
+    except (TypeError, ValueError):
+        return None
+    if not parsed.host:
+        return None
+    return f"{parsed.host}:{parsed.port}"
+
+
+RateLimit = Union[float, int, str, Tuple[float, float]]
+
+_UNITS = {
+    "s": 1.0, "sec": 1.0, "second": 1.0, "seconds": 1.0,
+    "m": 60.0, "min": 60.0, "minute": 60.0, "minutes": 60.0,
+    "h": 3600.0, "hr": 3600.0, "hour": 3600.0, "hours": 3600.0,
+    "d": 86400.0, "day": 86400.0, "days": 86400.0,
+}  # fmt: skip
+
+
+def parse_rate(rate: RateLimit) -> float:
+    """Requests per second from ``5``, ``"100/min"``, ``"30/5min"``, ``"1000/h"`` or ``(100, 60)``."""
+    if isinstance(rate, bool):
+        raise TypeError("rate_limit must be a number, a string such as '100/min', or (count, seconds)")
+    if isinstance(rate, (int, float)):
+        per_second = float(rate)
+    elif isinstance(rate, tuple):
+        count, seconds = rate
+        per_second = float(count) / float(seconds)
+    elif isinstance(rate, str):
+        count_text, _, period = rate.replace(" ", "").partition("/")
+        match = re.fullmatch(r"(\d*\.?\d*)([a-z]+)", period.lower())
+        if not count_text or not match or match.group(2) not in _UNITS:
+            raise ValueError(f"invalid rate_limit {rate!r}; use for example '10/s', '100/min' or '1000/h'")
+        multiplier = float(match.group(1)) if match.group(1) else 1.0
+        per_second = float(count_text) / (multiplier * _UNITS[match.group(2)])
+    else:
+        raise TypeError("rate_limit must be a number, a string such as '100/min', or (count, seconds)")
+    if not per_second > 0:
+        raise ValueError("rate_limit must be greater than 0")
+    return per_second
+
+
+class HostRateLimiter:
+    """Spaces out requests evenly so that each host gets at most the given rate."""
+
+    def __init__(self, rate: RateLimit) -> None:
+        self._interval = 1.0 / parse_rate(rate)
+        self._next_slot: Dict[str, float] = {}
+
+    async def wait(self, url: str) -> None:
+        host = host_key(url)
+        if host is None:
+            return
+        now = time.monotonic()
+        # Reserve the next free slot synchronously, so concurrent callers never share one.
+        slot = max(now, self._next_slot.get(host, now))
+        self._next_slot[host] = slot + self._interval
+        if slot > now:
+            await asyncio.sleep(slot - now)

reqstorm/_plan.py

@@ -0,0 +1,60 @@
+"""Estimate how long a batch will take before sending it."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from ._limits import RateLimit, parse_rate
+from ._progress import format_duration
+
+
+@dataclass(frozen=True)
+class Estimate:
+    """How long ``requests`` requests should take, and which setting limits them."""
+
+    requests: int
+    seconds: float
+    limited_by: str
+
+    def __str__(self) -> str:
+        return (
+            f"{self.requests} requests: about {format_duration(self.seconds)} (limited by {self.limited_by})"
+        )
+
+
+def estimate(
+    requests: int,
+    *,
+    rate_limit: Optional[RateLimit] = None,
+    hosts: int = 1,
+    concurrency: int = 100,
+    concurrency_per_host: int = 0,
+    latency: float = 0.5,
+) -> Estimate:
+    """Estimate the duration of a batch, without sending anything.
+
+        >>> print(reqstorm.estimate(7000, rate_limit="100/min"))
+        7000 requests: about 1h 10m (limited by rate_limit)
+
+    Args:
+        requests: Number of requests.
+        rate_limit: The per-host rate limit you plan to use (same formats as ``fetch_all``).
+        hosts: How many different hosts the requests are spread evenly over.
+        concurrency: The overall concurrency you plan to use.
+        concurrency_per_host: The per-host concurrency you plan to use; 0 means none.
+        latency: Typical seconds per request (response time); 0.5 by default.
+
+    Retries are not included; they add time for requests that fail.
+    """
+    if requests < 0 or hosts < 1 or concurrency < 1 or latency < 0:
+        raise ValueError("requests must be >= 0, hosts and concurrency >= 1, latency >= 0")
+    in_flight = concurrency
+    if concurrency_per_host:
+        in_flight = min(in_flight, concurrency_per_host * hosts)
+    candidates = {"concurrency": requests * latency / in_flight}
+    if rate_limit is not None:
+        per_host = requests / hosts
+        candidates["rate_limit"] = max(per_host - 1, 0) / parse_rate(rate_limit) + latency
+    limited_by = max(candidates, key=lambda name: candidates[name])
+    return Estimate(requests=requests, seconds=candidates[limited_by], limited_by=limited_by)

reqstorm/_progress.py

@@ -0,0 +1,82 @@
+"""A small progress line for long batches, with no extra dependency."""
+
+from __future__ import annotations
+
+import sys
+import time
+from typing import TYPE_CHECKING, Optional, TextIO, Union
+
+if TYPE_CHECKING:
+    from ._client import Result
+
+ProgressTarget = Union[bool, TextIO]
+
+
+def format_duration(seconds: float) -> str:
+    """``42s``, ``3m 05s``, ``1h 10m``."""
+    seconds = max(int(round(seconds)), 0)
+    hours, rest = divmod(seconds, 3600)
+    minutes, secs = divmod(rest, 60)
+    if hours:
+        return f"{hours}h {minutes:02d}m"
+    if minutes:
+        return f"{minutes}m {secs:02d}s"
+    return f"{secs}s"
+
+
+class Progress:
+    """Prints ``done/total``, successes, failures and the request rate.
+
+    On a terminal the line is rewritten in place several times a second; when the
+    output is redirected (a log file, CI) a new line is written every few seconds.
+    """
+
+    def __init__(self, stream: TextIO, total: Optional[int]) -> None:
+        self._stream = stream
+        self._total = total
+        self._interactive = bool(getattr(stream, "isatty", lambda: False)())
+        self._interval = 0.2 if self._interactive else 5.0
+        self._started = time.monotonic()
+        self._last_print = 0.0
+        self.done = 0
+        self.ok = 0
+        self.failed = 0
+
+    @classmethod
+    def create(cls, target: ProgressTarget, total: Optional[int]) -> Optional[Progress]:
+        if target is False or target is None:
+            return None
+        return cls(sys.stderr if target is True else target, total)
+
+    def update(self, result: Result) -> None:
+        self.done += 1
+        if result.ok:
+            self.ok += 1
+        else:
+            self.failed += 1
+        now = time.monotonic()
+        if now - self._last_print >= self._interval:
+            self._last_print = now
+            self._write(final=False)
+
+    def close(self) -> None:
+        self._write(final=True)
+
+    def _line(self) -> str:
+        elapsed = max(time.monotonic() - self._started, 1e-9)
+        rate = self.done / elapsed
+        if self._total:
+            count = f"{self.done}/{self._total} ({self.done * 100 // self._total}%)"
+        else:
+            count = str(self.done)
+        line = f"reqstorm: {count}  ok {self.ok}  failed {self.failed}  {rate:.1f} req/s"
+        if self._total and rate > 0 and self.done < self._total:
+            line += f"  ETA {format_duration((self._total - self.done) / rate)}"
+        return line
+
+    def _write(self, final: bool) -> None:
+        if self._interactive:
+            self._stream.write("\r" + self._line() + ("\n" if final else ""))
+        else:
+            self._stream.write(self._line() + "\n")
+        self._stream.flush()

reqstorm/_sync.py

@@ -0,0 +1,135 @@
+"""Blocking wrappers, for scripts that do not use asyncio."""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import queue
+import threading
+from typing import Any, Awaitable, Iterable, Iterator, TypeVar, Union
+
+from ._client import Request, Result, Results, fetch_all, stream
+from ._files import Summary, fetch_to_db, fetch_to_file
+
+T = TypeVar("T")
+
+
+def _run(awaitable: Awaitable[T]) -> T:
+    """Run a coroutine to completion, even when called from inside a running event loop.
+
+    Inside a running loop (for example a Jupyter notebook) ``asyncio.run`` is not allowed,
+    so the coroutine runs on a fresh loop in a helper thread instead.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(awaitable)  # type: ignore[arg-type]
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+        return executor.submit(asyncio.run, awaitable).result()  # type: ignore[arg-type]
+
+
+def fetch_all_sync(urls: Iterable[Union[str, Request]], method: str = "GET", **options: Any) -> Results:
+    """Blocking version of ``fetch_all``: send the requests and return their results in order.
+
+    Takes the same options as ``fetch_all`` except ``session``, which belongs to an event loop.
+
+        results = reqstorm.fetch_all_sync(urls, concurrency=20, retries=2)
+    """
+    if "session" in options:
+        raise TypeError("fetch_all_sync() does not accept `session`; use fetch_all() inside your event loop")
+    return _run(fetch_all(urls, method, **options))
+
+
+def fetch_to_file_sync(urls: Iterable[Union[str, Request]], path: Any, **options: Any) -> Summary:
+    """Blocking version of ``fetch_to_file``."""
+    if "session" in options:
+        raise TypeError(
+            "fetch_to_file_sync() does not accept `session`; use fetch_to_file() inside your event loop"
+        )
+    return _run(fetch_to_file(urls, path, **options))
+
+
+def fetch_to_db_sync(urls: Iterable[Union[str, Request]], connection: Any, **options: Any) -> Summary:
+    """Blocking version of ``fetch_to_db``.
+
+    The requests run on a helper thread when called from a running event loop; a sqlite3
+    connection must then be opened with ``check_same_thread=False``.
+    """
+    if "session" in options:
+        raise TypeError(
+            "fetch_to_db_sync() does not accept `session`; use fetch_to_db() inside your event loop"
+        )
+    return _run(fetch_to_db(urls, connection, **options))
+
+
+_FINISHED = object()
+
+
+def stream_sync(urls: Iterable[Union[str, Request]], method: str = "GET", **options: Any) -> Iterator[Result]:
+    """Blocking version of ``stream``: yield each ``Result`` as soon as it completes.
+
+    The requests run on an event loop in a background thread. Leaving the loop early
+    (``break``) stops the remaining requests.
+
+        for result in reqstorm.stream_sync(urls, concurrency=50):
+            print(result.url, result.status)
+    """
+    if "session" in options:
+        raise TypeError("stream_sync() does not accept `session`; use stream() inside your event loop")
+    results: queue.Queue[Any] = queue.Queue(maxsize=max(int(options.get("concurrency", 100)) * 2, 1))
+    stop = threading.Event()
+
+    async def produce() -> None:
+        generator = stream(urls, method, **options)
+        try:
+            async for result in generator:
+                while not stop.is_set():
+                    try:
+                        results.put_nowait(result)
+                        break
+                    except queue.Full:
+                        await asyncio.sleep(0.01)  # the consumer is slower: wait without blocking the loop
+                if stop.is_set():
+                    return
+        finally:
+            await generator.aclose()
+
+    loop = asyncio.new_event_loop()
+    task: asyncio.Future[None] = loop.create_task(produce())
+
+    def run() -> None:
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(task)
+        except asyncio.CancelledError:
+            results.put(_FINISHED)
+        except BaseException as error:
+            results.put(error)
+        else:
+            results.put(_FINISHED)
+        finally:
+            loop.run_until_complete(loop.shutdown_asyncgens())
+            loop.close()
+
+    thread = threading.Thread(target=run, name="reqstorm-stream", daemon=True)
+    thread.start()
+    try:
+        while True:
+            item = results.get()
+            if item is _FINISHED:
+                return
+            if isinstance(item, BaseException):
+                raise item
+            yield item
+    finally:
+        stop.set()
+        if not task.done():
+            try:
+                loop.call_soon_threadsafe(task.cancel)  # stop requests still in flight
+            except RuntimeError:
+                pass  # the loop has just finished and closed on its own
+        while thread.is_alive():  # let the producer notice `stop` even if the queue is full
+            try:
+                results.get_nowait()
+            except queue.Empty:
+                thread.join(0.05)

reqstorm-2.0.1.dist-info/METADATA

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: reqstorm
+Version: 2.0.1
+Summary: Send large numbers of HTTP requests concurrently with asyncio, with retries, timeouts and per-request results.
+Author-email: Melih Colpan <melihcolpan1@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://reqstorm.github.io
+Project-URL: Source, https://github.com/melihcolpan/reqstorm
+Project-URL: Changelog, https://github.com/melihcolpan/reqstorm/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/melihcolpan/reqstorm/issues
+Keywords: asyncio,aiohttp,http,requests,concurrent,bulk,rate-limit,retry,crawler,scraping
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+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.9
+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: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp<4,>=3.9
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Requires-Dist: trustme>=1.1; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff>=0.6; extra == "lint"
+Requires-Dist: mypy>=1.10; extra == "lint"
+Dynamic: license-file
+
+# reqstorm
+
+[![PyPI](https://img.shields.io/pypi/v/reqstorm)](https://pypi.org/project/reqstorm/)
+[![Python](https://img.shields.io/pypi/pyversions/reqstorm)](https://pypi.org/project/reqstorm/)
+[![CI](https://github.com/melihcolpan/reqstorm/actions/workflows/ci.yml/badge.svg)](https://github.com/melihcolpan/reqstorm/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+**Documentation: [reqstorm.github.io](https://reqstorm.github.io)**
+
+> **reqstorm** is the new name of **reqt**. If you used reqt, see [Coming from reqt](#coming-from-reqt).
+
+**reqstorm** sends large numbers of HTTP requests concurrently and gives you one result per request, with rate limits, retries, progress and output to files or databases built in.
+
+```python
+import reqstorm
+
+urls = [f"https://api.example.com/items/{i}" for i in range(7000)]
+
+print(reqstorm.estimate(len(urls), rate_limit="100/min"))
+# 7000 requests: about 1h 10m (limited by rate_limit)
+
+results = reqstorm.fetch_all_sync(urls, rate_limit="100/min", retries=2, progress=True)
+
+print(results.summary())
+# {'total': 7000, 'ok': 6987, 'failed': 13, 'failures': {'HTTP 404': 9, 'TimeoutError': 4}}
+for error in results.errors():
+    print(error["url"], error["error"] or error["status"])
+```
+
+- **Every request gets a result.** A timeout, a dropped connection or an invalid URL is recorded on that request and never stops the others. Each result keeps the history of its attempts.
+- **Rate limits per host** in any unit (`"10/s"`, `"100/min"`, `"1000/h"`), plus overall and per-host concurrency limits.
+- **Timeouts and retries**: immediate retries with exponential backoff and `Retry-After` support, and retry rounds that resend what still failed at the end.
+- **Large batches**: stream results as they finish, or write them straight to JSONL, CSV, SQLite, PostgreSQL or MySQL, and resume an interrupted run where it stopped.
+- **Works with or without asyncio**, and inside Jupyter notebooks.
+- **TLS certificates are verified** by default. Fully typed, with a single dependency: [aiohttp](https://docs.aiohttp.org).
+
+## Installation
+
+```console
+$ python -m pip install reqstorm
+```
+
+reqstorm supports Python 3.9 and newer.
+
+## Usage
+
+Every function has an async version for code that already runs an event loop: `fetch_all`, `stream`, `fetch_to_file`, `fetch_to_db`. The blocking versions end in `_sync`. They take the same options.
+
+```python
+results = reqstorm.fetch_all_sync(urls)  # in a script or a notebook
+results = await reqstorm.fetch_all(urls)  # inside async code
+```
+
+### Results
+
+`fetch_all` returns a `Results` list with one `Result` per request, in input order.
+
+| `Result` attribute | Meaning |
+|---|---|
+| `ok` | `True` when a response arrived with a status below 400 |
+| `status`, `headers`, `body` | The response (`status` is `None` if none arrived) |
+| `text()`, `json()` | The body decoded as text (using the response charset) or JSON |
+| `error` | The exception that prevented a response, or `None` |
+| `attempts`, `elapsed`, `history` | Number of attempts, total seconds, and each attempt's status, error and duration |
+| `url`, `method`, `final_url`, `index` | What was requested, where redirects ended, and its position in the input |
+
+`result.raise_for_error()` raises the request's error, or `reqstorm.HTTPStatusError` for a status of 400 or above. `result.to_dict()` gives the same fields as plain data.
+
+The `Results` list has reporting helpers:
+
+```python
+results.succeeded  # list of successful results
+results.failed  # list of failed results
+results.summary()  # {'total': ..., 'ok': ..., 'failed': ..., 'failures': {'HTTP 404': 9, ...}}
+results.errors()  # failed requests as dicts with index, url, status, error, attempts and history
+results.to_dicts()  # every result as a dict, ready for json.dump or a DataFrame
+```
+
+### Rate limits and concurrency
+
+```python
+results = reqstorm.fetch_all_sync(
+    urls,
+    rate_limit="100/min",  # per host; also 5 (per second), "10/s", "30/5min", "1000/h", (100, 60)
+    concurrency=50,  # at most 50 requests in flight in total
+    concurrency_per_host=10,  # and at most 10 to the same host
+)
+```
+
+The rate limit applies to each host (`host:port`) separately and counts retries too. `reqstorm.estimate(requests, rate_limit=..., hosts=..., concurrency=..., latency=...)` tells you how long a batch should take before you send it.
+
+### Timeouts and retries
+
+```python
+results = reqstorm.fetch_all_sync(
+    urls,
+    timeout=10,  # seconds per attempt, including the body; None disables it
+    retries=3,  # retry right away: 0.5 s, 1 s, 2 s apart (Retry-After takes precedence)
+    backoff=0.5,
+    retry_rounds=2,  # then resend whatever still failed, after everything else...
+    retry_round_delay=30,  # ...waiting 30 s before each round
+)
+```
+
+Connection errors, timeouts and the statuses in `retry_statuses` (default: 429, 500, 502, 503, 504) are retried. Invalid URLs and other statuses such as 404 are not.
+
+### Writing results to a file
+
+`fetch_to_file` writes each result as soon as it is final, so results never pile up in memory:
+
+```python
+summary = reqstorm.fetch_to_file_sync(urls, "results.jsonl", rate_limit="10/s", progress=True)
+print(summary.ok, summary.failed, summary.errors[:5])
+```
+
+- **Format** follows the file name: `.jsonl` (JSON Lines), `.csv`, or `.db` / `.sqlite` for SQLite. Pass `format=` to override it.
+- **Order:** records are written as requests complete. With `ordered=True` they are written in input order instead; finished records then wait in memory until the ones before them are done.
+- **Resume:** with `resume=True`, requests already recorded as successful are skipped, and the others, including earlier failures, are sent again and appended. Without it a JSONL or CSV file is overwritten.
+- **Fields:** each record has `index`, `method`, `url`, `status`, `ok`, `error`, `attempts`, `elapsed`, `final_url`, `history` and `body`. Use `body="none"` to leave the body out, `body="base64"` for binary responses, and `include_headers=True` to add the response headers.
+
+`progress=True` prints a line such as `reqstorm: 3500/7000 (50%)  ok 3493  failed 7  1.7 req/s  ETA 35m 00s` to stderr.
+
+### Writing results to a database
+
+`fetch_to_db` inserts one row per request through a database connection you already have:
+
+```python
+import psycopg  # or sqlite3, psycopg2, pymysql, MySQLdb, mysql.connector
+
+with psycopg.connect("dbname=crawl") as connection:
+    summary = reqstorm.fetch_to_db_sync(urls, connection, table="api_results", resume=True)
+```
+
+reqstorm creates the table if it does not exist. The fields you filter on are real columns, and the variable parts are JSON:
+
+| Column | PostgreSQL | MySQL | SQLite |
+|---|---|---|---|
+| `id` | `BIGSERIAL` | `BIGINT AUTO_INCREMENT` | `INTEGER` |
+| `request_index`, `status`, `attempts` | `INTEGER` | `INT` | `INTEGER` |
+| `method`, `url`, `error`, `final_url` | `TEXT` | `VARCHAR` / `LONGTEXT` | `TEXT` |
+| `ok` | `BOOLEAN` | `BOOLEAN` | `INTEGER` |
+| `elapsed` | `DOUBLE PRECISION` | `DOUBLE` | `REAL` |
+| `history`, `headers` | `JSONB` | `JSON` | `TEXT` (JSON) |
+| `body` | `TEXT`, or `BYTEA` with `body="bytes"` | `LONGTEXT` / `LONGBLOB` | `TEXT` / `BLOB` |
+| `created_at` | `TIMESTAMPTZ` | `TIMESTAMP` | `TEXT` |
+
+So `SELECT url, error FROM api_results WHERE NOT ok` works directly. Rows are inserted in batches on a background thread, so a remote database does not slow down the requests. Existing rows are never deleted; with `resume=True`, requests that already have a successful row are skipped.
+
+### Methods, headers and bodies
+
+Options given to `fetch_all` apply to every request. Use `reqstorm.Request` to vary them per request:
+
+```python
+results = reqstorm.fetch_all_sync(
+    [
+        "https://api.example.com/items/1",
+        reqstorm.Request("https://api.example.com/items", method="POST", json={"name": "new"}),
+    ],
+    headers={"Authorization": "Bearer ..."},  # merged with each Request's own headers
+)
+```
+
+`fetch_all_sync(urls, "POST", json=...)` sends every plain URL as a POST. `params`, `json` and `data` work the same way.
+
+### Streaming results
+
+`stream` (or `stream_sync`) yields each result as soon as it completes. `urls` can be a generator, which is read lazily, so millions of URLs never need to be in memory at once:
+
+```python
+for result in reqstorm.stream_sync(read_urls_from_file(), concurrency=100):
+    save(result.url, result.status, result.body)
+```
+
+`fetch_all` also accepts `callback=`, a function or coroutine function called with each result as it completes.
+
+### TLS
+
+Certificates are verified by default. To trust a private certificate authority, pass an `ssl.SSLContext`:
+
+```python
+import ssl
+
+context = ssl.create_default_context(cafile="internal-ca.pem")
+results = reqstorm.fetch_all_sync(urls, ssl=context)
+```
+
+`verify_ssl=False` turns verification off. Only use it for hosts you control.
+
+### Using your own session
+
+In async code, pass an existing `aiohttp.ClientSession` with `session=` to share cookies, connection pools or proxy settings. reqstorm will not close it.
+
+## Coming from reqt
+
+reqstorm 2.0 is the next version of reqt, renamed because another project already uses that name. Install `reqstorm` and replace `import reqt` with `import reqstorm`. The `reqt` package on PyPI now just installs reqstorm and shows a deprecation warning, so existing code keeps working in the meantime.
+
+reqt 1.x called a function with each raw response and returned nothing. That style still works, with a `DeprecationWarning`:
+
+```python
+async def handle(response):  # reqt 1.x
+    print(response.status)
+
+
+await reqstorm.fetch_all(urls=urls, method=handle)
+```
+
+Two things changed even in the 1.x style:
+
+- **TLS certificates are now verified.** 1.x silently skipped verification, which let anyone in the network path impersonate the server. Pass `verify_ssl=False` only if you really need the old behaviour for hosts you control.
+- **Every failed request is logged** to the `reqstorm` logger instead of only connection errors; other errors no longer abort the whole batch.
+
+The 2.0 equivalent of the example above is:
+
+```python
+results = await reqstorm.fetch_all(urls)
+for result in results:
+    print(result.status)
+```
+
+The reqt 1.x style will be removed in reqstorm 3.0.
+
+## Development
+
+```console
+$ python -m pip install -e ".[test,lint]"
+$ pytest
+$ ruff check . && ruff format --check . && mypy reqstorm
+```
+
+The tests run against a local server and need no network access. The PostgreSQL and MySQL tests run when `REQSTORM_TEST_POSTGRES` (a libpq connection string) and `REQSTORM_TEST_MYSQL` (`host:port:user:password:database`) are set.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

reqstorm-2.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+reqstorm/__init__.py,sha256=YaFJLnbIXKf5YON32SAa8VwUDqtgvWWoAwgZxvwXX3s,1136
+reqstorm/_client.py,sha256=CSqcj8h6l_20NYv2lTZOxoHizzIxerNY1VEykPAQ5OI,20216
+reqstorm/_files.py,sha256=5eSQiTwpw7eaEQD57Tt_ozPLWqtI4kMxOe_VPpRGTRE,19905
+reqstorm/_legacy.py,sha256=QV2VEjAbV6ndGw5RXj2eSQS86_kjwEvDW5wRjpSE6xU,3106
+reqstorm/_limits.py,sha256=3_jnp95lTfeN4KjxD5oUZWdFQpi_1L24WvP6b4M5Uyw,2678
+reqstorm/_plan.py,sha256=Zk0mnbjyy45qwiQkP0bpNydrGeMdJPq7842kPhE0IWk,2188
+reqstorm/_progress.py,sha256=ma_jI-5HFZLXS2Q4ACndt2sLVmV6zGvom4v-H7f2LP4,2699
+reqstorm/_sync.py,sha256=TF66fUhlMUveauR_X2KZrxGUNUXIBBcmu7pS2iVNw0A,5066
+reqstorm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reqstorm-2.0.1.dist-info/licenses/LICENSE,sha256=Je4JBpdx1S-w4qdCWMCt7bD6fxW_cmgu9W8Wl2Znkus,1074
+reqstorm-2.0.1.dist-info/METADATA,sha256=6lbvkhF-75znsi2C1AZRY5-o3rAmYpLRsZWn3KHXnqU,12321
+reqstorm-2.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+reqstorm-2.0.1.dist-info/top_level.txt,sha256=UcK9wOskk393JpTaZsZGyjvRBoWWyGqOgK3kGsgm3Kg,9
+reqstorm-2.0.1.dist-info/RECORD,,

reqstorm-2.0.1.dist-info/WHEEL

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

reqstorm-2.0.1.dist-info/licenses/LICENSE

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

reqstorm-2.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+reqstorm