urlpipe 0.1.0__tar.gz

urlpipe-0.1.0/.gitignore

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

urlpipe-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0 — 2026-09-25
+
+The first release.
+
+- `Client` and `AsyncClient` with one method per operation: `markdown`, `html`, `summarize`, `screenshot`, `meta`, `keywords`, `console`, `lighthouse` and `scrape`, plus `result` and `wait` for tokens.
+- Calls wait for their result by default; a call that outlives the API's 60-second sync window is polled to completion.
+- Screenshots decoded to bytes, with the MIME type and the key-free image URL.
+- Response metadata parsed from headers: cache status and age, processing time, credits spent and left, concurrency limit.
+- Automatic retries for connection errors, rate and concurrency limits and 500/502/503, each call under one `Idempotency-Key`.
+- A typed error for every failure the API reports.
+- `verify_webhook` for signed webhook deliveries.

urlpipe-0.1.0/LICENSE

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

urlpipe-0.1.0/PKG-INFO

@@ -0,0 +1,262 @@
+Metadata-Version: 2.5
+Name: urlpipe
+Version: 0.1.0
+Summary: Official Python client for the URLpipe API: turn a URL into Markdown, HTML, a screenshot, metadata, a summary, keywords, console errors or a Lighthouse audit.
+Project-URL: Homepage, https://urlpipe.dev
+Project-URL: Documentation, https://urlpipe.dev/docs
+Project-URL: Source, https://github.com/URLpipe/urlpipe-python
+Project-URL: Changelog, https://github.com/URLpipe/urlpipe-python/blob/main/CHANGELOG.md
+Author-email: URLpipe <contact@urlpipe.dev>
+Maintainer-email: URLpipe <contact@urlpipe.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api client,html,lighthouse,llm,markdown,screenshot,urlpipe,web scraping
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.23
+Provides-Extra: dev
+Requires-Dist: mypy>=1.5; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# urlpipe
+
+Turn any URL into clean Markdown, rendered HTML, a full-page screenshot, metadata, a summary, keywords, console errors or a Lighthouse audit — from Python, in one call. Pages are rendered in real Chrome, so JavaScript-heavy sites come back complete.
+
+This is the official Python client for the [URLpipe API](https://urlpipe.dev/docs). It works sync or async, is fully typed, and depends only on `httpx`.
+
+## Install
+
+```sh
+pip install urlpipe
+```
+
+Python 3.9 or later.
+
+## Quickstart
+
+Create a project in the [dashboard](https://urlpipe.dev) and copy its API key. The Free plan gives you 1,000 credits a month, no card needed.
+
+```sh
+export URLPIPE_API_KEY=your_project_key
+```
+
+```python
+import urlpipe
+
+client = urlpipe.Client()  # reads URLPIPE_API_KEY
+
+page = client.markdown("https://example.com")
+print(page.data)  # "# Example Domain\n\nThis domain is for use in …"
+```
+
+Every method waits for the result and returns a `Response`:
+
+| Field | What it holds |
+|---|---|
+| `status` | `"completed"`, `"accepted"` (an async request was taken) or `"processing"` (still running) |
+| `data` | the result, typed per operation; `None` unless completed |
+| `token` | the request's token — fetch the result again for free with `client.result(token)` |
+| `labels` | the labels the request was made with |
+| `meta` | `cache`, `cache_age`, `processing_time_ms`, `quota` (`cost`, `limit`, `remaining`, `overage`, `resets_at`), `concurrency_limit`, `result_url`, `idempotent_replayed` |
+
+```python
+page.meta.cache             # "hit" — served from cache, cost nothing
+page.meta.quota.remaining   # 943, or "unlimited"
+```
+
+## Operations
+
+Every method takes the URL first; everything else is an optional keyword.
+
+```python
+client.markdown("https://example.com").data      # str: the main content as Markdown
+client.html("https://example.com").data          # str: the HTML after JavaScript ran
+client.summarize("https://example.com").data     # str: an AI summary, in Markdown
+client.meta("https://example.com").data          # dict: title, description, language, author, …
+client.keywords("https://example.com").data      # list[str], most relevant first
+client.console("https://example.com").data       # [{"type": "error", "text": "…"}, …]
+client.lighthouse("https://example.com", device="desktop", include_audits=True).data
+```
+
+### Screenshots
+
+```python
+shot = client.screenshot(
+    "https://example.com/pricing",
+    screenshot_options={"viewport_width": 390, "format": "webp"},
+).data
+
+shot.save("pricing.webp")
+shot.mime_type    # "image/webp", read from the image bytes
+shot.result_url   # a link to the image that needs no API key, for an <img> tag
+shot.data         # the decoded bytes
+```
+
+### Several operations off one page visit
+
+```python
+result = client.scrape("https://example.com", ["markdown", "meta", "screenshot"]).data
+result["operations"]["meta"]["result"]["title"]
+```
+
+Each operation has its own `success`, `result`, `error` and `cached`; one failing never affects the others. A screenshot inside a scrape is Base64 text, as the API returns it.
+
+### Options every method takes
+
+```python
+client.markdown(
+    "https://example.com/blog",
+    max_age="1 hour",                     # or seconds; 0 skips the cache
+    labels={"client": "acme"},            # your own ids, returned with the result
+    residential=True,                     # fetch from a home broadband address
+    page_options={"block_cookie_banners": True, "remove_selectors": [".promo"]},
+    idempotency_key="import-2026-09-25-17",
+)
+```
+
+`page_options` is not accepted by `lighthouse`. Options the API adds after this release can be sent with `extra`, which is merged into the request body as given:
+
+```python
+client.markdown("https://example.com", extra={"some_option": True})
+```
+
+The client passes option values through unchanged; the API validates them and answers `InvalidRequestError` naming what to change.
+
+## Async requests and `wait`
+
+Pass `sync=False` and the call returns straight away with a token, while the work carries on. Collect the result by polling, or have it POSTed to a webhook with `report_to`.
+
+```python
+accepted = client.lighthouse("https://example.com", sync=False)
+accepted.status  # "accepted"
+
+report = client.wait(accepted.token, operation="lighthouse")  # polls every 2 s
+report.data["categories"]["performance"]["score"]
+```
+
+`client.result(token)` makes a single check instead: it returns a `"processing"` Response while the work is running.
+
+`GET /result` does not say which operation made a token, so pass `operation=` to get typed `data`. Without it, JSON comes back parsed and text as a string — a screenshot stays Base64 until you ask for `wait(token, operation="screenshot")`.
+
+A synchronous call that runs past the API's 60-second window is not an error: the client polls for the result itself and returns it, for up to `wait_timeout` seconds (5 minutes by default) before raising `WaitTimeoutError`. The work keeps running either way, so `client.wait(error.token)` picks it up later.
+
+### asyncio
+
+`AsyncClient` has the same methods, as coroutines:
+
+```python
+import asyncio
+import urlpipe
+
+async def main() -> None:
+    async with urlpipe.AsyncClient() as client:
+        pages = await asyncio.gather(
+            client.markdown("https://example.com/a"),
+            client.markdown("https://example.com/b"),
+        )
+        print([p.data for p in pages])
+
+asyncio.run(main())
+```
+
+## Webhooks
+
+With webhook signing on (project **Settings → Webhook Signing**), check each delivery came from URLpipe before you trust it. `verify_webhook` needs no client:
+
+```python
+import os
+import urlpipe
+from flask import Flask, request, abort
+
+app = Flask(__name__)
+
+@app.post("/webhooks/urlpipe")
+def urlpipe_webhook():
+    try:
+        delivery = urlpipe.verify_webhook(
+            request.get_data(),          # the raw body bytes
+            request.headers,
+            os.environ["URLPIPE_WEBHOOK_SECRET"],  # whsec_…
+        )
+    except urlpipe.WebhookVerificationError:
+        abort(401)
+    enqueue(delivery["token"], delivery["result"])
+    return "", 200
+```
+
+Give it the **raw request body** exactly as received (`request.get_data()` in Flask, `await request.body()` in FastAPI, `request.body` in Django). Parsed and re-serialised JSON has different bytes, and the signature will not match. Header names are matched case-insensitively; deliveries signed more than `tolerance` seconds ago (300 by default) are refused, and during a secret rotation either signature is accepted.
+
+It returns the payload: `token`, `operation`, `labels`, `success`, `result`, `result_url`, `error` and `meta`.
+
+## Errors
+
+Every error is a `urlpipe.UrlpipeError`, with `status`, `code`, `message`, `body` and `token`.
+
+| Error | When |
+|---|---|
+| `AuthenticationError` | 401: the API key is missing or wrong |
+| `EmailUnverifiedError` | 403: confirm the email address on the account |
+| `InvalidRequestError` | 422: a parameter was refused (`invalid_url`, `invalid_options`, …); nothing ran |
+| `AnalysisFailedError` | 422: the page could not be analysed; `message` says why |
+| `QuotaExceededError` | 429: the Free plan's credits are spent (`limit`, `used`, `needed`, `resets_at`) |
+| `ConcurrencyLimitError` | 429: too many of your requests running (`limit`, `running`) |
+| `RateLimitedError` | 429: sending too fast (`retry_after`) |
+| `NotFoundError` | 404: no result for this token |
+| `StaleResultError` | 410: the result is past the 30-day window |
+| `ServerError` | 5xx |
+| `APIConnectionError` | no HTTP answer at all |
+| `WaitTimeoutError` | the result was not ready within the wait timeout (`token`) |
+
+```python
+try:
+    page = client.markdown(url)
+except urlpipe.AnalysisFailedError as error:
+    print("Could not read the page:", error.message)
+except urlpipe.QuotaExceededError as error:
+    print("Out of credits until", error.resets_at)
+```
+
+A failed analysis costs nothing, and neither does a cache hit.
+
+## Retries and idempotency
+
+The client retries connection errors, rate limits (after `Retry-After`, up to 60 s), concurrency limits and 500/502/503 responses — twice by default, with exponential backoff. It never retries a 4xx other than those, or a spent quota.
+
+A retry is only safe if it cannot run the work twice, so every analysis the client may retry carries an `Idempotency-Key`: yours if you pass `idempotency_key=`, otherwise one generated for that call and reused by all of its retries. The API answers a repeated key with the first request's result — one run, one charge, one webhook. When you retry across processes yourself (a job that ran twice), pass the same key each time.
+
+```python
+client = urlpipe.Client(
+    api_key="…",          # default: URLPIPE_API_KEY
+    timeout=90,           # seconds per HTTP request
+    max_retries=2,        # 0 turns retries off
+    wait_timeout=300,     # how long a slow sync call keeps polling
+)
+```
+
+For a proxy, custom TLS or test transports, pass your own `httpx.Client` (or `httpx.AsyncClient`) as `http_client=`. You keep ownership of it; closing the URLpipe client leaves it open.
+
+## Links
+
+- API docs: https://urlpipe.dev/docs
+- Pricing: https://urlpipe.dev/pricing
+- MCP server, for using URLpipe from AI assistants: https://github.com/URLpipe/mcp
+
+## License
+
+MIT © Aliat Partner S.L.

urlpipe-0.1.0/README.md

@@ -0,0 +1,226 @@
+# urlpipe
+
+Turn any URL into clean Markdown, rendered HTML, a full-page screenshot, metadata, a summary, keywords, console errors or a Lighthouse audit — from Python, in one call. Pages are rendered in real Chrome, so JavaScript-heavy sites come back complete.
+
+This is the official Python client for the [URLpipe API](https://urlpipe.dev/docs). It works sync or async, is fully typed, and depends only on `httpx`.
+
+## Install
+
+```sh
+pip install urlpipe
+```
+
+Python 3.9 or later.
+
+## Quickstart
+
+Create a project in the [dashboard](https://urlpipe.dev) and copy its API key. The Free plan gives you 1,000 credits a month, no card needed.
+
+```sh
+export URLPIPE_API_KEY=your_project_key
+```
+
+```python
+import urlpipe
+
+client = urlpipe.Client()  # reads URLPIPE_API_KEY
+
+page = client.markdown("https://example.com")
+print(page.data)  # "# Example Domain\n\nThis domain is for use in …"
+```
+
+Every method waits for the result and returns a `Response`:
+
+| Field | What it holds |
+|---|---|
+| `status` | `"completed"`, `"accepted"` (an async request was taken) or `"processing"` (still running) |
+| `data` | the result, typed per operation; `None` unless completed |
+| `token` | the request's token — fetch the result again for free with `client.result(token)` |
+| `labels` | the labels the request was made with |
+| `meta` | `cache`, `cache_age`, `processing_time_ms`, `quota` (`cost`, `limit`, `remaining`, `overage`, `resets_at`), `concurrency_limit`, `result_url`, `idempotent_replayed` |
+
+```python
+page.meta.cache             # "hit" — served from cache, cost nothing
+page.meta.quota.remaining   # 943, or "unlimited"
+```
+
+## Operations
+
+Every method takes the URL first; everything else is an optional keyword.
+
+```python
+client.markdown("https://example.com").data      # str: the main content as Markdown
+client.html("https://example.com").data          # str: the HTML after JavaScript ran
+client.summarize("https://example.com").data     # str: an AI summary, in Markdown
+client.meta("https://example.com").data          # dict: title, description, language, author, …
+client.keywords("https://example.com").data      # list[str], most relevant first
+client.console("https://example.com").data       # [{"type": "error", "text": "…"}, …]
+client.lighthouse("https://example.com", device="desktop", include_audits=True).data
+```
+
+### Screenshots
+
+```python
+shot = client.screenshot(
+    "https://example.com/pricing",
+    screenshot_options={"viewport_width": 390, "format": "webp"},
+).data
+
+shot.save("pricing.webp")
+shot.mime_type    # "image/webp", read from the image bytes
+shot.result_url   # a link to the image that needs no API key, for an <img> tag
+shot.data         # the decoded bytes
+```
+
+### Several operations off one page visit
+
+```python
+result = client.scrape("https://example.com", ["markdown", "meta", "screenshot"]).data
+result["operations"]["meta"]["result"]["title"]
+```
+
+Each operation has its own `success`, `result`, `error` and `cached`; one failing never affects the others. A screenshot inside a scrape is Base64 text, as the API returns it.
+
+### Options every method takes
+
+```python
+client.markdown(
+    "https://example.com/blog",
+    max_age="1 hour",                     # or seconds; 0 skips the cache
+    labels={"client": "acme"},            # your own ids, returned with the result
+    residential=True,                     # fetch from a home broadband address
+    page_options={"block_cookie_banners": True, "remove_selectors": [".promo"]},
+    idempotency_key="import-2026-09-25-17",
+)
+```
+
+`page_options` is not accepted by `lighthouse`. Options the API adds after this release can be sent with `extra`, which is merged into the request body as given:
+
+```python
+client.markdown("https://example.com", extra={"some_option": True})
+```
+
+The client passes option values through unchanged; the API validates them and answers `InvalidRequestError` naming what to change.
+
+## Async requests and `wait`
+
+Pass `sync=False` and the call returns straight away with a token, while the work carries on. Collect the result by polling, or have it POSTed to a webhook with `report_to`.
+
+```python
+accepted = client.lighthouse("https://example.com", sync=False)
+accepted.status  # "accepted"
+
+report = client.wait(accepted.token, operation="lighthouse")  # polls every 2 s
+report.data["categories"]["performance"]["score"]
+```
+
+`client.result(token)` makes a single check instead: it returns a `"processing"` Response while the work is running.
+
+`GET /result` does not say which operation made a token, so pass `operation=` to get typed `data`. Without it, JSON comes back parsed and text as a string — a screenshot stays Base64 until you ask for `wait(token, operation="screenshot")`.
+
+A synchronous call that runs past the API's 60-second window is not an error: the client polls for the result itself and returns it, for up to `wait_timeout` seconds (5 minutes by default) before raising `WaitTimeoutError`. The work keeps running either way, so `client.wait(error.token)` picks it up later.
+
+### asyncio
+
+`AsyncClient` has the same methods, as coroutines:
+
+```python
+import asyncio
+import urlpipe
+
+async def main() -> None:
+    async with urlpipe.AsyncClient() as client:
+        pages = await asyncio.gather(
+            client.markdown("https://example.com/a"),
+            client.markdown("https://example.com/b"),
+        )
+        print([p.data for p in pages])
+
+asyncio.run(main())
+```
+
+## Webhooks
+
+With webhook signing on (project **Settings → Webhook Signing**), check each delivery came from URLpipe before you trust it. `verify_webhook` needs no client:
+
+```python
+import os
+import urlpipe
+from flask import Flask, request, abort
+
+app = Flask(__name__)
+
+@app.post("/webhooks/urlpipe")
+def urlpipe_webhook():
+    try:
+        delivery = urlpipe.verify_webhook(
+            request.get_data(),          # the raw body bytes
+            request.headers,
+            os.environ["URLPIPE_WEBHOOK_SECRET"],  # whsec_…
+        )
+    except urlpipe.WebhookVerificationError:
+        abort(401)
+    enqueue(delivery["token"], delivery["result"])
+    return "", 200
+```
+
+Give it the **raw request body** exactly as received (`request.get_data()` in Flask, `await request.body()` in FastAPI, `request.body` in Django). Parsed and re-serialised JSON has different bytes, and the signature will not match. Header names are matched case-insensitively; deliveries signed more than `tolerance` seconds ago (300 by default) are refused, and during a secret rotation either signature is accepted.
+
+It returns the payload: `token`, `operation`, `labels`, `success`, `result`, `result_url`, `error` and `meta`.
+
+## Errors
+
+Every error is a `urlpipe.UrlpipeError`, with `status`, `code`, `message`, `body` and `token`.
+
+| Error | When |
+|---|---|
+| `AuthenticationError` | 401: the API key is missing or wrong |
+| `EmailUnverifiedError` | 403: confirm the email address on the account |
+| `InvalidRequestError` | 422: a parameter was refused (`invalid_url`, `invalid_options`, …); nothing ran |
+| `AnalysisFailedError` | 422: the page could not be analysed; `message` says why |
+| `QuotaExceededError` | 429: the Free plan's credits are spent (`limit`, `used`, `needed`, `resets_at`) |
+| `ConcurrencyLimitError` | 429: too many of your requests running (`limit`, `running`) |
+| `RateLimitedError` | 429: sending too fast (`retry_after`) |
+| `NotFoundError` | 404: no result for this token |
+| `StaleResultError` | 410: the result is past the 30-day window |
+| `ServerError` | 5xx |
+| `APIConnectionError` | no HTTP answer at all |
+| `WaitTimeoutError` | the result was not ready within the wait timeout (`token`) |
+
+```python
+try:
+    page = client.markdown(url)
+except urlpipe.AnalysisFailedError as error:
+    print("Could not read the page:", error.message)
+except urlpipe.QuotaExceededError as error:
+    print("Out of credits until", error.resets_at)
+```
+
+A failed analysis costs nothing, and neither does a cache hit.
+
+## Retries and idempotency
+
+The client retries connection errors, rate limits (after `Retry-After`, up to 60 s), concurrency limits and 500/502/503 responses — twice by default, with exponential backoff. It never retries a 4xx other than those, or a spent quota.
+
+A retry is only safe if it cannot run the work twice, so every analysis the client may retry carries an `Idempotency-Key`: yours if you pass `idempotency_key=`, otherwise one generated for that call and reused by all of its retries. The API answers a repeated key with the first request's result — one run, one charge, one webhook. When you retry across processes yourself (a job that ran twice), pass the same key each time.
+
+```python
+client = urlpipe.Client(
+    api_key="…",          # default: URLPIPE_API_KEY
+    timeout=90,           # seconds per HTTP request
+    max_retries=2,        # 0 turns retries off
+    wait_timeout=300,     # how long a slow sync call keeps polling
+)
+```
+
+For a proxy, custom TLS or test transports, pass your own `httpx.Client` (or `httpx.AsyncClient`) as `http_client=`. You keep ownership of it; closing the URLpipe client leaves it open.
+
+## Links
+
+- API docs: https://urlpipe.dev/docs
+- Pricing: https://urlpipe.dev/pricing
+- MCP server, for using URLpipe from AI assistants: https://github.com/URLpipe/mcp
+
+## License
+
+MIT © Aliat Partner S.L.

urlpipe-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "urlpipe"
+dynamic = ["version"]
+description = "Official Python client for the URLpipe API: turn a URL into Markdown, HTML, a screenshot, metadata, a summary, keywords, console errors or a Lighthouse audit."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+authors = [{ name = "URLpipe", email = "contact@urlpipe.dev" }]
+maintainers = [{ name = "URLpipe", email = "contact@urlpipe.dev" }]
+keywords = ["urlpipe", "markdown", "screenshot", "html", "lighthouse", "web scraping", "llm", "api client"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "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",
+  "Framework :: AsyncIO",
+]
+dependencies = ["httpx>=0.23,<1"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "mypy>=1.5"]
+
+[project.urls]
+Homepage = "https://urlpipe.dev"
+Documentation = "https://urlpipe.dev/docs"
+Source = "https://github.com/URLpipe/urlpipe-python"
+Changelog = "https://github.com/URLpipe/urlpipe-python/blob/main/CHANGELOG.md"
+
+[tool.hatch.version]
+path = "src/urlpipe/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/urlpipe"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/urlpipe", "tests", "README.md", "CHANGELOG.md", "LICENSE", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.mypy]
+strict = true
+files = ["src/urlpipe"]

urlpipe-0.1.0/src/urlpipe/__init__.py

@@ -0,0 +1,78 @@
+"""The official Python client for the URLpipe API: turn a URL into Markdown,
+HTML, a screenshot, metadata, a summary, keywords, console errors or a
+Lighthouse audit.
+
+    import urlpipe
+
+    client = urlpipe.Client()  # reads URLPIPE_API_KEY
+    print(client.markdown("https://example.com").data)
+
+Docs: https://urlpipe.dev/docs
+"""
+
+from . import errors
+from ._client import AsyncClient, Client
+from ._models import (
+    ConsoleEntry,
+    Operation,
+    PageMeta,
+    Quota,
+    Response,
+    ResponseMeta,
+    ResponseStatus,
+    ScrapeOperationResult,
+    ScrapeResult,
+    Screenshot,
+)
+from ._version import __version__
+from .errors import (
+    AnalysisFailedError,
+    APIConnectionError,
+    AuthenticationError,
+    ConcurrencyLimitError,
+    ConfigurationError,
+    EmailUnverifiedError,
+    InvalidRequestError,
+    NotFoundError,
+    QuotaExceededError,
+    RateLimitedError,
+    ServerError,
+    StaleResultError,
+    UrlpipeError,
+    WaitTimeoutError,
+    WebhookVerificationError,
+)
+from .webhooks import verify_webhook
+
+__all__ = [
+    "APIConnectionError",
+    "AnalysisFailedError",
+    "AsyncClient",
+    "AuthenticationError",
+    "Client",
+    "ConcurrencyLimitError",
+    "ConfigurationError",
+    "ConsoleEntry",
+    "EmailUnverifiedError",
+    "InvalidRequestError",
+    "NotFoundError",
+    "Operation",
+    "PageMeta",
+    "Quota",
+    "QuotaExceededError",
+    "RateLimitedError",
+    "Response",
+    "ResponseMeta",
+    "ResponseStatus",
+    "ScrapeOperationResult",
+    "ScrapeResult",
+    "Screenshot",
+    "ServerError",
+    "StaleResultError",
+    "UrlpipeError",
+    "WaitTimeoutError",
+    "WebhookVerificationError",
+    "__version__",
+    "errors",
+    "verify_webhook",
+]