doconda 0.1.0__py3-none-any.whl

doconda/__init__.py

@@ -0,0 +1,6 @@
+from ._client import Doconda, DocondaError, verify_webhook
+from ._tools import Tool
+
+# ===== Public API =====
+
+__all__ = ["Doconda", "DocondaError", "Tool", "verify_webhook"]

doconda/_client.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import re
+import time
+import uuid
+from collections.abc import Iterator, Mapping
+from pathlib import Path
+from typing import IO, Any, Union
+from urllib.parse import quote
+
+import httpx
+
+# ===== Types =====
+
+FileLike = Union[str, bytes, os.PathLike, IO[bytes]]
+
+# ===== Constants =====
+
+TERMINAL = {"ready", "ready_with_warnings", "needs_review", "failed", "canceled"}
+TERMINAL_EVENTS = {"document.ready", "document.failed", "document.canceled"}
+TIMEOUT = httpx.Timeout(60.0, read=600.0)
+STREAM_TIMEOUT = httpx.Timeout(60.0, read=None)
+
+# ===== Helpers =====
+
+
+def _sse(response: httpx.Response) -> Iterator[dict]:
+    data: list[str] = []
+    for line in response.iter_lines():
+        if not line:
+            if data:
+                yield json.loads("\n".join(data))
+            data = []
+        elif line.startswith("data:"):
+            data.append(line[5:].removeprefix(" "))
+    if data:
+        yield json.loads("\n".join(data))
+
+
+def _read(file: FileLike, filename: str | None) -> tuple[bytes, str]:
+    if isinstance(file, bytes):
+        if not filename:
+            raise ValueError("Doconda: pass filename (with its extension) when uploading bytes.")
+        return file, filename
+    if isinstance(file, (str, os.PathLike)):
+        path = Path(file)
+        return path.read_bytes(), filename or path.name
+    name = filename or Path(getattr(file, "name", "") or "").name
+    if not name:
+        raise ValueError("Doconda: pass filename (with its extension) for this file object.")
+    return file.read(), name
+
+
+def _file_input(file: FileLike | Mapping[str, str], filename: str | None) -> Any:
+    if isinstance(file, Mapping):
+        return dict(file)
+    if isinstance(file, str) and re.match(r"^(file|doc)_", file):
+        return file
+    if isinstance(file, str) and re.match(r"^https?://", file):
+        return {"url": file, **({"filename": filename} if filename else {})}
+    data, name = _read(file, filename)
+    return {"data": base64.b64encode(data).decode(), "filename": name}
+
+
+def _query(params: Mapping[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in params.items() if v is not None}
+
+
+# ===== Public API =====
+
+
+class DocondaError(Exception):
+    def __init__(self, status: int, body: Any):
+        body = body if isinstance(body, dict) else {}
+        super().__init__(body.get("title") or f"Doconda API answered {status}")
+        self.status = status
+        self.code = body.get("code") or "http_error"
+        self.request_id = body.get("request_id")
+        self.errors = body.get("errors") or []
+
+
+class Doconda:
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        max_retries: int = 2,
+        http_client: httpx.Client | None = None,
+    ):
+        key = api_key or os.environ.get("DOCONDA_API_KEY")
+        if not key:
+            raise ValueError("Doconda: pass api_key or set DOCONDA_API_KEY.")
+        self.base_url = (
+            base_url or os.environ.get("DOCONDA_BASE_URL") or "https://api.eu.doconda.com/v1"
+        ).rstrip("/")
+        self.max_retries = max_retries
+        self._key = key
+        self._http = http_client or httpx.Client(timeout=TIMEOUT)
+        self.documents = Documents(self)
+        self.files = Files(self)
+        self.webhooks = Webhooks(self)
+
+    def tools(self, *, local_files: bool = False) -> list:
+        from ._tools import doconda_tools
+
+        return doconda_tools(self, local_files=local_files)
+
+    def extract(self, file: FileLike | Mapping[str, str], *, filename: str | None = None) -> dict:
+        result = self.json("POST", "/extract", json={"file": _file_input(file, filename)})
+        while "markdown" not in result:
+            time.sleep(2)
+            result = self.json("GET", f"/extract/{result['id']}")
+        return result
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any = None,
+        files: Any = None,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+        stream: bool = False,
+    ) -> httpx.Response:
+        all_headers = {"authorization": f"Bearer {self._key}", **(headers or {})}
+        for attempt in range(self.max_retries + 1):
+            try:
+                request = self._http.build_request(
+                    method,
+                    f"{self.base_url}{path}",
+                    json=json,
+                    files=files,
+                    params=params,
+                    headers=all_headers,
+                    timeout=STREAM_TIMEOUT if stream else self._http.timeout,
+                )
+                response = self._http.send(request, stream=stream)
+            except httpx.TransportError:
+                if attempt >= self.max_retries:
+                    raise
+                time.sleep(0.5 * 2**attempt)
+                continue
+            if response.is_success:
+                return response
+            if stream:
+                response.read()
+            retryable = response.status_code == 429 or response.status_code >= 500
+            if not retryable or attempt >= self.max_retries:
+                try:
+                    body = response.json()
+                except ValueError:
+                    body = None
+                raise DocondaError(response.status_code, body)
+            wait = response.headers.get("retry-after")
+            time.sleep(float(wait) if wait and wait.isdigit() else 0.5 * 2**attempt)
+        raise AssertionError("unreachable")
+
+    def json(self, method: str, path: str, **kwargs: Any) -> Any:
+        response = self.request(method, path, **kwargs)
+        return None if response.status_code == 204 else response.json()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+
+class Documents:
+    def __init__(self, client: Doconda):
+        self._c = client
+
+    def create(self, *, idempotency_key: str | None = None, **body: Any) -> dict:
+        doc = self._post(body, idempotency_key)
+        return doc if doc["status"] in TERMINAL else self.wait(doc["id"])
+
+    def create_in_background(self, *, idempotency_key: str | None = None, **body: Any) -> dict:
+        return self._post({**body, "background": True}, idempotency_key)
+
+    def stream(self, *, idempotency_key: str | None = None, **body: Any) -> Iterator[dict]:
+        response = self._c.request(
+            "POST",
+            "/documents",
+            json={**body, "stream": True},
+            headers={"idempotency-key": idempotency_key or str(uuid.uuid4()), "accept": "text/event-stream"},
+            stream=True,
+        )
+        try:
+            yield from _sse(response)
+        finally:
+            response.close()
+
+    def get(self, document_id: str) -> dict:
+        return self._c.json("GET", f"/documents/{document_id}")
+
+    def page(self, *, limit: int | None = None, cursor: str | None = None, status: str | None = None) -> dict:
+        return self._c.json(
+            "GET", "/documents", params=_query({"limit": limit, "cursor": cursor, "status": status})
+        )
+
+    def list(self, *, status: str | None = None) -> Iterator[dict]:
+        cursor = None
+        while True:
+            page = self.page(limit=100, cursor=cursor, status=status)
+            yield from page["data"]
+            cursor = page.get("next_cursor")
+            if not cursor:
+                return
+
+    def cancel(self, document_id: str) -> dict:
+        return self._c.json(
+            "POST", f"/documents/{document_id}/cancel", headers={"idempotency-key": str(uuid.uuid4())}
+        )
+
+    def delete(self, document_id: str) -> None:
+        self._c.json("DELETE", f"/documents/{document_id}")
+
+    def events(self, document_id: str, *, after: int = 0) -> Iterator[dict]:
+        response = self._c.request(
+            "GET", f"/documents/{document_id}/events", params=_query({"after": after or None}), stream=True
+        )
+        try:
+            yield from _sse(response)
+        finally:
+            response.close()
+
+    def wait(self, document_id: str) -> dict:
+        after = 0
+        while True:
+            for event in self.events(document_id, after=after):
+                after = event["sequence"]
+                if event["type"] in TERMINAL_EVENTS:
+                    return self.get(document_id)
+            doc = self.get(document_id)
+            if doc["status"] in TERMINAL:
+                return doc
+
+    def outputs(self, document_id: str) -> list:
+        return self._c.json("GET", f"/documents/{document_id}/outputs")["data"]
+
+    def download(self, document_id: str, kind: str) -> bytes:
+        output = next((o for o in self.outputs(document_id) if o["kind"] == kind), None)
+        if output is None:
+            raise ValueError(f"Doconda: document {document_id} has no {kind}.")
+        response = httpx.get(output["url"], timeout=TIMEOUT, follow_redirects=True)
+        response.raise_for_status()
+        return response.content
+
+    def report(self, document_id: str) -> dict:
+        return self._c.json("GET", f"/documents/{document_id}/report")
+
+    def data(self, document_id: str, collection: str | None = None) -> list:
+        path = f"/documents/{document_id}/data" + (f"/{quote(collection, safe='')}" if collection else "")
+        return self._c.json("GET", path)["data"]
+
+    def _post(self, body: dict, idempotency_key: str | None) -> dict:
+        return self._c.json(
+            "POST", "/documents", json=body, headers={"idempotency-key": idempotency_key or str(uuid.uuid4())}
+        )
+
+
+class Files:
+    def __init__(self, client: Doconda):
+        self._c = client
+
+    def upload(self, file: FileLike, filename: str | None = None) -> dict:
+        data, name = _read(file, filename)
+        return self._c.json("POST", "/files", files={"file": (name, data)})
+
+    def get(self, file_id: str) -> dict:
+        return self._c.json("GET", f"/files/{file_id}")
+
+    def delete(self, file_id: str) -> None:
+        self._c.json("DELETE", f"/files/{file_id}")
+
+
+class Webhooks:
+    def __init__(self, client: Doconda):
+        self._c = client
+
+    def create(self, url: str, *, event_types: list[str] | None = None) -> dict:
+        return self._c.json(
+            "POST", "/webhook-endpoints", json=_query({"url": url, "event_types": event_types})
+        )
+
+    def list(self) -> list:
+        return self._c.json("GET", "/webhook-endpoints")["data"]
+
+    def delete(self, endpoint_id: str) -> None:
+        self._c.json("DELETE", f"/webhook-endpoints/{endpoint_id}")
+
+
+def verify_webhook(
+    body: str | bytes, headers: Mapping[str, str], secret: str, tolerance_seconds: int = 300
+) -> dict:
+    lower = {k.lower(): v for k, v in headers.items()}
+    msg_id, timestamp, signatures = (
+        lower.get(h) for h in ("webhook-id", "webhook-timestamp", "webhook-signature")
+    )
+    if not msg_id or not timestamp or not signatures:
+        raise ValueError("Doconda webhook: missing webhook-id, -timestamp or -signature.")
+    if abs(time.time() - int(timestamp)) > tolerance_seconds:
+        raise ValueError("Doconda webhook: the timestamp is too old or in the future.")
+    text = body.decode() if isinstance(body, bytes) else body
+    key = base64.b64decode(secret.removeprefix("whsec_"))
+    mac = hmac.new(key, f"{msg_id}.{timestamp}.{text}".encode(), hashlib.sha256).digest()
+    expected = base64.b64encode(mac).decode()
+    if not any(s.startswith("v1,") and hmac.compare_digest(s[3:], expected) for s in signatures.split(" ")):
+        raise ValueError("Doconda webhook: the signature does not match.")
+    return json.loads(text)

doconda/_tools.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable
+from urllib.parse import urlparse
+
+import httpx
+
+if TYPE_CHECKING:
+    from ._client import Doconda
+
+# ===== Types =====
+
+
+@dataclass(frozen=True)
+class Tool:
+    name: str
+    description: str
+    input_schema: dict
+    run: Callable[[dict], Any]
+
+    def __call__(self, **kwargs: Any) -> Any:
+        return self.run(kwargs)
+
+
+# ===== Constants =====
+
+FORMATS = ["docx", "pdf", "pptx", "xlsx", "artifact"]
+
+# ===== Helpers =====
+
+
+def _text(description: str) -> dict:
+    return {"type": "string", "description": description}
+
+
+def _object(properties: dict, required: list[str] | None = None) -> dict:
+    return {
+        "type": "object",
+        "properties": properties,
+        **({"required": required} if required else {}),
+        "additionalProperties": False,
+    }
+
+
+def _summary(doc: dict) -> dict:
+    hosted = doc.get("retention") != "none"
+    links = {
+        ("page" if o["kind"] == "html" and hosted else o["kind"]): o["url"]
+        for o in doc.get("outputs") or []
+        if o["kind"] != "preview"
+    }
+    out: dict[str, Any] = {"id": doc["id"]}
+    if doc.get("name"):
+        out["name"] = doc["name"]
+    out["format"] = doc.get("format")
+    out["status"] = doc["status"]
+    if doc.get("error"):
+        out["error"] = doc["error"]["message"]
+    if doc.get("pages"):
+        out["pages"] = doc["pages"]
+    if links:
+        out["links"] = links
+        out["links_note"] = (
+            "The page works until the document expires (`expires_at`); file links expire in 5 minutes: "
+            "call get_document for fresh ones."
+            if "page" in links
+            else "With retention `none`: `html` is the page for the user to download (deleted in 15 minutes); "
+            "it keeps data in each visitor's browser."
+            if "html" in links
+            else "Links expire in 5 minutes: call get_document for fresh ones."
+        )
+    if doc.get("style_unsupported"):
+        out["style_not_applied"] = doc["style_unsupported"]
+    summary = doc.get("validation_summary") or {}
+    if summary.get("errors") or summary.get("warnings"):
+        out["review"] = (
+            f"{summary['errors']} problems and {summary['warnings']} warnings left; see get_report"
+        )
+    return out
+
+
+# ===== Public API =====
+
+
+def doconda_tools(doconda: Doconda, *, local_files: bool = False) -> list[Tool]:
+    def create_document(a: dict) -> dict:
+        body: dict[str, Any] = {}
+        for key in ("format", "prompt", "style", "name", "retention"):
+            if a.get(key):
+                body[key] = a[key]
+        if a.get("markdown"):
+            body["content"] = {"markdown": a["markdown"]}
+        if a.get("source_file_ids"):
+            body["sources"] = [str(i) for i in a["source_file_ids"]]
+        if a.get("data"):
+            body["artifact"] = {"storage": a["data"]}
+        return _summary(doconda.documents.create(**body))
+
+    def upload_file(a: dict) -> dict:
+        filename = a.get("filename") or ""
+        if a.get("path") and local_files:
+            path = Path(a["path"])
+            data, filename = path.read_bytes(), filename or path.name
+        elif a.get("url"):
+            response = httpx.get(a["url"], follow_redirects=True, timeout=60)
+            if not response.is_success:
+                raise ValueError(f"Could not download {a['url']} ({response.status_code}).")
+            data, filename = response.content, filename or Path(urlparse(a["url"]).path).name or "file"
+        elif a.get("content_base64"):
+            data = base64.b64decode(a["content_base64"])
+        else:
+            raise ValueError(
+                "Give path, url or content_base64." if local_files else "Give url or content_base64."
+            )
+        if not filename:
+            raise ValueError("Give filename (with its extension).")
+        file = doconda.files.upload(data, filename)
+        return {"file_id": file["id"], "filename": file["filename"], "pages": file.get("pages")}
+
+    def list_documents(a: dict) -> list:
+        page = doconda.documents.page(limit=min(100, max(1, int(a.get("limit") or 20))))
+        return [
+            {
+                "id": d["id"],
+                **({"name": d["name"]} if d.get("name") else {}),
+                "operation": d.get("operation"),
+                "type": d.get("type"),
+                "status": d["status"],
+                "created_at": d.get("created_at"),
+            }
+            for d in page["data"]
+        ]
+
+    def get_report(a: dict) -> dict:
+        r = doconda.documents.report(a["document_id"])
+        out = {
+            "problems_left": [{"severity": i["severity"], "message": i["message"]} for i in r["issues"]],
+            "fixes": len(r.get("ledger") or []),
+        }
+        if r.get("edits"):
+            out["edits"] = r["edits"]
+        return out
+
+    upload_properties = {
+        **({"path": _text("Absolute path of the file on this computer.")} if local_files else {}),
+        "url": _text("A public URL to download the file from."),
+        "content_base64": _text("The file's bytes in base64 (for small files)."),
+        "filename": _text("Its name with extension, e.g. contract.docx. Needed with content_base64."),
+    }
+    file_id = _text("From upload_file, or the id of a document Doconda made (list_documents).")
+    return [
+        Tool(
+            "create_document",
+            "Create a finished document: Word, PDF, PowerPoint, Excel or an artifact (a web page with its own "
+            "shared database, e.g. a poll or a team checklist). Choose only the format: Doconda works out what kind "
+            "of document it is (contract, letter, report…) from the request. Give `prompt` to have it written, or "
+            "`markdown` with the content already written. Waits until it is ready and returns download links.",
+            _object(
+                {
+                    "format": {
+                        "type": "string",
+                        "enum": FORMATS,
+                        "description": "docx → Word (+ PDF); pdf → only the PDF; pptx → PowerPoint (+ PDF); xlsx → "
+                        "Excel (+ PDF); artifact → web page. If the user didn't say, leave it out and Doconda decides "
+                        "from the prompt.",
+                    },
+                    "prompt": _text(
+                        "What to write, in the user's words (topic, audience, length, tone). Formatting wishes too, "
+                        "e.g. 'blue centred headings, with a cover page'."
+                    ),
+                    "markdown": _text(
+                        "Content already written, in Markdown (instead of prompt). For an artifact, the content its "
+                        "page shows."
+                    ),
+                    "style": _text(
+                        "Optional: the look in plain words, e.g. 'blue centred headings, Lora font, page numbers, "
+                        "table of contents'."
+                    ),
+                    "name": _text(
+                        "Optional: a name to find it later, e.g. 'Contrato piso Malasaña'. It also names the files."
+                    ),
+                    "source_file_ids": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Uploaded files (upload_file) or documents already made (their id, from "
+                        "list_documents): documents to base the text on (up to 5, with prompt) and pictures to put in "
+                        "the document (up to 10; with markdown, refer to them as ![caption](img:1), the first picture).",
+                    },
+                    "data": {
+                        "type": "string",
+                        "enum": ["shared", "local"],
+                        "description": "Artifacts only. shared (default): everyone with the link sees the same data "
+                        "(polls, team lists). local: each visitor keeps their own in their browser (calculators, "
+                        "personal checklists). With retention none, only local.",
+                    },
+                    "retention": {
+                        "type": "string",
+                        "enum": ["none", "1d", "7d", "30d", "90d"],
+                        "description": "Optional: how long Doconda keeps it once finished (none = 15 minutes). Without "
+                        "it, the project's retention (30 days unless changed). The user should save the file before "
+                        "then.",
+                    },
+                }
+            ),
+            create_document,
+        ),
+        Tool(
+            "upload_file",
+            "Upload a file (Word, PDF, PowerPoint, Excel — also the old .doc, .ppt and .xls —, TXT, Markdown, or a "
+            "PNG, JPEG, GIF or WebP picture; up to 20 MB) to review or edit it, or to use it as a source. Returns its "
+            "file_id."
+            + (
+                " Give `path` for a file on this computer."
+                if local_files
+                else " Give `url` (public) or `content_base64`."
+            ),
+            _object(upload_properties),
+            upload_file,
+        ),
+        Tool(
+            "review_document",
+            "Check an uploaded Word, PowerPoint, Excel or PDF file (also .doc, .ppt, .xls) for problems and fix the "
+            "safe ones without touching the content, no AI: tables off the page, split signatures and broken "
+            "numbering in Word; text overflowing its box or shapes off the slide in PowerPoint; formula errors, "
+            "numbers stored as text or sheets too wide to print in Excel; scanned pages without text, missing title "
+            "or language in PDF; amounts in words that don't match the figures in all of them. Files with macros are "
+            "rejected; other dangerous content (external links and pictures, embedded files, automatic actions…) is "
+            "removed. Returns the fixed file (old formats come back as .docx/.pptx/.xlsx) and what was found.",
+            _object({"file_id": file_id}, ["file_id"]),
+            lambda a: _summary(doconda.documents.create(operation="review", file=a["file_id"])),
+        ),
+        Tool(
+            "edit_document",
+            "Change an uploaded Word, PowerPoint, Excel or PDF file as asked (e.g. 'blue headings and add a "
+            "confidentiality clause'). Only what is asked changes; the rest stays identical. Returns the new file "
+            "and a link to the report of every change.",
+            _object(
+                {"file_id": file_id, "instructions": _text("What to change, in the user's words.")},
+                ["file_id", "instructions"],
+            ),
+            lambda a: _summary(
+                doconda.documents.create(operation="edit", file=a["file_id"], prompt=a["instructions"])
+            ),
+        ),
+        Tool(
+            "list_documents",
+            "The latest documents made in this project (newest first), with their id and name. Use an id as file_id "
+            "to review, edit or read one, or in source_file_ids to create from it.",
+            _object({"limit": {"type": "number", "description": "How many, 1–100 (default 20)."}}),
+            list_documents,
+        ),
+        Tool(
+            "get_document",
+            "A document's status and fresh download links (they expire after 5 minutes).",
+            _object({"document_id": _text("doc_…")}, ["document_id"]),
+            lambda a: _summary(doconda.documents.get(a["document_id"])),
+        ),
+        Tool(
+            "get_report",
+            "What a review or edit found and did: problems left, fixes applied or rejected (and why), and for edits "
+            "every change with the text before and after.",
+            _object({"document_id": _text("doc_…")}, ["document_id"]),
+            get_report,
+        ),
+        Tool(
+            "read_artifact_data",
+            "What people have saved in an artifact's page (e.g. poll votes): its collections, or one collection's "
+            "records, newest first.",
+            _object(
+                {
+                    "document_id": _text("The artifact's doc_… id."),
+                    "collection": _text(
+                        "Optional: one collection's records instead of the list of collections."
+                    ),
+                },
+                ["document_id"],
+            ),
+            lambda a: doconda.documents.data(a["document_id"], a.get("collection")),
+        ),
+    ]

doconda-0.1.0.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.5
+Name: doconda
+Version: 0.1.0
+Summary: Python SDK for Doconda: generate, review and edit Word, PowerPoint, Excel and PDF documents from AI agents (Amazon Bedrock, Vertex AI, OpenAI, Claude, LangChain).
+Project-URL: Homepage, https://doconda.com
+Project-URL: Documentation, https://docs.doconda.com/en/sdk/python
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,anthropic,bedrock,document-generation,docx,excel,langchain,llm,mcp,openai,pdf,powerpoint,pptx,tools,vertex-ai,word,xlsx
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# doconda
+
+Generate, review and edit **Word (DOCX), PowerPoint (PPTX), Excel (XLSX) and PDF** documents from your AI agent or chatbot, with one call. Editable files with real Word styles, reviewed before they are delivered.
+
+Use it when your agent has to hand the user a document and you don't want to maintain python-docx, python-pptx, openpyxl or templates. Works with Amazon Bedrock, Vertex AI, OpenAI, Claude, Gemini, LangChain, CrewAI and any model with tool calling.
+
+```bash
+pip install doconda
+```
+
+```python
+from doconda import Doconda
+
+doconda = Doconda()  # reads DOCONDA_API_KEY
+doc = doconda.documents.create(format="docx", prompt="Report on the housing law")
+print(doc["outputs"])  # links to the Word file and the PDF
+
+open("report.docx", "wb").write(doconda.documents.download(doc["id"], "docx"))
+```
+
+## As tools for your agent
+
+`doconda.tools()` returns ready-made tools (name, description, JSON Schema, `run`) to create, review and edit documents. With Amazon Bedrock (Converse API):
+
+```python
+import json
+import boto3
+from doconda import Doconda
+
+bedrock = boto3.client("bedrock-runtime")
+tools = Doconda().tools()
+tool_config = {
+    "tools": [
+        {"toolSpec": {"name": t.name, "description": t.description, "inputSchema": {"json": t.input_schema}}}
+        for t in tools
+    ]
+}
+messages = [{"role": "user", "content": [{"text": "Make an Excel with the event budget"}]}]
+
+while True:
+    res = bedrock.converse(modelId=MODEL_ID, messages=messages, toolConfig=tool_config)
+    message = res["output"]["message"]
+    messages.append(message)
+    if res["stopReason"] != "tool_use":
+        break
+    results = []
+    for block in message["content"]:
+        if "toolUse" in block:
+            use = block["toolUse"]
+            out = next(t for t in tools if t.name == use["name"]).run(use["input"])
+            results.append(
+                {"toolResult": {"toolUseId": use["toolUseId"], "content": [{"text": json.dumps(out)}]}}
+            )
+    messages.append({"role": "user", "content": results})
+```
+
+The same tools plug into Vertex AI / Gemini, OpenAI, Claude, LangChain or CrewAI: see the guides.
+
+## What else
+
+- `documents.create(operation="review", file=…)` and `operation="edit"`: review and fix, or change, an existing Word, PowerPoint, Excel or PDF.
+- `documents.stream(…)`: the document's events as they happen.
+- `extract(file)`: any file to Markdown for your model (free).
+- `files.upload(path_or_bytes)`, `webhooks.create(url)` and `verify_webhook(body, headers, secret)`.
+
+Docs: https://docs.doconda.com/en/sdk/python · Guides per stack: https://docs.doconda.com/en/agents/introduction · Get an API key: https://doconda.com

doconda-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+doconda/__init__.py,sha256=R4JP9f2XWAeTXWmPFQcZQkdassvSgQUS-tilFw3cf88,175
+doconda/_client.py,sha256=RnhN3TUs0C4XJX4nkjoIcJTChg8btB_CumVkD2dMkTw,11779
+doconda/_tools.py,sha256=VJhFAu7uzvOcQcjU1YM88VMDyvLQEP0vkY5WE8JO4XE,12692
+doconda/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doconda-0.1.0.dist-info/METADATA,sha256=Rb3hJr_cFPyaAJnvpNM05ucU2awj2JF2Oc6yfmXLr5U,3448
+doconda-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+doconda-0.1.0.dist-info/licenses/LICENSE,sha256=t2QYZmJ9o6N4MsUtIaa9WO1rw7Lx80BoHcEwRLGNqrk,1064
+doconda-0.1.0.dist-info/RECORD,,

doconda-0.1.0.dist-info/WHEEL

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

doconda-0.1.0.dist-info/licenses/LICENSE

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