pdfcraft-dev 1.4.0__py3-none-any.whl

pdfcraft/__init__.py

@@ -0,0 +1,33 @@
+"""PDFCraft — HTML to PDF, and PDF to structured JSON, in one call.
+
+    from pdfcraft import PDFCraft
+
+    client = PDFCraft("sk_live_...")
+    pdf = client.render(html="<h1>hello</h1>")
+    data = client.extract_pdf(pdf)
+
+Zero dependencies. Every failure raises `PDFCraftError`; branch on `.code`.
+"""
+
+from ._client import DEFAULT_BASE_URL, PDFCraft
+from ._contract import (
+    A11Y_SEVERITIES,
+    ERROR_CODES,
+    FINDING_LAYERS,
+    PAGE_FORMATS,
+    SCAN_STATUSES,
+)
+from ._errors import PDFCraftError
+from ._version import __version__
+
+__all__ = [
+    "PDFCraft",
+    "PDFCraftError",
+    "ERROR_CODES",
+    "PAGE_FORMATS",
+    "A11Y_SEVERITIES",
+    "SCAN_STATUSES",
+    "FINDING_LAYERS",
+    "DEFAULT_BASE_URL",
+    "__version__",
+]

pdfcraft/_client.py

@@ -0,0 +1,266 @@
+"""The PDFCraft client.
+
+Mirrors the TypeScript SDK's surface method for method, so the docs can show
+the same call in both languages and mean it. Where the two differ it is
+because Python idiom demands it: snake_case, keyword arguments, and bytes
+rather than ``Uint8Array``.
+
+Zero dependencies, on purpose. The whole client is ``urllib.request`` plus
+about forty lines of retry logic, and an SDK that drags ``requests`` and its
+transitive tree into a customer's lockfile to save those forty lines is a bad
+trade — especially for anyone installing into a Lambda or a slim container.
+The TypeScript SDK makes the same choice with ``fetch``.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import random
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Mapping, Sequence
+
+from ._errors import PDFCraftError, to_error
+from ._version import __version__
+
+DEFAULT_BASE_URL = "https://api.pdfcraft.dev"
+DEFAULT_MAX_RETRIES = 3
+# Just past the API's own 120s ceiling, so a server-side timeout surfaces as
+# the API's `render_timeout` — which tells you what happened — rather than as a
+# client-side socket timeout, which tells you nothing.
+DEFAULT_TIMEOUT = 130.0
+
+JsonDict = dict[str, Any]
+
+
+class PDFCraft:
+    """A PDFCraft API client.
+
+    >>> pdf = PDFCraft("sk_live_...").render(html="<h1>hello</h1>")
+    >>> pdf[:4]
+    b'%PDF'
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT,
+        opener: urllib.request.OpenerDirector | None = None,
+    ) -> None:
+        if not api_key:
+            raise PDFCraftError("invalid_api_key", "An API key is required.", 401)
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._timeout = timeout
+        # Injectable so the tests can run without a network, and so anyone
+        # behind a corporate proxy can hand in their own opener.
+        self._opener = opener or urllib.request.build_opener()
+
+    # ── rendering ─────────────────────────────────────────────────────────
+
+    def render(self, *, idempotency_key: str | None = None, **input: Any) -> bytes:
+        """Render HTML or a URL and return the PDF bytes.
+
+        The method decides the output mode, so passing ``output`` yourself
+        could only contradict it — it is rejected rather than ignored, because
+        ``render(output="url")`` quietly returning JSON is the kind of surprise
+        that costs an afternoon.
+        """
+        body = _with_output(input, "binary")
+        return self._request("POST", "/v1/render", body, idempotency_key).read()
+
+    def render_to_url(self, *, idempotency_key: str | None = None, **input: Any) -> JsonDict:
+        """Store the PDF and return a signed link instead of the bytes."""
+        body = _with_output(input, "url")
+        return _json(self._request("POST", "/v1/render", body, idempotency_key))
+
+    def render_async(self, *, idempotency_key: str | None = None, **input: Any) -> JsonDict:
+        """Queue a render; the webhook fires when it settles."""
+        return _json(self._request("POST", "/v1/render/async", dict(input), idempotency_key))
+
+    def get_render(self, render_id: str) -> JsonDict:
+        return _json(self._request("GET", f"/v1/renders/{_quote(render_id)}"))
+
+    def usage(self) -> JsonDict:
+        """Current period usage and quota."""
+        return _json(self._request("GET", "/v1/usage"))
+
+    # ── extraction ────────────────────────────────────────────────────────
+
+    def extract(self, *, idempotency_key: str | None = None, **input: Any) -> JsonDict:
+        """A PDF in, its tables and labelled fields out, each with a bounding box.
+
+        ``file`` takes base64 PDF bytes or an https URL to one; pass ``url`` or
+        ``html`` instead and the page is rendered first, then extracted — one
+        call, one charge. Billed per page read, so ``options={"pages": ...}``
+        narrows the bill as well as the work.
+
+        There is no OCR. A scan has no text layer and comes back as
+        ``extraction_failed``, unbilled. Nothing is guessed by a model, so the
+        same document always produces the same answer.
+        """
+        body = _with_output(input, "inline")
+        return _json(self._request("POST", "/v1/extract", body, idempotency_key))
+
+    def extract_to_url(self, *, idempotency_key: str | None = None, **input: Any) -> JsonDict:
+        body = _with_output(input, "url")
+        return _json(self._request("POST", "/v1/extract", body, idempotency_key))
+
+    def extract_async(self, *, idempotency_key: str | None = None, **input: Any) -> JsonDict:
+        return _json(self._request("POST", "/v1/extract/async", dict(input), idempotency_key))
+
+    def get_extraction(self, extraction_id: str) -> JsonDict:
+        """Poll one extraction.
+
+        An extraction id is not a render id: ``get_render`` will 404 on one and
+        this will 404 on a render id, deliberately.
+        """
+        return _json(self._request("GET", f"/v1/extractions/{_quote(extraction_id)}"))
+
+    def extract_pdf(
+        self,
+        pdf: bytes,
+        *,
+        idempotency_key: str | None = None,
+        **input: Any,
+    ) -> JsonDict:
+        """Convenience for the common case: hand it PDF bytes, it does the base64.
+
+        Kept out of ``extract`` itself so that call stays a plain dict you can
+        log, diff or replay.
+        """
+        return self.extract(
+            file=base64.b64encode(pdf).decode("ascii"),
+            idempotency_key=idempotency_key,
+            **input,
+        )
+
+    # ── accessibility ─────────────────────────────────────────────────────
+
+    def scan(
+        self,
+        *,
+        domain: str | None = None,
+        sitemap: str | None = None,
+        urls: Sequence[str] | None = None,
+        **options: Any,
+    ) -> JsonDict:
+        """Start an accessibility scan. Returns at once with an id to poll.
+
+        Exactly one source. A scan of a thousand documents at one request per
+        second per host has a floor measured in minutes, so there is nothing to
+        return but an id and somewhere to look.
+
+            scan = client.scan(domain="example.gov", max_documents=500)
+            while scan["status"] not in ("succeeded", "failed"):
+                time.sleep(10)
+                scan = client.get_scan(scan["id"])
+
+        ``max_documents`` is clamped to your plan rather than refused, and the
+        gap between what was found and what was checked is reported back as
+        ``discovered`` minus ``checked``.
+        """
+        source = {
+            key: value
+            for key, value in (("domain", domain), ("sitemap", sitemap), ("urls", list(urls) if urls else None))
+            if value is not None
+        }
+        if len(source) != 1:
+            raise PDFCraftError(
+                "invalid_request",
+                "exactly one of domain, sitemap or urls is required",
+                400,
+            )
+        body: JsonDict = {"source": source}
+        if options:
+            body["options"] = dict(options)
+        return _json(self._request("POST", "/v1/a11y/scan", body))
+
+    def get_scan(self, scan_id: str) -> JsonDict:
+        """Poll one scan.
+
+        Returns progress while it runs and the full result — every document,
+        ranked, with findings and cost — once it succeeds. ``report_url`` is a
+        share token: anyone with it can read the report, no account needed.
+        """
+        return _json(self._request("GET", f"/v1/a11y/scans/{_quote(scan_id)}"))
+
+    # ── transport ─────────────────────────────────────────────────────────
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Mapping[str, Any] | None = None,
+        idempotency_key: str | None = None,
+    ) -> Any:
+        payload = json.dumps(body).encode("utf-8") if body is not None else None
+        headers = {
+            "authorization": f"Bearer {self._api_key}",
+            "user-agent": f"pdfcraft-sdk-python/{__version__}",
+        }
+        if payload is not None:
+            headers["content-type"] = "application/json"
+        if idempotency_key:
+            headers["idempotency-key"] = idempotency_key
+
+        last: PDFCraftError | None = None
+        for attempt in range(self._max_retries + 1):
+            request = urllib.request.Request(
+                f"{self._base_url}{path}", data=payload, headers=headers, method=method
+            )
+            try:
+                return self._opener.open(request, timeout=self._timeout)
+            except urllib.error.HTTPError as response:
+                last = to_error(response.code, response.read())
+                if not last.retryable or attempt == self._max_retries:
+                    raise last from None
+                time.sleep(_retry_after(response) or _backoff(attempt))
+            except (urllib.error.URLError, TimeoutError, OSError) as cause:
+                last = PDFCraftError("network_error", f"Could not reach PDFCraft: {cause}", 0)
+                if attempt == self._max_retries:
+                    raise last from None
+                time.sleep(_backoff(attempt))
+
+        raise last or PDFCraftError("internal_error", "Request failed.", 500)
+
+
+def _with_output(input: Mapping[str, Any], mode: str) -> JsonDict:
+    if "output" in input:
+        raise PDFCraftError(
+            "invalid_request",
+            "Do not pass `output`; the method you call decides it.",
+            400,
+        )
+    return {**input, "output": mode}
+
+
+def _json(response: Any) -> JsonDict:
+    return json.loads(response.read().decode("utf-8"))
+
+
+def _quote(value: str) -> str:
+    from urllib.parse import quote
+
+    return quote(value, safe="")
+
+
+def _backoff(attempt: int) -> float:
+    """Exponential with jitter, matching the TypeScript SDK's curve exactly."""
+    return 0.5 * (2**attempt) * (0.75 + random.random() * 0.5)
+
+
+def _retry_after(response: Any) -> float | None:
+    header = response.headers.get("retry-after") if hasattr(response, "headers") else None
+    if not header:
+        return None
+    try:
+        return max(0.0, float(header))
+    except (TypeError, ValueError):
+        return None

pdfcraft/_contract.py

@@ -0,0 +1,72 @@
+# GENERATED FILE — do not edit.
+# Written by packages/contract/scripts/sync-polyglot.mjs from the same
+# definitions the PDFCraft API validates requests against.
+# Editing it by hand will be silently overwritten on the next sync.
+
+CONTRACT_HASH = "f5af303a2509e0d11d0c6efdc069e9acb80fddcd43a337a4789fa8f538f2588a"
+
+#: Stable machine-readable codes. Branch on these, never on the message.
+ERROR_CODES: tuple[str, ...] = (
+    "invalid_request",
+    "invalid_api_key",
+    "payment_required",
+    "not_found",
+    "render_timeout",
+    "render_failed",
+    "rate_limited",
+    "quota_exceeded",
+    "demo_busy",
+    "unsupported_file",
+    "extraction_failed",
+    "internal_error",
+)
+
+PAGE_FORMATS: tuple[str, ...] = (
+    "A4",
+    "A3",
+    "A5",
+    "Letter",
+    "Legal",
+    "Tabloid",
+)
+
+EMULATE_MEDIA: tuple[str, ...] = (
+    "print",
+    "screen",
+)
+
+OUTPUT_MODES: tuple[str, ...] = (
+    "binary",
+    "url",
+)
+
+EXTRACT_OUTPUT_MODES: tuple[str, ...] = (
+    "inline",
+    "url",
+)
+
+MAX_TIMEOUT_MS = 120000
+DEFAULT_TIMEOUT_MS = 30000
+
+#: Accessibility severity, worst first. Ordered, not merely enumerated.
+A11Y_SEVERITIES: tuple[str, ...] = (
+    "blocker",
+    "major",
+    "minor",
+    "pass",
+)
+
+#: Scan lifecycle. Poll until the status is terminal.
+SCAN_STATUSES: tuple[str, ...] = (
+    "queued",
+    "crawling",
+    "checking",
+    "succeeded",
+    "failed",
+)
+
+#: Which layer found a finding. "geometric" is the half a conformance validator cannot do.
+FINDING_LAYERS: tuple[str, ...] = (
+    "machine",
+    "geometric",
+)

pdfcraft/_errors.py

@@ -0,0 +1,66 @@
+"""Every failure from the API arrives as one exception type. Branch on ``.code``.
+
+Mirrors ``src/errors.ts`` in the TypeScript SDK deliberately, down to which
+statuses count as retryable, so a bug report against one client can be read by
+someone holding the other.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+class PDFCraftError(Exception):
+    """A PDFCraft API failure.
+
+    ``code`` is the stable machine-readable string from the API's error
+    envelope — ``quota_exceeded``, ``render_timeout`` and so on — or
+    ``network_error`` when the request never reached us. Branch on it rather
+    than on the message, which is written for humans and may be reworded.
+    """
+
+    __slots__ = ("code", "status", "docs_url", "retryable")
+
+    def __init__(
+        self,
+        code: str,
+        message: str,
+        status: int,
+        docs_url: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.status = status
+        self.docs_url = docs_url
+        # A 4xx other than 429 will fail identically however many times we ask.
+        self.retryable = code == "network_error" or status == 429 or status >= 500
+
+    def __repr__(self) -> str:  # pragma: no cover - debugging aid
+        return f"PDFCraftError(code={self.code!r}, status={self.status})"
+
+
+def to_error(status: int, body: bytes) -> PDFCraftError:
+    """Turn an error response into a typed exception.
+
+    Tolerates a non-JSON body on purpose: a proxy or load balancer in front of
+    the API returns an HTML error page, and a client that raises
+    ``JSONDecodeError`` there hides the status code that would have explained
+    the problem.
+    """
+    payload: Any = None
+    try:
+        payload = json.loads(body.decode("utf-8", "replace"))
+    except (ValueError, AttributeError):
+        payload = None
+
+    error = payload.get("error") if isinstance(payload, dict) else None
+    if not isinstance(error, dict):
+        error = {}
+
+    return PDFCraftError(
+        str(error.get("code") or "internal_error"),
+        str(error.get("message") or f"PDFCraft responded {status}"),
+        status,
+        error.get("docs_url") or None,
+    )

pdfcraft/_version.py

@@ -0,0 +1,6 @@
+# src/pdfcraft/_version.py
+#
+# One place, read by the package metadata AND by the User-Agent header. Not
+# read back out of the installed distribution: that fails when the package is
+# run from a source checkout, which is exactly when someone is debugging.
+__version__ = "1.4.0"

pdfcraft_dev-1.4.0.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: pdfcraft-dev
+Version: 1.4.0
+Summary: HTML to PDF, and PDF to structured JSON, in one call. The official PDFCraft SDK.
+Project-URL: Homepage, https://pdfcraft.dev
+Project-URL: Documentation, https://pdfcraft.dev/sdk/python/
+Project-URL: Source, https://github.com/igaurav-dev/pdfcraft-python
+Project-URL: Issues, https://github.com/igaurav-dev/pdfcraft-python/issues
+Author: PDFCraft
+License: MIT License
+        
+        Copyright (c) 2026 Gaurav Singh
+        
+        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.
+License-File: LICENSE
+Keywords: chromium,extract-tables-from-pdf,headless-chrome,html-to-pdf,html-to-pdf-api,invoice,pdf,pdf-accessibility,pdf-api,pdf-extraction,pdf-generation,pdf-table-extraction,pdf-to-json,url-to-pdf
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Printing
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# PDFCraft for Python
+
+HTML to PDF, PDF to structured JSON, and accessibility triage for a whole document estate.
+The official Python client for [PDFCraft](https://pdfcraft.dev).
+
+**Zero dependencies.** The whole client is `urllib.request` plus a retry loop, so it installs
+into a Lambda or a slim container without dragging a transitive tree behind it.
+
+```bash
+pip install pdfcraft-dev
+```
+
+Installs as `pdfcraft-dev`, imports as `pdfcraft` — the same split as
+`python-dateutil`/`dateutil`. The plain name was taken on PyPI by an unrelated
+project, and the npm package is `@pdfcraft-dev/pdf`, so the two registries at
+least agree with each other.
+
+## Render
+
+```python
+from pdfcraft import PDFCraft
+
+client = PDFCraft("sk_live_...")
+
+pdf = client.render(html="<h1>Invoice 1042</h1>")
+open("invoice.pdf", "wb").write(pdf)
+```
+
+A URL instead of HTML, with page options:
+
+```python
+pdf = client.render(
+    url="https://example.com/report",
+    options={
+        "format": "A4",
+        "margin": {"top": "20mm", "bottom": "20mm"},
+        "printBackground": True,
+        "waitFor": {"selector": "#chart-ready", "networkIdle": True},
+    },
+    filename="report.pdf",
+)
+```
+
+Need a link rather than bytes — for an email, or a file too big to hold in memory:
+
+```python
+result = client.render_to_url(html=invoice_html)
+print(result["url"], result["expires_at"], result["pages"])
+```
+
+## Extract
+
+A PDF in, its tables and labelled fields out, each with a bounding box:
+
+```python
+data = client.extract_pdf(open("statement.pdf", "rb").read())
+
+for table in data["tables"]:
+    print(table["header"], len(table["rows"]), table["confidence"])
+```
+
+Ask for specific fields by name and type:
+
+```python
+data = client.extract(
+    file=base64_pdf,
+    schema={"invoice_total": "currency", "due_date": "date", "po_number": "string"},
+)
+print(data["fields"]["invoice_total"]["value"])
+```
+
+There is **no OCR**. A scanned document has no text layer, comes back as `extraction_failed`,
+and is not billed. Nothing is guessed by a model, so the same document always produces the
+same answer — which is the point if you are reconciling numbers.
+
+Extraction is billed per page read, so `options={"pages": "1-3"}` narrows the bill as well as
+the work.
+
+## Async
+
+For documents slow enough that you would rather not hold the connection:
+
+```python
+job = client.render_async(url="https://example.com/huge", webhookUrl="https://you/hook")
+status = client.get_render(job["id"])
+```
+
+`get_extraction` polls extractions. An extraction id is not a render id — each endpoint 404s
+on the other's ids, deliberately.
+
+## Accessibility
+
+Point it at a domain and it finds every PDF, checks each against PDF/UA and WCAG 2.1 AA, and
+returns a report ranked by severity weighted by reach, with a remediation cost range.
+
+```python
+import time
+
+scan = client.scan(domain="example.gov", max_documents=500)
+while scan["status"] not in ("succeeded", "failed"):
+    time.sleep(10)
+    scan = client.get_scan(scan["id"])
+
+for doc in scan["documents"][:10]:          # already ranked — this is the fix list
+    print(doc["severity"], doc["score"], doc["url"])
+    print(f"  ${doc['cost_low_usd']:.0f}-${doc['cost_high_usd']:.0f} to remediate")
+```
+
+Exactly one source: `domain=`, `sitemap=` or `urls=`. Passing none or two raises
+`PDFCraftError` before anything is sent, because a round trip to be told you contradicted
+yourself is a round trip wasted.
+
+A scan runs for minutes — one request per second per host is a rule we do not break — so it
+returns an id immediately and you poll. `max_documents` is **clamped to your plan rather than
+refused**; `discovered` minus `checked` is what was found and not looked at, which is also the
+upgrade prompt.
+
+`report_url` on a finished scan is a share token. Anyone holding it can read the full HTML
+report, and `GET /r/<token>/pdf` renders the same report to PDF through the render API. Treat
+it as a credential, not an identifier.
+
+Each finding carries `severity` (`blocker`, `major`, `minor`), the `wcag` criteria it breaks, a
+`message` written for whoever approves the budget, and `technical_detail` for whoever does the
+work. `occurrences` is volume, not severity — one check failing 1,535 times is one thing wrong,
+fixed once, so never rank on it.
+
+```python
+from pdfcraft import A11Y_SEVERITIES, FINDING_LAYERS, SCAN_STATUSES
+```
+
+Those are generated from the same contract the API validates against, so comparing against them
+beats comparing against a string you typed.
+
+Accessibility is a **separate subscription** from rendering. An account can hold either, both or
+neither, and the free tier is a real scan of 25 documents with full findings.
+
+## Errors
+
+Every failure raises `PDFCraftError`. Branch on `.code`, which is stable; the message is
+written for a human and may be reworded.
+
+```python
+from pdfcraft import PDFCraft, PDFCraftError
+
+try:
+    pdf = client.render(html=page)
+except PDFCraftError as error:
+    if error.code == "quota_exceeded":
+        ...          # out of renders this period
+    elif error.code == "render_failed":
+        ...          # their HTML broke — billable, and worth logging
+    elif error.retryable:
+        ...          # already retried; this is after the last attempt
+    else:
+        raise
+```
+
+`error.docs_url` points at the page explaining that specific code.
+
+### What is and is not billed
+
+A render is billable if Chromium actually ran. Successes and `render_failed` count;
+`render_timeout`, `internal_error` and every 4xx that never reached the browser do not.
+
+## Retries
+
+Retries happen automatically on `429` and `5xx` and on network failures — never on a `4xx`
+other than `429`, because those fail identically however often you ask. `Retry-After` is
+honoured when the API sends it, otherwise the backoff is exponential with jitter.
+
+```python
+client = PDFCraft("sk_live_...", max_retries=0)      # off
+client = PDFCraft("sk_live_...", timeout=200.0)      # seconds
+client = PDFCraft("sk_live_...", base_url="https://gateway.internal")
+```
+
+## Typing
+
+Ships `py.typed`. Responses are plain dicts rather than dataclasses: the API's response shape
+grows, and a dict that gains a key is a non-event where a frozen dataclass is a crash. The
+option and error enumerations you might want to validate against are exported:
+
+```python
+from pdfcraft import ERROR_CODES, PAGE_FORMATS
+```
+
+Those are generated from the same definitions the API validates requests against, so they
+cannot drift from the server.
+
+## Links
+
+- Docs — https://pdfcraft.dev/docs/
+- Every error code, cause and fix — https://pdfcraft.dev/errors/
+- Extraction guides on 27 real document shapes — https://pdfcraft.dev/guides/
+- TypeScript SDK — `@pdfcraft-dev/pdf`
+- Go SDK — `github.com/igaurav-dev/pdfcraft-go`
+
+MIT licensed.

pdfcraft_dev-1.4.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pdfcraft/__init__.py,sha256=TL628Pcxuggf2SVOirPN9uZue2KuB_U16aRhnMTGB0Q,746
+pdfcraft/_client.py,sha256=9s0PFQ56rU3fESwv6bIkauTB_xLCpKj2odhBKAmJCcE,10767
+pdfcraft/_contract.py,sha256=H8RNxvJqYKI2CWMMn7zibTpFzlVNGKb6p0NHX0yeX4g,1539
+pdfcraft/_errors.py,sha256=6eDr5jDcF6tLR6i9SDU5k9qRKmhlVqLF1aeCxfoIn-8,2202
+pdfcraft/_version.py,sha256=mQUmfuD6SzNbDotSl4VdGUGeiArADo4hejfW5nDZ_eE,279
+pdfcraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pdfcraft_dev-1.4.0.dist-info/METADATA,sha256=mscBMul08Gg_M_WAE3juFgFUjj4NEQ0Mqt_rdJC0rCQ,9093
+pdfcraft_dev-1.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pdfcraft_dev-1.4.0.dist-info/licenses/LICENSE,sha256=VvFCyi2di0rvS6eYiaa6nEK_aybkXjxeQ8iJVuafvjk,1069
+pdfcraft_dev-1.4.0.dist-info/RECORD,,

pdfcraft_dev-1.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pdfcraft_dev-1.4.0.dist-info/licenses/LICENSE

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