paperlypdf 0.1.0__tar.gz

paperlypdf-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: paperlypdf
+Version: 0.1.0
+Summary: Python client for Paperly — turn prompts or CSV/Excel files into polished, downloadable PDF reports.
+License: MIT
+Project-URL: Homepage, https://saas-pdf-kappa.vercel.app
+Keywords: pdf,report,ai,generator,document,paperly
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25
+
+# Paperly Python SDK
+
+Turn a prompt — or a CSV/Excel file — into a polished, downloadable **PDF report**
+in a few lines of Python. The AI builds a designed, multi-page document
+(table of contents, tables, summary section) and renders it to PDF — no manual
+formatting.
+
+```bash
+pip install paperlypdf
+```
+
+## Quickstart
+
+```python
+from paperlypdf import PaperlyPdf
+
+client = PaperlyPdf(api_key="pdf_YOUR_API_KEY")
+
+pdf = client.generate_to_pdf(
+    "Write a quarterly sales analysis for Q2 2026.",
+    length="standard",          # concise | standard | in-depth
+    output_path="report.pdf",
+)
+```
+
+That's it — submit, poll, download. `report.pdf` lands on disk.
+
+## Data file → PDF report (the killer use case)
+
+```python
+import csv
+import io
+from paperlypdf import PaperlyPdf
+
+client = PaperlyPdf(api_key="pdf_YOUR_API_KEY")
+
+def csv_as_text(path):
+    with open(path, encoding="utf-8-sig") as f:
+        rows = list(csv.DictReader(f))
+    out = io.StringIO()
+    out.write(f"Source: {path} ({len(rows)} rows)\n\n")
+    for row in rows:
+        out.write(" | ".join(f"{k}: {v}" for k, v in row.items()))
+        out.write("\n")
+    return out.getvalue()
+
+client.generate_to_pdf(
+    "Organize this data into a clean business report with tables, "
+    "then add an analysis section with concrete recommendations.",
+    file_text=csv_as_text("sales.csv"),
+    length="standard",
+    output_path="sales_report.pdf",
+)
+```
+
+For Excel (`.xlsx`) use pandas to read and pass a text representation the same way:
+
+```python
+import pandas as pd
+client.generate_to_pdf("Summarize this into a clean report.", file_text=pd.read_excel("orders.xlsx").to_string())
+```
+
+## Low-level API
+
+| Method | Purpose |
+|---|---|
+| `generate(prompt, length, mode, file_text, clarify, answers)` | Submit a job — returns `jobId` |
+| `get_job(job_id)` | Poll status: `pending` / `running` / `done` / `failed` |
+| `wait(job_id)` | Block until `done` (raises on `failed` or timeout) |
+| `download(job_id, output_path)` | Fetch the finished PDF (bytes) |
+| `generate_to_pdf(...)` | All of the above in one call |
+| `me()` | API-key info: balance, usage, caps |
+
+### Handling clarifying questions
+
+Pass `clarify=True` and the API may ask questions first:
+
+```python
+res = client.generate("I need a document about ice cream.", clarify=True)
+if res.get("needsInput"):
+    print(res["questions"])   # -> ask the user, then retry with answers:
+    res = client.generate("I need a document about ice cream.",
+                          clarify=True,
+                          answers=["Tutorial", "Beginner home cooks", "3 sections"])
+job = client.wait(res["jobId"])
+client.download(job["jobId"], "out.pdf")
+```
+
+## Errors
+
+Non-2xx responses raise `PaperlyError` with the server's error message. Failed
+jobs raise `PaperlyError` too. Jobs expire after 30 minutes.
+
+## Pricing
+
+Prepaid, pay-as-you-go: `concise` $0.30 · `standard` $0.30 · `in-depth` $1.00,
+plus $0.10 per 100K characters of file data. No subscription.

paperlypdf-0.1.0/README.md

@@ -0,0 +1,97 @@
+# Paperly Python SDK
+
+Turn a prompt — or a CSV/Excel file — into a polished, downloadable **PDF report**
+in a few lines of Python. The AI builds a designed, multi-page document
+(table of contents, tables, summary section) and renders it to PDF — no manual
+formatting.
+
+```bash
+pip install paperlypdf
+```
+
+## Quickstart
+
+```python
+from paperlypdf import PaperlyPdf
+
+client = PaperlyPdf(api_key="pdf_YOUR_API_KEY")
+
+pdf = client.generate_to_pdf(
+    "Write a quarterly sales analysis for Q2 2026.",
+    length="standard",          # concise | standard | in-depth
+    output_path="report.pdf",
+)
+```
+
+That's it — submit, poll, download. `report.pdf` lands on disk.
+
+## Data file → PDF report (the killer use case)
+
+```python
+import csv
+import io
+from paperlypdf import PaperlyPdf
+
+client = PaperlyPdf(api_key="pdf_YOUR_API_KEY")
+
+def csv_as_text(path):
+    with open(path, encoding="utf-8-sig") as f:
+        rows = list(csv.DictReader(f))
+    out = io.StringIO()
+    out.write(f"Source: {path} ({len(rows)} rows)\n\n")
+    for row in rows:
+        out.write(" | ".join(f"{k}: {v}" for k, v in row.items()))
+        out.write("\n")
+    return out.getvalue()
+
+client.generate_to_pdf(
+    "Organize this data into a clean business report with tables, "
+    "then add an analysis section with concrete recommendations.",
+    file_text=csv_as_text("sales.csv"),
+    length="standard",
+    output_path="sales_report.pdf",
+)
+```
+
+For Excel (`.xlsx`) use pandas to read and pass a text representation the same way:
+
+```python
+import pandas as pd
+client.generate_to_pdf("Summarize this into a clean report.", file_text=pd.read_excel("orders.xlsx").to_string())
+```
+
+## Low-level API
+
+| Method | Purpose |
+|---|---|
+| `generate(prompt, length, mode, file_text, clarify, answers)` | Submit a job — returns `jobId` |
+| `get_job(job_id)` | Poll status: `pending` / `running` / `done` / `failed` |
+| `wait(job_id)` | Block until `done` (raises on `failed` or timeout) |
+| `download(job_id, output_path)` | Fetch the finished PDF (bytes) |
+| `generate_to_pdf(...)` | All of the above in one call |
+| `me()` | API-key info: balance, usage, caps |
+
+### Handling clarifying questions
+
+Pass `clarify=True` and the API may ask questions first:
+
+```python
+res = client.generate("I need a document about ice cream.", clarify=True)
+if res.get("needsInput"):
+    print(res["questions"])   # -> ask the user, then retry with answers:
+    res = client.generate("I need a document about ice cream.",
+                          clarify=True,
+                          answers=["Tutorial", "Beginner home cooks", "3 sections"])
+job = client.wait(res["jobId"])
+client.download(job["jobId"], "out.pdf")
+```
+
+## Errors
+
+Non-2xx responses raise `PaperlyError` with the server's error message. Failed
+jobs raise `PaperlyError` too. Jobs expire after 30 minutes.
+
+## Pricing
+
+Prepaid, pay-as-you-go: `concise` $0.30 · `standard` $0.30 · `in-depth` $1.00,
+plus $0.10 per 100K characters of file data. No subscription.

paperlypdf-0.1.0/paperlypdf/__init__.py

@@ -0,0 +1,6 @@
+"""Paperly PDF SDK — turn prompts or data files into polished PDF documents."""
+
+from .client import PaperlyPdf, PaperlyError
+
+__version__ = "0.1.0"
+__all__ = ["PaperlyPdf", "PaperlyError"]

paperlypdf-0.1.0/paperlypdf/client.py

@@ -0,0 +1,157 @@
+"""Minimal Python client for the Paperly PDF API.
+
+Turn a prompt — or a CSV/Excel file — into a polished, downloadable PDF report.
+
+    from paperlypdf import PaperlyPdf
+
+    client = PaperlyPdf(api_key="pdf_...")
+    client.generate_to_pdf(
+        "Write a quarterly sales analysis for Q2 2026.",
+        length="standard",
+        output_path="report.pdf",
+    )
+
+The API is a simple submit → poll → download flow, so nothing fancy is needed
+here: this module just wraps the four endpoints with retries-free polling and
+clean error messages.
+"""
+from __future__ import annotations
+
+import time
+from typing import List, Optional, Union
+
+import requests
+
+__all__ = ["PaperlyPdf", "PaperlyError"]
+
+
+class PaperlyError(Exception):
+    """Raised when the Paperly PDF API returns an error or a job fails."""
+
+
+class PaperlyPdf:
+    """Async job-based client. Submitting returns a jobId immediately; you
+    poll with ``wait``/``get_job`` and fetch the finished PDF with ``download``."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://saas-pdf-kappa.vercel.app",
+        timeout: int = 60,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers["Authorization"] = f"Bearer {api_key}"
+        self._session.headers["Accept"] = "application/json"
+
+    # ── low-level ────────────────────────────────────────────────────────────
+    def _request(self, method: str, path: str, **kwargs) -> requests.Response:
+        url = f"{self.base_url}{path}"
+        resp = self._session.request(method, url, timeout=self.timeout, **kwargs)
+        if resp.status_code >= 400:
+            try:
+                msg = resp.json().get("error", resp.text)
+            except Exception:  # noqa: BLE001 — non-JSON error body
+                msg = resp.text
+            raise PaperlyError(f"HTTP {resp.status_code}: {msg}")
+        return resp
+
+    # ── endpoints ────────────────────────────────────────────────────────────
+    def me(self) -> dict:
+        """Account / API-key info: balance, usage, caps."""
+        return self._request("GET", "/api/v1/me").json()
+
+    def generate(
+        self,
+        prompt: str,
+        length: str = "standard",
+        mode: str = "business",
+        file_text: Optional[str] = None,
+        clarify: bool = False,
+        answers: Optional[List[str]] = None,
+    ) -> dict:
+        """Submit a generation job.
+
+        Returns ``{"jobId": ...}`` when the job starts. If ``clarify=True`` and
+        the prompt is judged vague, returns ``{"needsInput": True, "questions": [...]}``
+        instead — pass the answered values back via ``answers`` on a retry.
+        """
+        body: dict = {"prompt": prompt, "length": length, "mode": mode, "clarify": bool(clarify)}
+        if file_text:
+            body["fileText"] = file_text
+        if answers:
+            body["answers"] = list(answers)
+        return self._request("POST", "/api/v1/generate", json=body).json()
+
+    def get_job(self, job_id: str) -> dict:
+        """Current job state: status (pending/running/done/failed) + step."""
+        return self._request("GET", f"/api/v1/jobs/{job_id}").json()
+
+    def wait(self, job_id: str, poll_interval: float = 3, timeout: float = 900) -> dict:
+        """Poll until the job reaches a terminal state.
+
+        Jobs expire after 30 minutes; ``timeout`` defaults to 15 min and can be
+        raised for very long in-depth generations.
+        """
+        deadline = time.time() + timeout
+        while True:
+            job = self.get_job(job_id)
+            status = job.get("status")
+            if status == "done":
+                return job
+            if status == "failed":
+                raise PaperlyError(job.get("error") or f"Job {job_id} failed.")
+            if time.time() >= deadline:
+                raise PaperlyError(f"Timed out after {timeout}s waiting for job {job_id}.")
+            time.sleep(poll_interval)
+
+    def download(self, job_id: str, output_path: Optional[str] = None) -> bytes:
+        """Fetch the finished PDF. Returns raw bytes; writes to ``output_path`` when given."""
+        resp = self._request("GET", f"/api/v1/jobs/{job_id}/download")
+        content = resp.content
+        if output_path:
+            with open(output_path, "wb") as f:
+                f.write(content)
+        return content
+
+    # ── convenience ──────────────────────────────────────────────────────────
+    def generate_to_pdf(
+        self,
+        prompt: str,
+        output_path: Optional[str] = None,
+        length: str = "standard",
+        mode: str = "business",
+        file_text: Optional[str] = None,
+        clarify: bool = False,
+        answers: Optional[List[str]] = None,
+        poll_interval: float = 3,
+        timeout: float = 900,
+    ) -> bytes:
+        """Submit, poll to completion, and download — one call end to end."""
+        data = self.generate(
+            prompt=prompt,
+            length=length,
+            mode=mode,
+            file_text=file_text,
+            clarify=clarify,
+            answers=answers,
+        )
+        if data.get("needsInput"):
+            raise PaperlyError(
+                f"Clarification needed — call generate(clarify=True) with answers for: "
+                f"{data.get('questions')}"
+            )
+        job = self.wait(data["jobId"], poll_interval=poll_interval, timeout=timeout)
+        return self.download(job["jobId"], output_path)
+
+    def generate_from_text_file(
+        self,
+        file_path: str,
+        prompt: str = "Organize this file's content into a clean, structured document.",
+        **kwargs,
+    ) -> bytes:
+        """Read a plain-text (or CSV) file locally and generate a PDF from it."""
+        with open(file_path, encoding="utf-8", errors="replace") as f:
+            text = f.read()
+        return self.generate_to_pdf(prompt=prompt, file_text=text, **kwargs)

paperlypdf-0.1.0/paperlypdf.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: paperlypdf
+Version: 0.1.0
+Summary: Python client for Paperly — turn prompts or CSV/Excel files into polished, downloadable PDF reports.
+License: MIT
+Project-URL: Homepage, https://saas-pdf-kappa.vercel.app
+Keywords: pdf,report,ai,generator,document,paperly
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25
+
+# Paperly Python SDK
+
+Turn a prompt — or a CSV/Excel file — into a polished, downloadable **PDF report**
+in a few lines of Python. The AI builds a designed, multi-page document
+(table of contents, tables, summary section) and renders it to PDF — no manual
+formatting.
+
+```bash
+pip install paperlypdf
+```
+
+## Quickstart
+
+```python
+from paperlypdf import PaperlyPdf
+
+client = PaperlyPdf(api_key="pdf_YOUR_API_KEY")
+
+pdf = client.generate_to_pdf(
+    "Write a quarterly sales analysis for Q2 2026.",
+    length="standard",          # concise | standard | in-depth
+    output_path="report.pdf",
+)
+```
+
+That's it — submit, poll, download. `report.pdf` lands on disk.
+
+## Data file → PDF report (the killer use case)
+
+```python
+import csv
+import io
+from paperlypdf import PaperlyPdf
+
+client = PaperlyPdf(api_key="pdf_YOUR_API_KEY")
+
+def csv_as_text(path):
+    with open(path, encoding="utf-8-sig") as f:
+        rows = list(csv.DictReader(f))
+    out = io.StringIO()
+    out.write(f"Source: {path} ({len(rows)} rows)\n\n")
+    for row in rows:
+        out.write(" | ".join(f"{k}: {v}" for k, v in row.items()))
+        out.write("\n")
+    return out.getvalue()
+
+client.generate_to_pdf(
+    "Organize this data into a clean business report with tables, "
+    "then add an analysis section with concrete recommendations.",
+    file_text=csv_as_text("sales.csv"),
+    length="standard",
+    output_path="sales_report.pdf",
+)
+```
+
+For Excel (`.xlsx`) use pandas to read and pass a text representation the same way:
+
+```python
+import pandas as pd
+client.generate_to_pdf("Summarize this into a clean report.", file_text=pd.read_excel("orders.xlsx").to_string())
+```
+
+## Low-level API
+
+| Method | Purpose |
+|---|---|
+| `generate(prompt, length, mode, file_text, clarify, answers)` | Submit a job — returns `jobId` |
+| `get_job(job_id)` | Poll status: `pending` / `running` / `done` / `failed` |
+| `wait(job_id)` | Block until `done` (raises on `failed` or timeout) |
+| `download(job_id, output_path)` | Fetch the finished PDF (bytes) |
+| `generate_to_pdf(...)` | All of the above in one call |
+| `me()` | API-key info: balance, usage, caps |
+
+### Handling clarifying questions
+
+Pass `clarify=True` and the API may ask questions first:
+
+```python
+res = client.generate("I need a document about ice cream.", clarify=True)
+if res.get("needsInput"):
+    print(res["questions"])   # -> ask the user, then retry with answers:
+    res = client.generate("I need a document about ice cream.",
+                          clarify=True,
+                          answers=["Tutorial", "Beginner home cooks", "3 sections"])
+job = client.wait(res["jobId"])
+client.download(job["jobId"], "out.pdf")
+```
+
+## Errors
+
+Non-2xx responses raise `PaperlyError` with the server's error message. Failed
+jobs raise `PaperlyError` too. Jobs expire after 30 minutes.
+
+## Pricing
+
+Prepaid, pay-as-you-go: `concise` $0.30 · `standard` $0.30 · `in-depth` $1.00,
+plus $0.10 per 100K characters of file data. No subscription.

paperlypdf-0.1.0/paperlypdf.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+paperlypdf/__init__.py
+paperlypdf/client.py
+paperlypdf.egg-info/PKG-INFO
+paperlypdf.egg-info/SOURCES.txt
+paperlypdf.egg-info/dependency_links.txt
+paperlypdf.egg-info/requires.txt
+paperlypdf.egg-info/top_level.txt

paperlypdf-0.1.0/paperlypdf.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

paperlypdf-0.1.0/paperlypdf.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25

paperlypdf-0.1.0/paperlypdf.egg-info/top_level.txt

@@ -0,0 +1 @@
+paperlypdf

paperlypdf-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "paperlypdf"
+version = "0.1.0"
+description = "Python client for Paperly — turn prompts or CSV/Excel files into polished, downloadable PDF reports."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["pdf", "report", "ai", "generator", "document", "paperly"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Office/Business",
+]
+dependencies = ["requests>=2.25"]
+
+[project.urls]
+Homepage = "https://saas-pdf-kappa.vercel.app"
+
+[tool.setuptools.packages.find]
+include = ["paperlypdf*"]

paperlypdf-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+