ailang-parse 0.1.0__py3-none-any.whl

ailang_parse/__init__.py

@@ -0,0 +1,38 @@
+"""AILANG Parse — Python client for the AILANG Parse document parsing API.
+
+Usage::
+
+    from ailang_parse import DocParse
+
+    client = DocParse(api_key="dp_a1b2c3d4...")
+    result = client.parse("report.docx")
+    print(result.blocks)
+
+Unstructured migration::
+
+    from ailang_parse import UnstructuredClient
+    client = UnstructuredClient(
+        server_url="https://ailang-dev-docparse-api-ejjw6zt3bq-ew.a.run.app"
+    )
+    elements = client.general.partition(file="report.docx")
+"""
+from .client import DocParse
+from .compat import UnstructuredClient
+from .types import (
+    Block, Cell, ParseResult, DocMetadata, Summary,
+    HealthResult, FormatsResult,
+    KeyInfo, Quota, Usage, UsageInfo,
+    Element, ElementMetadata,
+    DocParseError, AuthError, QuotaError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "DocParse",
+    "UnstructuredClient",
+    "Block", "Cell", "ParseResult", "DocMetadata", "Summary",
+    "HealthResult", "FormatsResult",
+    "KeyInfo", "Quota", "Usage", "UsageInfo",
+    "Element", "ElementMetadata",
+    "DocParseError", "AuthError", "QuotaError",
+]

ailang_parse/client.py

@@ -0,0 +1,96 @@
+"""AILANG Parse HTTP client — handles API communication and response unwrapping."""
+from __future__ import annotations
+import json
+from typing import Any, Dict, Optional
+
+import requests
+
+from .types import (
+    DocParseError, AuthError, QuotaError,
+    ParseResult, HealthResult, FormatsResult,
+)
+
+DEFAULT_BASE_URL = "https://ailang-dev-docparse-api-ejjw6zt3bq-ew.a.run.app"
+
+
+class DocParse:
+    """AILANG Parse API client.
+
+    Usage::
+
+        from ailang_parse import DocParse
+
+        client = DocParse(api_key="dp_a1b2c3d4...")
+        result = client.parse("report.docx")
+        print(result.blocks)
+    """
+
+    def __init__(
+        self,
+        api_key: str = "",
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: int = 60,
+    ):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+        if api_key:
+            self._session.headers["x-api-key"] = api_key
+
+        from .keys import KeyManager
+        self.keys = KeyManager(self)
+
+    # ── Core API methods ──
+
+    def parse(self, filepath: str, output_format: str = "blocks") -> ParseResult:
+        """Parse a document file. Returns structured blocks."""
+        data = self._call("POST", "/api/v1/parse", args=[filepath, output_format])
+        return ParseResult.from_dict(data)
+
+    def health(self) -> HealthResult:
+        """Check API health."""
+        data = self._call("GET", "/api/v1/health")
+        return HealthResult.from_dict(data)
+
+    def formats(self) -> FormatsResult:
+        """List supported formats."""
+        data = self._call("GET", "/api/v1/formats")
+        return FormatsResult.from_dict(data)
+
+    # ── HTTP layer ──
+
+    def _call(self, method: str, path: str, args: Optional[list] = None) -> Dict[str, Any]:
+        """Make an API call and unwrap the serve-api response envelope."""
+        url = self.base_url + path
+
+        if method == "GET":
+            resp = self._session.get(url, timeout=self.timeout)
+        else:
+            body = {"args": args} if args else {}
+            resp = self._session.post(
+                url, json=body, timeout=self.timeout
+            )
+
+        if resp.status_code == 401:
+            raise AuthError("Invalid or missing API key", 401)
+        if resp.status_code == 429:
+            raise QuotaError("Quota exceeded", status_code=429)
+        if resp.status_code >= 400:
+            raise DocParseError(f"API error: {resp.status_code} {resp.text}", resp.status_code)
+
+        outer = resp.json()
+
+        # serve-api wraps responses: {"result": "<json string>", "module": ..., "elapsed_ms": N}
+        if "error" in outer and outer["error"]:
+            raise DocParseError(outer["error"])
+
+        result_str = outer.get("result", "")
+        if not result_str:
+            return outer
+
+        # Inner result is a JSON string that needs a second parse
+        try:
+            return json.loads(result_str)
+        except (json.JSONDecodeError, TypeError):
+            return {"raw": result_str}

ailang_parse/compat.py

@@ -0,0 +1,82 @@
+"""Unstructured API compatibility — drop-in replacement for unstructured-client."""
+from __future__ import annotations
+import json
+from typing import List, Optional
+
+import requests
+
+from .types import Element, DocParseError
+
+DEFAULT_BASE_URL = "https://ailang-dev-docparse-api-ejjw6zt3bq-ew.a.run.app"
+
+
+class _GeneralApi:
+    """Mimics unstructured_client.general.GeneralApi."""
+
+    def __init__(self, session: requests.Session, base_url: str, timeout: int):
+        self._session = session
+        self._base_url = base_url
+        self._timeout = timeout
+
+    def partition(self, file: str = "", strategy: str = "auto", **kwargs) -> List[Element]:
+        """Partition a document — returns Unstructured-format elements.
+
+        Usage (identical to unstructured-client)::
+
+            elements = client.general.partition(file="report.docx")
+        """
+        url = f"{self._base_url}/general/v0/general"
+        resp = self._session.post(
+            url,
+            json={"args": [file, strategy]},
+            timeout=self._timeout,
+        )
+
+        if resp.status_code >= 400:
+            raise DocParseError(f"API error: {resp.status_code}", resp.status_code)
+
+        outer = resp.json()
+        if "error" in outer and outer["error"]:
+            raise DocParseError(outer["error"])
+
+        result_str = outer.get("result", "[]")
+        try:
+            elements_raw = json.loads(result_str)
+        except (json.JSONDecodeError, TypeError):
+            return []
+
+        if isinstance(elements_raw, list):
+            return [Element.from_dict(e) for e in elements_raw]
+        return []
+
+
+class UnstructuredClient:
+    """Drop-in replacement for ``unstructured_client.UnstructuredClient``.
+
+    Migration::
+
+        # Before
+        from unstructured_client import UnstructuredClient
+        client = UnstructuredClient(server_url="https://api.unstructured.io")
+
+        # After — one import change
+        from ailang_parse import UnstructuredClient
+        client = UnstructuredClient(
+            server_url="https://ailang-dev-docparse-api-ejjw6zt3bq-ew.a.run.app"
+        )
+        # All existing code works unchanged
+    """
+
+    def __init__(
+        self,
+        server_url: str = DEFAULT_BASE_URL,
+        api_key: str = "",
+        timeout: int = 60,
+        **kwargs,  # Accept extra args for compat
+    ):
+        self._session = requests.Session()
+        if api_key:
+            self._session.headers["unstructured-api-key"] = api_key
+        self._base_url = server_url.rstrip("/")
+        self._timeout = timeout
+        self.general = _GeneralApi(self._session, self._base_url, self._timeout)

ailang_parse/keys.py

@@ -0,0 +1,49 @@
+"""AILANG Parse key management — generate, list, revoke, rotate, usage."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from .types import KeyInfo, UsageInfo
+
+if TYPE_CHECKING:
+    from .client import DocParse
+
+
+class KeyManager:
+    """API key management. Access via ``client.keys``."""
+
+    def __init__(self, client: "DocParse"):
+        self._client = client
+
+    def generate(self, label: str = "default", user_id: str = "", auth_token: str = "") -> KeyInfo:
+        """Generate a new API key.
+
+        .. deprecated:: 0.10.0
+            Direct key generation removed. Use the device auth flow instead:
+            1. POST /api/v1/auth/device → get device_code + user_code
+            2. POST /api/v1/auth/device/approve (with Firebase Bearer token)
+            3. POST /api/v1/auth/device/poll → get api_key
+        """
+        raise NotImplementedError(
+            "Direct key generation removed in v0.10.0. Use device auth flow: "
+            "POST /api/v1/auth/device → approve → poll"
+        )
+
+    def list(self, user_id: str = "", auth_token: str = "") -> dict:
+        """List API keys for a user."""
+        data = self._client._call("POST", "/api/v1/keys/list", args=[user_id])
+        return data
+
+    def revoke(self, key_id: str, user_id: str = "", auth_token: str = "") -> dict:
+        """Revoke an API key."""
+        data = self._client._call("POST", "/api/v1/keys/revoke", args=[key_id, user_id])
+        return data
+
+    def rotate(self, key_id: str, user_id: str = "", auth_token: str = "") -> KeyInfo:
+        """Rotate a key — generates new key, revokes old one, preserves tier."""
+        data = self._client._call("POST", "/api/v1/keys/rotate", args=[key_id, user_id])
+        return KeyInfo.from_dict(data)
+
+    def usage(self, key_id: str, user_id: str = "", auth_token: str = "") -> UsageInfo:
+        """Get usage statistics for a key."""
+        data = self._client._call("POST", "/api/v1/keys/usage", args=[key_id, user_id])
+        return UsageInfo.from_dict(data)

ailang_parse/types.py

@@ -0,0 +1,320 @@
+"""AILANG Parse types — Block ADT, ParseResult, metadata, errors."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+
+# ── Errors ──
+
+class DocParseError(Exception):
+    """Base error for all AILANG Parse API errors."""
+    def __init__(self, message: str, status_code: int = 0):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class AuthError(DocParseError):
+    """Invalid or missing API key."""
+    pass
+
+
+class QuotaError(DocParseError):
+    """Quota exceeded (daily requests or monthly pages)."""
+    def __init__(self, message: str, tier: str = "", used: int = 0, limit: int = 0):
+        super().__init__(message, 429)
+        self.tier = tier
+        self.used = used
+        self.limit = limit
+
+
+# ── Cell (for tables) ──
+
+@dataclass
+class Cell:
+    text: str = ""
+    col_span: int = 1
+    merged: bool = False
+
+    @classmethod
+    def from_raw(cls, raw: Any) -> "Cell":
+        if isinstance(raw, str):
+            return cls(text=raw)
+        if isinstance(raw, dict):
+            return cls(
+                text=raw.get("text", ""),
+                col_span=raw.get("colSpan", 1),
+                merged=raw.get("merged", False),
+            )
+        return cls(text=str(raw))
+
+
+# ── Block variants ──
+
+@dataclass
+class Block:
+    type: str = ""
+    # TextBlock / HeadingBlock / ChangeBlock
+    text: str = ""
+    level: int = 0
+    style: str = ""
+    # ChangeBlock
+    change_type: str = ""
+    author: str = ""
+    date: str = ""
+    # TableBlock
+    headers: List[Cell] = field(default_factory=list)
+    rows: List[List[Cell]] = field(default_factory=list)
+    # ListBlock
+    items: List[str] = field(default_factory=list)
+    ordered: bool = False
+    # ImageBlock / AudioBlock / VideoBlock
+    description: str = ""
+    transcription: str = ""
+    mime: str = ""
+    data_length: int = 0
+    # SectionBlock
+    kind: str = ""
+    children: List["Block"] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Block":
+        block_type = d.get("type", "")
+        b = cls(type=block_type)
+
+        b.text = d.get("text", "")
+        b.level = d.get("level", 0)
+        b.style = d.get("style", "")
+        b.change_type = d.get("changeType", "")
+        b.author = d.get("author", "")
+        b.date = d.get("date", "")
+        b.description = d.get("description", "")
+        b.transcription = d.get("transcription", "")
+        b.mime = d.get("mime", "")
+        b.data_length = d.get("dataLength", 0)
+        b.kind = d.get("kind", "")
+        b.ordered = d.get("ordered", False)
+        b.items = d.get("items", [])
+
+        # Table
+        b.headers = [Cell.from_raw(c) for c in d.get("headers", [])]
+        b.rows = [[Cell.from_raw(c) for c in row] for row in d.get("rows", [])]
+
+        # Section (recursive)
+        b.children = [Block.from_dict(child) for child in d.get("blocks", [])]
+
+        return b
+
+
+# ── Metadata ──
+
+@dataclass
+class DocMetadata:
+    title: str = ""
+    author: str = ""
+    created: str = ""
+    modified: str = ""
+    page_count: int = 0
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "DocMetadata":
+        return cls(
+            title=d.get("title", ""),
+            author=d.get("author", ""),
+            created=d.get("created", ""),
+            modified=d.get("modified", ""),
+            page_count=d.get("pageCount", 0),
+        )
+
+
+@dataclass
+class Summary:
+    total_blocks: int = 0
+    headings: int = 0
+    tables: int = 0
+    images: int = 0
+    changes: int = 0
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Summary":
+        return cls(
+            total_blocks=d.get("totalBlocks", 0),
+            headings=d.get("headings", 0),
+            tables=d.get("tables", 0),
+            images=d.get("images", 0),
+            changes=d.get("changes", 0),
+        )
+
+
+# ── Parse result ──
+
+@dataclass
+class ParseResult:
+    status: str = ""
+    filename: str = ""
+    format: str = ""
+    blocks: List[Block] = field(default_factory=list)
+    metadata: DocMetadata = field(default_factory=DocMetadata)
+    summary: Summary = field(default_factory=Summary)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "ParseResult":
+        return cls(
+            status=d.get("status", ""),
+            filename=d.get("filename", ""),
+            format=d.get("format", ""),
+            blocks=[Block.from_dict(b) for b in d.get("blocks", [])],
+            metadata=DocMetadata.from_dict(d.get("metadata", {})),
+            summary=Summary.from_dict(d.get("summary", {})),
+        )
+
+
+# ── Health / Formats ──
+
+@dataclass
+class HealthResult:
+    status: str = ""
+    version: str = ""
+    service: str = ""
+    formats_parse: int = 0
+    formats_generate: int = 0
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "HealthResult":
+        return cls(
+            status=d.get("status", ""),
+            version=d.get("version", ""),
+            service=d.get("service", ""),
+            formats_parse=int(d.get("formats_parse", 0)),
+            formats_generate=int(d.get("formats_generate", 0)),
+        )
+
+
+@dataclass
+class FormatsResult:
+    parse: List[str] = field(default_factory=list)
+    generate: List[str] = field(default_factory=list)
+    ai_required: List[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "FormatsResult":
+        return cls(
+            parse=d.get("parse", []),
+            generate=d.get("generate", []),
+            ai_required=d.get("ai_required", []),
+        )
+
+
+# ── Key management types ──
+
+@dataclass
+class Quota:
+    requests_per_day: int = 0
+    pages_per_month: int = 0
+    ai_limit_per_request: int = 0
+    fs_limit_per_request: int = 0
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Quota":
+        return cls(
+            requests_per_day=int(d.get("requestsPerDay", 0)),
+            pages_per_month=int(d.get("pagesPerMonth", 0)),
+            ai_limit_per_request=int(d.get("aiLimitPerRequest", 0)),
+            fs_limit_per_request=int(d.get("fsLimitPerRequest", 0)),
+        )
+
+
+@dataclass
+class KeyInfo:
+    status: str = ""
+    key: str = ""
+    key_id: str = ""
+    label: str = ""
+    tier: str = ""
+    created: str = ""
+    quota: Quota = field(default_factory=Quota)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "KeyInfo":
+        return cls(
+            status=d.get("status", ""),
+            key=d.get("key", ""),
+            key_id=d.get("keyId", ""),
+            label=d.get("label", ""),
+            tier=d.get("tier", ""),
+            created=d.get("created", ""),
+            quota=Quota.from_dict(d.get("quota", {})),
+        )
+
+
+@dataclass
+class Usage:
+    requests_today: int = 0
+    pages_this_month: int = 0
+    total_requests: int = 0
+    total_pages: int = 0
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Usage":
+        return cls(
+            requests_today=int(d.get("requestsToday", 0)),
+            pages_this_month=int(d.get("pagesThisMonth", 0)),
+            total_requests=int(d.get("totalRequests", 0)),
+            total_pages=int(d.get("totalPages", 0)),
+        )
+
+
+@dataclass
+class UsageInfo:
+    status: str = ""
+    key_id: str = ""
+    tier: str = ""
+    usage: Usage = field(default_factory=Usage)
+    quota: Quota = field(default_factory=Quota)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "UsageInfo":
+        return cls(
+            status=d.get("status", ""),
+            key_id=d.get("keyId", ""),
+            tier=d.get("tier", ""),
+            usage=Usage.from_dict(d.get("usage", {})),
+            quota=Quota.from_dict(d.get("quota", {})),
+        )
+
+
+# ── Unstructured compatibility ──
+
+@dataclass
+class ElementMetadata:
+    filename: str = ""
+    filetype: str = ""
+    category_depth: int = 0
+    image_mime_type: str = ""
+    text_as_html: str = ""
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "ElementMetadata":
+        return cls(
+            filename=d.get("filename", ""),
+            filetype=d.get("filetype", ""),
+            category_depth=d.get("category_depth", 0),
+            image_mime_type=d.get("image_mime_type", ""),
+            text_as_html=d.get("text_as_html", ""),
+        )
+
+
+@dataclass
+class Element:
+    type: str = ""
+    element_id: str = ""
+    text: str = ""
+    metadata: ElementMetadata = field(default_factory=ElementMetadata)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Element":
+        return cls(
+            type=d.get("type", ""),
+            element_id=d.get("element_id", ""),
+            text=d.get("text", ""),
+            metadata=ElementMetadata.from_dict(d.get("metadata", {})),
+        )

ailang_parse-0.1.0.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: ailang-parse
+Version: 0.1.0
+Summary: Python client for the AILANG Parse document parsing API
+Project-URL: Homepage, https://www.sunholo.com/docparse
+Project-URL: Repository, https://github.com/sunholo-data/docparse
+Project-URL: Documentation, https://www.sunholo.com/docparse/api.html
+Author-email: Sunholo <dev@sunholo.com>
+License-Expression: Apache-2.0
+Keywords: ailang,ailang-parse,docparse,document-parsing,office-parser,unstructured
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.20
+Provides-Extra: async
+Requires-Dist: httpx>=0.24; extra == 'async'
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AILANG Parse Python SDK
+
+Python client for the [AILANG Parse](https://www.sunholo.com/docparse) document parsing API. Parse 13 formats, generate 8 — zero dependencies for Office, pluggable AI for PDFs.
+
+## Install
+
+```bash
+pip install ailang-parse
+```
+
+## Quick Start
+
+```python
+from ailang_parse import DocParse
+
+client = DocParse(api_key="dp_your_key_here")
+
+# Parse a document
+result = client.parse("report.docx")
+print(f"{len(result.blocks)} blocks, format: {result.format}")
+
+for block in result.blocks:
+    if block.type == "heading":
+        print(f"  H{block.level}: {block.text}")
+    elif block.type == "table":
+        print(f"  Table: {len(block.headers)} cols, {len(block.rows)} rows")
+    elif block.type == "change":
+        print(f"  {block.change_type} by {block.author}: {block.text}")
+    else:
+        print(f"  {block.type}: {block.text[:80]}")
+```
+
+## Parse Documents
+
+```python
+# Parse with different output formats
+result = client.parse("report.docx")                        # Block ADT (default)
+result = client.parse("report.docx", output_format="markdown")  # Markdown
+result = client.parse("report.docx", output_format="html")      # HTML
+
+# Access structured data
+print(result.status)          # "success"
+print(result.filename)        # "report.docx"
+print(result.format)          # "zip-office"
+print(result.blocks)          # List[Block]
+print(result.metadata.title)  # Document title
+print(result.metadata.author) # Document author
+print(result.summary.tables)  # Number of tables found
+```
+
+## Supported Formats
+
+```python
+formats = client.formats()
+print(formats.parse)       # ['docx', 'pptx', 'xlsx', 'odt', 'odp', 'ods', 'html', 'md', 'csv', 'epub', 'pdf', 'png', 'jpg']
+print(formats.generate)    # ['docx', 'pptx', 'xlsx', 'odt', 'odp', 'ods', 'html', 'md']
+print(formats.ai_required) # ['pdf', 'png', 'jpg', 'gif', 'bmp', 'tiff']
+```
+
+## Block Types
+
+AILANG Parse returns 9 block types:
+
+| Type | Fields | Description |
+|------|--------|-------------|
+| `text` | `text`, `style`, `level` | Paragraphs, code blocks |
+| `heading` | `text`, `level` (1-6) | Document headings |
+| `table` | `headers`, `rows` | Tables with merge tracking |
+| `list` | `items`, `ordered` | Ordered/unordered lists |
+| `image` | `description`, `mime`, `data_length` | Embedded images |
+| `audio` | `transcription`, `mime` | Audio transcriptions |
+| `video` | `description`, `mime` | Video descriptions |
+| `section` | `kind`, `children` | Slides, sheets, headers/footers |
+| `change` | `change_type`, `author`, `date`, `text` | Track changes |
+
+### Table cells
+
+Table cells can be simple strings or merged cells:
+
+```python
+for block in result.blocks:
+    if block.type == "table":
+        for cell in block.headers:
+            print(f"  {cell.text} (colspan={cell.col_span}, merged={cell.merged})")
+```
+
+### Nested sections
+
+Section blocks contain child blocks (slides, sheets, headers/footers):
+
+```python
+for block in result.blocks:
+    if block.type == "section":
+        print(f"Section: {block.kind}")  # "slide", "sheet", "header", "footer", etc.
+        for child in block.children:
+            print(f"  {child.type}: {child.text[:50]}")
+```
+
+## API Key Management
+
+Key generation uses the device auth flow (v0.10.0+). Direct generation is no longer available.
+
+```python
+# Get a key via device auth flow:
+#   1. POST /api/v1/auth/device       → {device_code, user_code, verification_url}
+#   2. User opens verification_url, signs in, clicks Approve
+#   3. POST /api/v1/auth/device/poll  → {api_key, tier}
+
+# Check usage
+usage = client.keys.usage(key_id="abc123", user_id="user123")
+print(f"Requests today: {usage.usage.requests_today} / {usage.quota.requests_per_day}")
+print(f"Pages this month: {usage.usage.pages_this_month} / {usage.quota.pages_per_month}")
+
+# Rotate (new key, old one revoked, same tier)
+new_key = client.keys.rotate(key_id="abc123", user_id="user123")
+print(new_key.key)  # New key
+
+# Revoke
+client.keys.revoke(key_id="abc123", user_id="user123")
+```
+
+## Migrating from Unstructured
+
+One import change:
+
+```python
+# Before
+from unstructured_client import UnstructuredClient
+client = UnstructuredClient(server_url="https://api.unstructured.io")
+
+# After
+from ailang_parse import UnstructuredClient
+client = UnstructuredClient(
+    server_url="https://ailang-dev-docparse-api-ejjw6zt3bq-ew.a.run.app"
+)
+
+# All existing code works unchanged
+elements = client.general.partition(file="report.docx")
+for el in elements:
+    print(f"{el.type}: {el.text[:80]}")
+    print(f"  metadata: {el.metadata.filename}")
+```
+
+## Error Handling
+
+```python
+from ailang_parse import DocParse, DocParseError, AuthError, QuotaError
+
+client = DocParse(api_key="dp_invalid")
+
+try:
+    result = client.parse("file.docx")
+except AuthError as e:
+    print(f"Bad key: {e}")           # 401
+except QuotaError as e:
+    print(f"Quota exceeded: {e}")    # 429
+except DocParseError as e:
+    print(f"API error ({e.status_code}): {e}")
+```
+
+## Configuration
+
+```python
+client = DocParse(
+    api_key="dp_your_key",
+    base_url="https://your-deployment.run.app",  # Custom endpoint
+    timeout=120,                                   # Request timeout (seconds)
+)
+```
+
+## Links
+
+- [AILANG Parse Website](https://www.sunholo.com/docparse)
+- [API Documentation](https://www.sunholo.com/docparse/api.html)
+- [GitHub](https://github.com/sunholo-data/docparse)
+- [Swagger UI](https://ailang-dev-docparse-api-ejjw6zt3bq-ew.a.run.app/api/_meta/docs)

ailang_parse-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+ailang_parse/__init__.py,sha256=wO-cRBvtje_TRbQMklxaFI4Rm2J-lxfFX3Ox2WUNzuQ,1087
+ailang_parse/client.py,sha256=YOQjjGhFH5I6H_5aq9Qd2iAN8Oi1BMPDanGt3n2CG8k,3073
+ailang_parse/compat.py,sha256=PUwSRtp5kIiUr2UKrVifHwTWKfhHNQFnR6a5o1AClZ4,2638
+ailang_parse/keys.py,sha256=lq1b5FWBJYGnzZKUQVAkv4eqlD9hpfwTeW1h20w0qzU,2039
+ailang_parse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ailang_parse/types.py,sha256=erbSKl1g4C6Aj_NeUomdPTV3isirRUEXh1X5uNGTTTM,8820
+ailang_parse-0.1.0.dist-info/METADATA,sha256=FClvYhwcyi5L1BzTtXPcXgFHuXIu5NcqVFpEba6cRYs,6393
+ailang_parse-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ailang_parse-0.1.0.dist-info/RECORD,,

ailang_parse-0.1.0.dist-info/WHEEL

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