ag-docparse 0.5.0__tar.gz

ag_docparse-0.5.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: ag-docparse
+Version: 0.5.0
+Summary: LLM-powered document extraction SDK
+License: MIT
+Author: Adnan Ghribi
+Author-email: aghribi@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.15
+Provides-Extra: all
+Provides-Extra: anthropic
+Provides-Extra: openai
+Provides-Extra: pdf
+Requires-Dist: anthropic (>=0.25,<0.26) ; extra == "anthropic" or extra == "all"
+Requires-Dist: click (>=8.0,<9.0)
+Requires-Dist: httpx (>=0.27,<1)
+Requires-Dist: openai (>=1.0,<2.0) ; extra == "openai" or extra == "all"
+Requires-Dist: pdfplumber (>=0.11,<0.12) ; extra == "pdf" or extra == "all"
+Requires-Dist: pydantic (>=2.0,<3.0)
+Project-URL: Homepage, https://github.com/aghribi/ag-docparse
+Project-URL: Repository, https://github.com/aghribi/ag-docparse
+Description-Content-Type: text/markdown
+
+# ag-docparse
+
+LLM-based structured extraction from documents.
+
+Loads PDF or text documents and extracts typed fields with an LLM, using built-in schemas (invoice, loan application, W-2, NDA, contract) or a custom JSON schema.
+
+## Install
+
+```sh
+pip install "ag-docparse[all]"
+npm install ag-docparse
+```
+
+Extras: `openai`, `anthropic`, `pdf` (pdfplumber), `all`.
+
+## Usage
+
+```python
+from ag_docparse import INVOICE_SCHEMA, LLMExtractor, from_text
+
+layout = from_text("Invoice INV-001, total due 1,250.00 EUR by 2026-11-30.")
+result = LLMExtractor(model="gpt-4o-mini").extract(layout, INVOICE_SCHEMA)  # needs OPENAI_API_KEY
+print(result)
+```
+
+Command line: `ag-docparse extract -f invoice.pdf -s invoice` and `ag-docparse schemas`.
+
+The TypeScript package `ag-docparse` is a port of the core classes.
+
+## Hosted API
+
+`AsyncJobClient` submits large documents to the hosted API as asynchronous jobs. API keys are issued at https://ai.artifact-network.org. The default endpoint is `https://ai-api.artifact-network.org`; pass a different base URL to use your own deployment.
+
+## Development
+
+```sh
+cd packages/python && pip install -e ".[all]" && pytest
+cd packages/typescript && npm ci && npm test
+```
+
+## License
+
+MIT, Copyright (c) 2026 Adnan Ghribi.
+

ag_docparse-0.5.0/README.md

@@ -0,0 +1,43 @@
+# ag-docparse
+
+LLM-based structured extraction from documents.
+
+Loads PDF or text documents and extracts typed fields with an LLM, using built-in schemas (invoice, loan application, W-2, NDA, contract) or a custom JSON schema.
+
+## Install
+
+```sh
+pip install "ag-docparse[all]"
+npm install ag-docparse
+```
+
+Extras: `openai`, `anthropic`, `pdf` (pdfplumber), `all`.
+
+## Usage
+
+```python
+from ag_docparse import INVOICE_SCHEMA, LLMExtractor, from_text
+
+layout = from_text("Invoice INV-001, total due 1,250.00 EUR by 2026-11-30.")
+result = LLMExtractor(model="gpt-4o-mini").extract(layout, INVOICE_SCHEMA)  # needs OPENAI_API_KEY
+print(result)
+```
+
+Command line: `ag-docparse extract -f invoice.pdf -s invoice` and `ag-docparse schemas`.
+
+The TypeScript package `ag-docparse` is a port of the core classes.
+
+## Hosted API
+
+`AsyncJobClient` submits large documents to the hosted API as asynchronous jobs. API keys are issued at https://ai.artifact-network.org. The default endpoint is `https://ai-api.artifact-network.org`; pass a different base URL to use your own deployment.
+
+## Development
+
+```sh
+cd packages/python && pip install -e ".[all]" && pytest
+cd packages/typescript && npm ci && npm test
+```
+
+## License
+
+MIT, Copyright (c) 2026 Adnan Ghribi.

ag_docparse-0.5.0/ag_docparse/__init__.py

@@ -0,0 +1,23 @@
+"""docparse — LLM-powered document extraction."""
+
+from importlib.metadata import version as _version
+
+from .models    import (
+    FieldSpec, ExtractionSchema, FieldValue, ExtractionResult,
+    PageContent, DocumentLayout,
+)
+from .loader    import from_text, load
+from .extractor import LLMExtractor
+from .async_client import AsyncJobClient, QuotaExceededError
+from .schemas   import REGISTRY, INVOICE_SCHEMA, LOAN_APPLICATION_SCHEMA, W2_SCHEMA, NDA_SCHEMA, CONTRACT_SCHEMA
+
+__version__ = _version("ag-docparse")
+
+__all__ = [
+    "FieldSpec", "ExtractionSchema", "FieldValue", "ExtractionResult",
+    "PageContent", "DocumentLayout",
+    "from_text", "load",
+    "LLMExtractor", "AsyncJobClient", "QuotaExceededError",
+    "REGISTRY", "INVOICE_SCHEMA", "LOAN_APPLICATION_SCHEMA",
+    "W2_SCHEMA", "NDA_SCHEMA", "CONTRACT_SCHEMA",
+]

ag_docparse-0.5.0/ag_docparse/async_client.py

@@ -0,0 +1,98 @@
+"""Async job client for large-document extraction via the hosted DocParse API."""
+from __future__ import annotations
+import time
+from typing import Optional
+import httpx
+
+_DEFAULT_BASE = "https://ai-api.artifact-network.org"
+
+
+class QuotaExceededError(Exception):
+    """Raised when the hosted API returns HTTP 429 (monthly quota exceeded)."""
+    def __init__(self, message: str = "Monthly quota exceeded"):
+        super().__init__(message)
+
+
+def _check(resp: httpx.Response) -> None:
+    if resp.status_code == 429:
+        try:
+            detail = resp.json().get("detail", resp.text)
+        except Exception:
+            detail = resp.text
+        raise QuotaExceededError(detail)
+    resp.raise_for_status()
+
+
+class AsyncJobClient:
+    """
+    Submit DocParse extraction jobs and poll for results.
+    Use this for large PDFs (>1000 words) where the sync /extract endpoint may time out.
+
+    Example::
+
+        from ag_docparse import AsyncJobClient
+
+        client = AsyncJobClient(api_key="ag_live_...")
+
+        job = client.submit(text=pdf_text, schema_name="contract",
+                            webhook_url="https://yourapp.com/hooks/ag_docparse")
+        print(job["job_id"], job["status"])  # pending
+
+        # Poll until done (or use webhook)
+        result = client.wait(job["job_id"], timeout=120)
+        print(result["result"])  # {"parties": {"value": [...], "confidence": 0.97}, ...}
+    """
+
+    def __init__(self, api_key: str, base_url: str = _DEFAULT_BASE, timeout: float = 15.0):
+        self._base    = base_url.rstrip("/")
+        self._headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        self._timeout = timeout
+
+    def submit(
+        self,
+        text:        str,
+        schema_name: Optional[str] = None,
+        fields:      Optional[list[dict]] = None,
+        webhook_url: Optional[str] = None,
+    ) -> dict:
+        """Submit a job. Returns immediately with ``{"job_id": ..., "status": "pending"}``."""
+        payload: dict = {"text": text}
+        if schema_name:
+            payload["schema_name"] = schema_name
+        if fields:
+            payload["fields"] = fields
+        if webhook_url:
+            payload["webhook_url"] = webhook_url
+
+        with httpx.Client(base_url=self._base, headers=self._headers, timeout=self._timeout) as c:
+            r = c.post("/v1/doc/jobs", json=payload)
+            _check(r)
+            return r.json()
+
+    def poll(self, job_id: str) -> dict:
+        """Fetch current status of a job."""
+        with httpx.Client(base_url=self._base, headers=self._headers, timeout=self._timeout) as c:
+            r = c.get(f"/v1/doc/jobs/{job_id}")
+            _check(r)
+            return r.json()
+
+    def list_jobs(self) -> list[dict]:
+        """Return the 20 most recent jobs for this API key."""
+        with httpx.Client(base_url=self._base, headers=self._headers, timeout=self._timeout) as c:
+            r = c.get("/v1/doc/jobs")
+            _check(r)
+            return r.json()
+
+    def wait(self, job_id: str, timeout: float = 120.0, poll_interval: float = 2.0) -> dict:
+        """
+        Block until the job is ``completed`` or ``failed``, then return the job dict.
+        Raises ``TimeoutError`` if *timeout* seconds elapse first.
+        """
+        deadline = time.monotonic() + timeout
+        while True:
+            job = self.poll(job_id)
+            if job["status"] in ("completed", "failed"):
+                return job
+            if time.monotonic() >= deadline:
+                raise TimeoutError(f"Job {job_id} not finished within {timeout}s")
+            time.sleep(poll_interval)

ag_docparse-0.5.0/ag_docparse/cli.py

@@ -0,0 +1,68 @@
+"""docparse CLI — extract structured data from documents."""
+from __future__ import annotations
+import json
+import sys
+import click
+from .loader    import load
+from .extractor import LLMExtractor
+from .schemas   import REGISTRY
+from .models    import ExtractionSchema, FieldSpec
+
+
+@click.group()
+def cli():
+    """docparse — LLM-powered document extraction."""
+
+
+@cli.command()
+@click.option("--file",   "-f", required=True, help="Path to document (PDF, TXT)")
+@click.option("--schema", "-s", required=True, help=f"Schema name: {', '.join(REGISTRY)} — or path to JSON schema file")
+@click.option("--model",  "-m", default="gpt-4o-mini", help="LLM model (default gpt-4o-mini)")
+@click.option("--provider", "-p", default="openai", help="LLM provider: openai | anthropic")
+@click.option("--output", "-o", default="json", type=click.Choice(["json", "table"]))
+def extract(file, schema, model, provider, output):
+    """Extract structured data from a document."""
+    layout = load(file)
+
+    if schema in REGISTRY:
+        sch = REGISTRY[schema]
+    else:
+        try:
+            raw = json.loads(open(schema).read())
+            sch = ExtractionSchema(
+                name=raw.get("name", "custom"),
+                fields=[FieldSpec(**f) for f in raw["fields"]],
+            )
+        except Exception as e:
+            raise click.BadParameter(f"Could not load schema: {e}")
+
+    extractor = LLMExtractor(model=model, provider=provider)
+    result    = extractor.extract(layout, sch)
+
+    if output == "json":
+        click.echo(json.dumps({
+            k: {"value": v.value, "confidence": round(v.confidence, 2)}
+            for k, v in result.fields.items()
+        }, indent=2))
+    else:
+        click.echo(f"{'Field':<25} {'Value':<40} {'Confidence':>10}")
+        click.echo("-" * 78)
+        for k, v in result.fields.items():
+            val = str(v.value) if v.value is not None else "(not found)"
+            click.echo(f"{k:<25} {val:<40} {v.confidence:>10.0%}")
+
+    missing = result.missing_required(sch)
+    if missing:
+        click.echo(f"\n⚠ Missing required fields: {', '.join(missing)}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+def schemas():
+    """List available built-in schemas."""
+    for name, sch in REGISTRY.items():
+        click.echo(f"{name:<20} ({len(sch.fields)} fields)")
+
+
+def main():
+    cli()

ag_docparse-0.5.0/ag_docparse/extractor.py

@@ -0,0 +1,118 @@
+"""LLM-powered schema-based extraction."""
+from __future__ import annotations
+import json
+import re
+from .models import DocumentLayout, ExtractionSchema, ExtractionResult, FieldValue
+
+_EXTRACT_PROMPT = """\
+You are an expert document extraction assistant. Extract structured data from the document text below.
+
+DOCUMENT TEXT:
+{text}
+
+SCHEMA — extract these fields:
+{fields}
+
+Return ONLY valid JSON in exactly this format (no markdown, no explanation):
+{{
+  "fields": {{
+    "<field_name>": {{
+      "value": <extracted_value_or_null>,
+      "confidence": <float_0.0_to_1.0>,
+      "raw": "<short_text_snippet_from_document>"
+    }}
+  }}
+}}
+
+Rules:
+- confidence 0.9–1.0: value clearly stated in document
+- confidence 0.5–0.9: value inferred or partially stated
+- confidence 0.0–0.5: value guessed or not found (set value to null)
+- For missing fields, use null with confidence 0.0
+- For dates, use ISO 8601 format (YYYY-MM-DD)
+- For numbers, return numeric type (not string)
+- For booleans, return true/false
+"""
+
+_JSON_RE = re.compile(r"\{.*\}", re.DOTALL)
+
+
+class LLMExtractor:
+    def __init__(
+        self,
+        model:    str = "gpt-4o-mini",
+        provider: str = "openai",
+        max_chars: int = 12_000,  # ~3K tokens — keep cost low for Phase 0
+    ):
+        self.model     = model
+        self.provider  = provider
+        self.max_chars = max_chars
+        self._client   = None
+
+    def _get_client(self):
+        if self._client:
+            return self._client
+        if self.provider == "openai":
+            from openai import OpenAI
+            self._client = OpenAI()
+        else:
+            from anthropic import Anthropic
+            self._client = Anthropic()
+        return self._client
+
+    def _call(self, prompt: str) -> str:
+        client = self._get_client()
+        if self.provider == "openai":
+            resp = client.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0,
+                response_format={"type": "json_object"},
+            )
+            return resp.choices[0].message.content or ""
+        else:
+            resp = client.messages.create(
+                model=self.model,
+                max_tokens=2048,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return resp.content[0].text if resp.content else ""
+
+    def extract(self, layout: DocumentLayout, schema: ExtractionSchema) -> ExtractionResult:
+        text   = layout.total_text[: self.max_chars]
+        prompt = _EXTRACT_PROMPT.format(text=text, fields=schema.prompt_lines())
+        raw    = self._call(prompt)
+        return self._parse_response(raw, schema, layout.page_count)
+
+    def _parse_response(self, raw: str, schema: ExtractionSchema, page_count: int = 1) -> ExtractionResult:
+        try:
+            data   = json.loads(raw)
+            fields = data.get("fields", {})
+        except json.JSONDecodeError:
+            m = _JSON_RE.search(raw)
+            if m:
+                try:
+                    data   = json.loads(m.group(0))
+                    fields = data.get("fields", {})
+                except json.JSONDecodeError:
+                    fields = {}
+            else:
+                fields = {}
+
+        fv_map: dict[str, FieldValue] = {}
+        for spec in schema.fields:
+            entry = fields.get(spec.name, {})
+            if isinstance(entry, dict):
+                fv_map[spec.name] = FieldValue(
+                    value=entry.get("value"),
+                    confidence=float(entry.get("confidence", 0.0)),
+                    raw=str(entry.get("raw", "")),
+                )
+            else:
+                fv_map[spec.name] = FieldValue(value=None, confidence=0.0)
+
+        return ExtractionResult(
+            schema_name=schema.name,
+            fields=fv_map,
+            page_count=page_count,
+        )

ag_docparse-0.5.0/ag_docparse/loader.py

@@ -0,0 +1,52 @@
+"""Document loader — PDF and raw text to DocumentLayout."""
+from __future__ import annotations
+from pathlib import Path
+from .models import DocumentLayout, PageContent
+
+
+def from_text(text: str, source: str = "text") -> DocumentLayout:
+    """Wrap raw text as a single-page DocumentLayout (useful for testing)."""
+    return DocumentLayout(
+        source=source,
+        pages=[PageContent(page_num=1, text=text)],
+    )
+
+
+def from_pdf(path: str | Path) -> DocumentLayout:
+    """Parse a PDF file using pdfplumber."""
+    try:
+        import pdfplumber
+    except ImportError:
+        raise ImportError("PDF support requires pdfplumber: pip install docparse[pdf]")
+
+    path   = Path(path)
+    pages: list[PageContent] = []
+
+    with pdfplumber.open(path) as pdf:
+        for i, page in enumerate(pdf.pages, start=1):
+            text   = page.extract_text() or ""
+            tables = []
+            for table in page.extract_tables() or []:
+                # Normalise None cells to empty string
+                cleaned = [[cell or "" for cell in row] for row in table if row]
+                if cleaned:
+                    tables.append(cleaned)
+            pages.append(PageContent(
+                page_num=i,
+                text=text,
+                tables=tables,
+                width=float(page.width),
+                height=float(page.height),
+            ))
+
+    return DocumentLayout(source=str(path), pages=pages)
+
+
+def load(path: str | Path) -> DocumentLayout:
+    path = Path(path)
+    suffix = path.suffix.lower()
+    if suffix == ".pdf":
+        return from_pdf(path)
+    if suffix in (".txt", ".md"):
+        return from_text(path.read_text(encoding="utf-8"), source=str(path))
+    raise ValueError(f"Unsupported file type: {suffix}. Use .pdf, .txt, or .md")

ag_docparse-0.5.0/ag_docparse/models.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+from typing import Any, Literal
+from pydantic import BaseModel, field_validator
+
+FieldType = Literal["string", "number", "date", "boolean", "list"]
+
+
+class FieldSpec(BaseModel):
+    name:        str
+    description: str
+    type:        FieldType = "string"
+    required:    bool      = False
+    example:     str | None = None   # helps the LLM understand the expected format
+
+
+class ExtractionSchema(BaseModel):
+    name:   str
+    fields: list[FieldSpec]
+
+    def field_names(self) -> list[str]:
+        return [f.name for f in self.fields]
+
+    def prompt_lines(self) -> str:
+        lines = []
+        for f in self.fields:
+            req  = " (REQUIRED)" if f.required else ""
+            ex   = f' e.g. "{f.example}"' if f.example else ""
+            lines.append(f"- {f.name} ({f.type}){req}: {f.description}{ex}")
+        return "\n".join(lines)
+
+
+class FieldValue(BaseModel):
+    value:      Any
+    confidence: float = 0.0
+    raw:        str   = ""
+
+    @field_validator("confidence")
+    @classmethod
+    def clamp(cls, v: float) -> float:
+        return max(0.0, min(1.0, v))
+
+
+class ExtractionResult(BaseModel):
+    schema_name: str
+    fields:      dict[str, FieldValue]
+    page_count:  int = 1
+
+    def get(self, field: str) -> Any:
+        fv = self.fields.get(field)
+        return fv.value if fv else None
+
+    def confidence(self, field: str) -> float:
+        fv = self.fields.get(field)
+        return fv.confidence if fv else 0.0
+
+    def missing_required(self, schema: ExtractionSchema) -> list[str]:
+        return [
+            f.name for f in schema.fields
+            if f.required and (self.fields.get(f.name) is None or self.fields[f.name].value is None)
+        ]
+
+
+class TableCell(BaseModel):
+    text:    str
+    row:     int
+    col:     int
+    rowspan: int = 1
+    colspan: int = 1
+
+
+class PageContent(BaseModel):
+    page_num: int
+    text:     str
+    tables:   list[list[list[str]]] = []  # tables[table_idx][row][col]
+    width:    float = 0.0
+    height:   float = 0.0
+
+
+class DocumentLayout(BaseModel):
+    source:     str = "unknown"
+    pages:      list[PageContent]
+    total_text: str = ""
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not self.total_text:
+            self.total_text = "\n\n".join(p.text for p in self.pages)
+
+    @property
+    def page_count(self) -> int:
+        return len(self.pages)
+
+    def text_for_pages(self, start: int = 1, end: int | None = None) -> str:
+        pages = [p for p in self.pages if start <= p.page_num <= (end or len(self.pages))]
+        return "\n\n".join(p.text for p in pages)
+
+    def all_tables(self) -> list[list[list[str]]]:
+        return [t for p in self.pages for t in p.tables]

ag_docparse-0.5.0/ag_docparse/schemas/__init__.py

@@ -0,0 +1,16 @@
+from .invoice  import INVOICE_SCHEMA
+from .mortgage import LOAN_APPLICATION_SCHEMA, W2_SCHEMA
+from .legal    import NDA_SCHEMA, CONTRACT_SCHEMA
+
+REGISTRY: dict[str, object] = {
+    "invoice":          INVOICE_SCHEMA,
+    "loan_application": LOAN_APPLICATION_SCHEMA,
+    "w2":               W2_SCHEMA,
+    "nda":              NDA_SCHEMA,
+    "contract":         CONTRACT_SCHEMA,
+}
+
+__all__ = [
+    "INVOICE_SCHEMA", "LOAN_APPLICATION_SCHEMA", "W2_SCHEMA",
+    "NDA_SCHEMA", "CONTRACT_SCHEMA", "REGISTRY",
+]

ag_docparse-0.5.0/ag_docparse/schemas/invoice.py

@@ -0,0 +1,19 @@
+from ..models import ExtractionSchema, FieldSpec
+
+INVOICE_SCHEMA = ExtractionSchema(
+    name="invoice",
+    fields=[
+        FieldSpec(name="invoice_number",   type="string",  required=True,  description="Invoice number or ID",             example="INV-2024-001"),
+        FieldSpec(name="invoice_date",     type="date",    required=True,  description="Date the invoice was issued",       example="2024-03-15"),
+        FieldSpec(name="due_date",         type="date",    required=False, description="Payment due date"),
+        FieldSpec(name="vendor_name",      type="string",  required=True,  description="Name of the vendor or supplier"),
+        FieldSpec(name="vendor_address",   type="string",  required=False, description="Full address of the vendor"),
+        FieldSpec(name="client_name",      type="string",  required=False, description="Name of the billed client"),
+        FieldSpec(name="subtotal",         type="number",  required=False, description="Subtotal before tax",               example="1250.00"),
+        FieldSpec(name="tax_amount",       type="number",  required=False, description="Tax or VAT amount"),
+        FieldSpec(name="total_amount",     type="number",  required=True,  description="Total amount due",                  example="1500.00"),
+        FieldSpec(name="currency",         type="string",  required=False, description="Currency code",                     example="EUR"),
+        FieldSpec(name="payment_terms",    type="string",  required=False, description="Payment terms",                     example="Net 30"),
+        FieldSpec(name="line_items",       type="list",    required=False, description="List of line items as strings"),
+    ],
+)

ag_docparse-0.5.0/ag_docparse/schemas/legal.py

@@ -0,0 +1,30 @@
+from ..models import ExtractionSchema, FieldSpec
+
+NDA_SCHEMA = ExtractionSchema(
+    name="nda",
+    fields=[
+        FieldSpec(name="party_1",            type="string",  required=True,  description="First party (disclosing party) full legal name"),
+        FieldSpec(name="party_2",            type="string",  required=True,  description="Second party (receiving party) full legal name"),
+        FieldSpec(name="effective_date",     type="date",    required=True,  description="Date the agreement becomes effective"),
+        FieldSpec(name="expiry_date",        type="date",    required=False, description="Date the agreement expires if stated"),
+        FieldSpec(name="confidential_info",  type="string",  required=False, description="Description of what constitutes confidential information"),
+        FieldSpec(name="jurisdiction",       type="string",  required=False, description="Governing law / jurisdiction",     example="State of California"),
+        FieldSpec(name="term_years",         type="number",  required=False, description="Duration of confidentiality obligation in years"),
+        FieldSpec(name="mutual",             type="boolean", required=False, description="True if mutual NDA, False if one-way"),
+    ],
+)
+
+CONTRACT_SCHEMA = ExtractionSchema(
+    name="contract",
+    fields=[
+        FieldSpec(name="contract_title",     type="string",  required=False, description="Title or type of contract"),
+        FieldSpec(name="party_1",            type="string",  required=True,  description="First party full legal name"),
+        FieldSpec(name="party_2",            type="string",  required=True,  description="Second party full legal name"),
+        FieldSpec(name="effective_date",     type="date",    required=False, description="Effective date of the contract"),
+        FieldSpec(name="expiry_date",        type="date",    required=False, description="Expiry or end date if stated"),
+        FieldSpec(name="contract_value",     type="number",  required=False, description="Total contract value if stated"),
+        FieldSpec(name="payment_terms",      type="string",  required=False, description="Payment schedule or terms"),
+        FieldSpec(name="jurisdiction",       type="string",  required=False, description="Governing law"),
+        FieldSpec(name="termination_notice", type="string",  required=False, description="Required notice period for termination"),
+    ],
+)

ag_docparse-0.5.0/ag_docparse/schemas/mortgage.py

@@ -0,0 +1,33 @@
+from ..models import ExtractionSchema, FieldSpec
+
+LOAN_APPLICATION_SCHEMA = ExtractionSchema(
+    name="loan_application",
+    fields=[
+        FieldSpec(name="borrower_name",       type="string",  required=True,  description="Full name of the primary borrower"),
+        FieldSpec(name="co_borrower_name",    type="string",  required=False, description="Full name of the co-borrower if any"),
+        FieldSpec(name="property_address",    type="string",  required=True,  description="Address of the property being financed"),
+        FieldSpec(name="loan_amount",         type="number",  required=True,  description="Requested loan amount in dollars",   example="350000"),
+        FieldSpec(name="loan_purpose",        type="string",  required=False, description="Purpose of the loan",               example="Purchase"),
+        FieldSpec(name="property_type",       type="string",  required=False, description="Type of property",                  example="Single Family"),
+        FieldSpec(name="annual_income",       type="number",  required=False, description="Borrower's annual income"),
+        FieldSpec(name="employment_status",   type="string",  required=False, description="Employment status of borrower",     example="Employed"),
+        FieldSpec(name="employer_name",       type="string",  required=False, description="Name of borrower's employer"),
+        FieldSpec(name="credit_score",        type="number",  required=False, description="Credit score if stated"),
+        FieldSpec(name="application_date",    type="date",    required=False, description="Date the application was submitted"),
+        FieldSpec(name="ssn_last4",           type="string",  required=False, description="Last 4 digits of SSN if present"),
+    ],
+)
+
+W2_SCHEMA = ExtractionSchema(
+    name="w2",
+    fields=[
+        FieldSpec(name="employee_name",       type="string",  required=True,  description="Employee's full name"),
+        FieldSpec(name="employer_name",       type="string",  required=True,  description="Employer's name"),
+        FieldSpec(name="tax_year",            type="string",  required=True,  description="Tax year",                         example="2023"),
+        FieldSpec(name="wages",               type="number",  required=True,  description="Box 1: Wages, tips, other comp"),
+        FieldSpec(name="federal_tax_withheld",type="number",  required=False, description="Box 2: Federal income tax withheld"),
+        FieldSpec(name="social_security_wages",type="number", required=False, description="Box 3: Social security wages"),
+        FieldSpec(name="medicare_wages",      type="number",  required=False, description="Box 5: Medicare wages"),
+        FieldSpec(name="state",               type="string",  required=False, description="State abbreviation",               example="CA"),
+    ],
+)

ag_docparse-0.5.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "ag-docparse"
+version = "0.5.0"
+description = "LLM-powered document extraction SDK"
+authors = ["Adnan Ghribi <aghribi@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/aghribi/ag-docparse"
+repository = "https://github.com/aghribi/ag-docparse"
+packages = [{ include = "ag_docparse" }]
+
+[tool.poetry.scripts]
+ag-docparse = "ag_docparse.cli:main"
+
+[tool.poetry.dependencies]
+python   = "^3.10"
+pydantic = "^2.0"
+httpx = ">=0.27,<1"
+click    = "^8.0"
+
+[tool.poetry.extras]
+openai    = ["openai"]
+anthropic = ["anthropic"]
+pdf       = ["pdfplumber"]
+all       = ["openai", "anthropic", "pdfplumber"]
+
+[tool.poetry.dependencies.openai]
+version  = "^1.0"
+optional = true
+
+[tool.poetry.dependencies.anthropic]
+version  = "^0.25"
+optional = true
+
+[tool.poetry.dependencies.pdfplumber]
+version  = "^0.11"
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+pytest         = "^8.0"
+pytest-asyncio = "^0.23"
+ruff           = "^0.4"
+openai         = "^1.0"
+pdfplumber     = "^0.11"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100