tabella-docs 2.0.1__py3-none-any.whl

tabella/read.py

@@ -0,0 +1,248 @@
+"""documents.read — read documents via anydoc (primary) + LiteParse (OCR fallback).
+
+Merged from the doc_read plugin. Dependencies (firecrawl-anydoc, liteparse) are
+now installed directly in the main Hermes venv — no subprocess/venv indirection.
+
+Architecture:
+  - Office formats (DOCX, DOC, XLSX, XLSB, PPTX, PPT, ODT, ODS, ODP, RTF,
+    EPUB, CSV) and text-based PDFs → anydoc (Rust, in-process, ~4ms,
+    GitHub-Flavored Markdown output).
+  - Scanned PDFs and images (JPG, PNG, TIFF) → LiteParse (Tesseract OCR).
+    Used when anydoc returns empty for a PDF, or for image files directly.
+  - Plain text (.txt, .md, .json, .py, .yaml, etc.) → direct file read.
+"""
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+# ── Format classification ────────────────────────────────────────────────────
+
+TEXT_SUFFIXES = {
+    ".txt", ".md", ".markdown", ".json", ".html", ".htm",
+    ".xml", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf",
+    ".rst", ".fountain", ".log", ".py", ".js", ".ts", ".css",
+}
+
+# Formats anydoc handles (office + text PDF).
+# Source: anydoc README — supported formats table.
+ANYDOC_SUFFIXES = {
+    ".doc", ".docx", ".docm",
+    ".ppt", ".pps", ".pot", ".pptx", ".pptm", ".ppsx", ".ppsm",
+    ".xls", ".xlsx", ".xlsm", ".xlsb",
+    ".odt", ".ods", ".odp",
+    ".rtf",
+    ".epub",
+    ".pdf",
+    ".csv",
+}
+
+# Image formats that need OCR (LiteParse + Tesseract).
+IMAGE_SUFFIXES = {
+    ".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".gif",
+}
+
+# ── anydoc (primary engine) ──────────────────────────────────────────────────
+
+def _run_anydoc(path: str, timeout: int = 60) -> str:
+    """Convert a document to Markdown using anydoc.
+
+    Returns the Markdown text, or empty string if the document has no
+    extractable text (e.g. scanned PDF without OCR).
+    """
+    import anydoc
+    md = anydoc.to_markdown(path)
+    return md or ""
+
+
+# ── LiteParse (OCR fallback) ─────────────────────────────────────────────────
+
+def _run_liteparse(path: str, extract_images: bool = True, timeout: int = 120) -> Dict[str, Any]:
+    """Parse a document using LiteParse with OCR enabled.
+
+    Used for scanned PDFs and images where anydoc returns empty.
+    """
+    from liteparse import LiteParse, ParseResult
+
+    parser = LiteParse(ocr_enabled=extract_images, output_format="text")
+    result = parser.parse(path)
+    text = ""
+    if isinstance(result, ParseResult):
+        text = getattr(result, "text", None) or getattr(result, "markdown", None) or ""
+    elif isinstance(result, str):
+        text = result
+    else:
+        text = str(result)
+    return {
+        "text": text,
+        "metadata": getattr(result, "metadata", {}) if hasattr(result, "metadata") else {},
+    }
+
+
+# ── Plain text fast path ─────────────────────────────────────────────────────
+
+def _read_text(path: str, max_chars: Optional[int] = None) -> str:
+    encodings = ["utf-8", "utf-8-sig", "latin-1"]
+    last_err = None
+    for enc in encodings:
+        try:
+            with open(path, "r", encoding=enc, errors="replace") as f:
+                text = f.read()
+                if max_chars:
+                    text = text[:max_chars]
+                return text
+        except Exception as e:
+            last_err = e
+    raise RuntimeError(f"Could not read text file: {last_err}")
+
+
+# ── Main dispatch ────────────────────────────────────────────────────────────
+
+def read(path: str, max_chars: Optional[int] = None, extract_images: bool = True, max_pages: Optional[int] = None) -> str:
+    """Extract text from a document.
+
+    Dispatch:
+      1. Plain text → direct file read (fast path)
+      2. Office formats + text PDFs → anydoc (Markdown output)
+      3. Images → LiteParse (OCR)
+      4. PDFs that anydoc returns empty → LiteParse (OCR fallback for scanned PDFs)
+    """
+    suffix = Path(path).suffix.lower()
+
+    # 1. Plain text fast path
+    if suffix in TEXT_SUFFIXES:
+        return _read_text(path, max_chars)
+
+    # 2. Images → LiteParse OCR directly
+    if suffix in IMAGE_SUFFIXES:
+        data = _run_liteparse(path, extract_images=extract_images)
+        text = data.get("text") or ""
+        if max_chars:
+            text = text[:max_chars]
+        return text
+
+    # 3. Office formats + PDFs → anydoc first
+    if suffix in ANYDOC_SUFFIXES or suffix not in TEXT_SUFFIXES:
+        text = ""
+        anydoc_error = None
+        try:
+            text = _run_anydoc(path)
+        except (RuntimeError, ImportError) as e:
+            anydoc_error = str(e)
+
+        # 4. If anydoc returned empty text (scanned PDF) or failed, try LiteParse OCR
+        if not text.strip():
+            try:
+                data = _run_liteparse(path, extract_images=extract_images)
+                text = data.get("text") or ""
+            except (RuntimeError, ImportError) as liteparse_err:
+                if anydoc_error:
+                    raise RuntimeError(f"anydoc failed: {anydoc_error}; liteparse fallback also failed: {liteparse_err}")
+                raise RuntimeError(f"both anydoc and liteparse returned no text. liteparse: {liteparse_err}")
+
+        if max_chars:
+            text = text[:max_chars]
+        return text
+
+    # Fallback: unknown format, try plain text read
+    return _read_text(path, max_chars)
+
+
+def read_meta(path: str) -> Dict[str, Any]:
+    """Extract metadata from a document."""
+    suffix = Path(path).suffix.lower()
+    if suffix in TEXT_SUFFIXES:
+        return {"path": path, "format": "text"}
+
+    # LiteParse has the richest metadata extraction (office + PDF + images).
+    try:
+        data = _run_liteparse(path, extract_images=False)
+        meta = data.get("metadata") or {}
+        meta["path"] = path
+        return meta
+    except Exception:
+        # LiteParse unavailable (e.g. its LibreOffice fallback missing for office
+        # formats). Fall back to filesystem-truth metadata rather than failing:
+        # callers get valid basics instead of a tool error.
+        import os
+
+        st = os.stat(path)
+        return {
+            "path": path,
+            "format": suffix.lstrip("."),
+            "size_bytes": st.st_size,
+            "mtime": st.st_mtime,
+        }
+
+
+# ── Hermes plugin registration ──
+
+def register(registry):
+    if registry is None:
+        return
+
+    def doc_read(path: str, max_chars: int = 1_000_000, extract_images: bool = True):
+        try:
+            text = read(path, max_chars=max_chars, extract_images=extract_images)
+            return {
+                "success": True,
+                "path": path,
+                "text": text,
+                "length": len(text),
+                "message": f"Read {len(text)} chars from {path}",
+            }
+        except Exception as e:
+            return {"success": False, "path": path, "error": f"{type(e).__name__}: {e}"}
+
+    def doc_read_meta(path: str):
+        try:
+            meta = read_meta(path)
+            return {"success": True, "path": path, "metadata": meta}
+        except Exception as e:
+            return {"success": False, "path": path, "error": f"{type(e).__name__}: {e}"}
+
+    registry.register_tool(
+        name="doc_read",
+        toolset="doc",
+        schema={
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Absolute path to the document.",
+                },
+                "max_chars": {
+                    "type": "integer",
+                    "description": "Maximum characters to return.",
+                    "default": 1_000_000,
+                },
+                "extract_images": {
+                    "type": "boolean",
+                    "description": "Extract text from images via OCR (LiteParse + Tesseract).",
+                    "default": True,
+                },
+            },
+            "required": ["path"],
+        },
+        handler=lambda args, **kw: json.dumps(doc_read(
+            args["path"],
+            max_chars=args.get("max_chars", 1_000_000),
+            extract_images=args.get("extract_images", True),
+        )),
+        description="Read and extract text from documents. Uses anydoc for office formats (DOCX, XLSX, PPTX, ODT, RTF, EPUB, PDF → Markdown) and LiteParse for OCR (scanned PDFs, images). Plain text files read directly.",
+    )
+    registry.register_tool(
+        name="doc_read_meta",
+        toolset="doc",
+        schema={
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Absolute path to the document.",
+                },
+            },
+            "required": ["path"],
+        },
+        handler=lambda args, **kw: json.dumps(doc_read_meta(args["path"])),
+        description="Read document metadata (PDF info, image EXIF, etc.) via LiteParse.",
+    )

tabella/utils.py

@@ -0,0 +1,43 @@
+"""Shared helpers for the documents plugin.
+
+Consolidates output-directory resolution that was previously duplicated in
+doc_convert and doc_create.
+"""
+
+import os
+from pathlib import Path
+
+
+def _get_output_dir() -> Path:
+    """Resolve output directory for documents.
+
+    Uses DOCS_OUTPUT_DIR env var if set, otherwise defaults to ~/Documents.
+    Fleet pCloud routing is handled by the document-routing skill, not here.
+    """
+    d = os.environ.get("DOCS_OUTPUT_DIR")
+    if d:
+        p = Path(d).expanduser()
+    else:
+        p = Path.home() / "Documents"
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _is_in_output_dir(path: Path) -> bool:
+    """Check if path is under the configured output directory."""
+    try:
+        resolved = path.expanduser().resolve()
+        user_dir = _get_output_dir()
+        return resolved != user_dir and user_dir in resolved.parents
+    except Exception:
+        return False
+
+
+def _resolve_output_dir(category: str = None) -> Path:
+    """Return output directory with optional category subfolder."""
+    base = _get_output_dir()
+    if category:
+        out = base / category
+        out.mkdir(parents=True, exist_ok=True)
+        return out
+    return base

tabella_docs-2.0.1.dist-info/METADATA

@@ -0,0 +1,315 @@
+Metadata-Version: 2.4
+Name: tabella-docs
+Version: 2.0.1
+Summary: Portable document lifecycle suite — create (.docx/.xlsx/.pptx/.pdf/.odt/.ods/.odp), convert (pandoc), and read (anydoc + LiteParse OCR) documents. Agent Plugins v1 compatible.
+Author-email: D Yiapanis <d@yiapanis.co>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/dyiapanis/tabella
+Project-URL: Source, https://github.com/dyiapanis/tabella
+Project-URL: Issues, https://github.com/dyiapanis/tabella/issues
+Keywords: documents,docx,xlsx,pptx,pdf,odt,pandoc,anydoc,document-generation,markdown,ocr,agent-plugins,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Office Suites
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: create
+Requires-Dist: python-docx<2.0,>=1.0; extra == "create"
+Requires-Dist: openpyxl<4.0,>=3.1; extra == "create"
+Requires-Dist: python-pptx<2.0,>=0.6; extra == "create"
+Requires-Dist: weasyprint<70.0,>=60.0; extra == "create"
+Requires-Dist: odfpy<2.0,>=1.4; extra == "create"
+Requires-Dist: Pillow<13.0,>=10.0; extra == "create"
+Requires-Dist: lxml<7.0,>=5.0; extra == "create"
+Provides-Extra: read
+Requires-Dist: firecrawl-anydoc<0.3.0,>=0.1.1; extra == "read"
+Requires-Dist: liteparse<3.0.0,>=2.0.0; extra == "read"
+Requires-Dist: PyMuPDF<2.0,>=1.24; extra == "read"
+Provides-Extra: convert
+Provides-Extra: all
+Requires-Dist: python-docx<2.0,>=1.0; extra == "all"
+Requires-Dist: openpyxl<4.0,>=3.1; extra == "all"
+Requires-Dist: python-pptx<2.0,>=0.6; extra == "all"
+Requires-Dist: weasyprint<70.0,>=60.0; extra == "all"
+Requires-Dist: odfpy<2.0,>=1.4; extra == "all"
+Requires-Dist: Pillow<13.0,>=10.0; extra == "all"
+Requires-Dist: lxml<7.0,>=5.0; extra == "all"
+Requires-Dist: firecrawl-anydoc<0.3.0,>=0.1.1; extra == "all"
+Requires-Dist: liteparse<3.0.0,>=2.0.0; extra == "all"
+Requires-Dist: PyMuPDF<2.0,>=1.24; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# tabella
+
+A portable document lifecycle suite: create, convert, and read documents
+from structured JSON or raw HTML/CSS.
+
+## Cross-Platform Compatibility
+
+This package conforms to the [Agent Plugins v1.0.0](https://agent-plugins.org/specification)
+specification. It works with any compatible AI agent client that supports
+MCP servers, including:
+
+- [Hermes Agent](https://hermes-agent.nousresearch.com)
+- [Cursor](https://cursor.com)
+- [Claude Desktop](https://claude.ai/download)
+- Any client that supports the Model Context Protocol
+
+### Three installation paths
+
+**Transports:** the plugin ships both.
+
+- **stdio (default)** — the declaring client spawns `mcp_server.py` itself
+  (Agent Plugins v1 lifecycle; `PLUGIN_ROOT`/`PLUGIN_DATA` injected by the
+  client). Nothing to run by hand.
+- **streamable-HTTP (self-host lane)** — for clients that prefer connecting
+  to a URL, run the server yourself:
+
+  ```bash
+  python3 scripts/mcp_http_server.py   # serves 127.0.0.1:8602
+  ```
+
+  First run bootstraps the dependency venv (or `scripts/setup.sh`);
+  `TABELLA_TOKEN` enables bearer auth. Then point an `mcp.json`
+  `streamable-http` entry at `http://127.0.0.1:8602/mcp`.
+
+
+
+**Agent Plugins v1 package** — clients that support the v1 spec auto-discover
+`plugin.json` + `mcp.json` from the repo root and launch the MCP server:
+
+```bash
+# Hermes Agent
+hermes plugins install dyiapanis/tabella --no-enable
+hermes plugins enable tabella
+
+# Other v1-compatible clients: follow your client's plugin installation instructions
+```
+
+**MCP server (manual)** — point any MCP-compatible client at the server directly:
+
+```json
+{
+  "mcpServers": {
+    "tabella": {
+      "type": "stdio",
+      "command": "python3",
+      "args": ["/path/to/tabella/mcp_server.py"]
+    }
+  }
+}
+```
+
+**pip install** — use the Python library directly:
+
+```bash
+pip install tabella-docs[all]
+```
+
+Or install only the modules you need:
+
+```bash
+pip install tabella-docs[create]    # python-docx, openpyxl, python-pptx, weasyprint, odfpy
+pip install tabella-docs[read]      # firecrawl-anydoc, liteparse, PyMuPDF
+pip install tabella-docs[convert]   # no python deps (needs system pandoc + texlive-xetex)
+```
+
+## Modules
+
+### Create
+
+Generate documents from structured JSON content or raw HTML/CSS:
+
+- **DOCX** — Word documents (python-docx)
+- **XLSX** — Spreadsheets (openpyxl)
+- **PPTX** — Presentations (python-pptx)
+- **PDF** — Print-ready documents and visual designs (WeasyPrint)
+  - Document-style: structured JSON → HTML → PDF
+  - Visual-style: raw HTML/CSS (Grid, Flexbox, gradients, themes) → PDF
+- **ODT/ODS/ODP** — OpenDocument formats (odfpy)
+
+Accepts plain strings (auto-normalized), HTML, or structured dicts with
+sections, sheets, slides, tables, images, and page breaks.
+
+### Convert
+
+Format conversion via pandoc + LaTeX (page size, margins, headers/footers
+configurable). **Pandoc 3.1 supports 44 input and 54 output formats** —
+`doc_convert` passes your `from`/`to` through, so all of them work. The
+everyday set:
+
+| Format | In | Out | Notes |
+|---|---|---|---|
+| Markdown (`.md`, variants) | ✅ | ✅ | gfm, commonmark, multimarkdown, strict… |
+| HTML | ✅ | ✅ | html4/html5, chunkedhtml |
+| DOCX (Word) | ✅ | ✅ | |
+| ODT | ✅ | ✅ | + `opendocument` |
+| PDF | ✅ | ✅ | in: text-based PDFs (pandoc's pdf reader); out: needs `pdflatex`/`xelatex` (texlive) — engine auto-selected |
+| LaTeX (`.tex`) | ✅ | ✅ | incl. beamer slides out |
+| RST | ✅ | ✅ | |
+| EPUB | ✅ | ✅ | out: epub2/epub3 |
+| CSV / TSV | ✅ | ✅ | out via markdown/AST route |
+| RTF | ✅ | ✅ | |
+| Plain text (`.txt`) | ✅ | ✅ | |
+| Org-mode, MediaWiki, Jira wiki, Textile, DocBook, FB2, OPML, IPynb, JATS | ✅ | ✅ | writers for most |
+| Typst / man / ms / texinfo / AsciiDoc | ✅ | ✅ | typst in+out |
+| Presentations | — | ✅ | beamer, revealjs, slidy, s5, dzslides (from any reader, Markdown especially) |
+| Pandoc AST (JSON) | ✅ | ✅ | for programmatic pipelines |
+
+Everything not in the table: if `pandoc --list-input-formats` /
+`--list-output-formats` lists it, `doc_convert` accepts it as-is — unknown
+extensions pass through untouched.
+
+### Read
+
+Extract text and metadata from any document:
+
+- **Office formats** (DOCX, DOC, XLSX, XLSB, PPTX, PPT, ODT, ODS, ODP, RTF,
+  EPUB, CSV) and **text-based PDFs** → GitHub-Flavored Markdown via
+  [anydoc](https://github.com/firecrawl/anydoc) (~4ms, in-process)
+- **Scanned PDFs** and **images** (JPG, PNG, TIFF) → OCR via
+  [LiteParse](https://github.com/run-llama/liteparse) (Tesseract)
+- **Plain text** (.txt, .md, .json, .py, .yaml, etc.) → direct file read
+- Returns structured Markdown (office formats) or plain text (OCR, plain text)
+
+## Prerequisites
+
+### Create module
+
+The create module uses a separate Python venv for heavy document libraries.
+Set `DOCS_VENV_PYTHON` to point to it:
+
+```bash
+# Create a dedicated venv
+python -m venv ~/.venvs/docs
+~/.venvs/docs/bin/pip install python-docx openpyxl python-pptx weasyprint odfpy Pillow lxml PyMuPDF firecrawl-anydoc liteparse
+```
+
+Or install the libraries into your main Python environment:
+
+```bash
+pip install tabella-docs[create]
+```
+
+### Read module
+
+```bash
+~/.venvs/docs/bin/pip install firecrawl-anydoc liteparse PyMuPDF
+```
+
+Or:
+
+```bash
+pip install tabella-docs[read]
+```
+
+### Convert module
+
+```bash
+pip install tabella-docs[convert]
+```
+
+Requires system-installed pandoc and a LaTeX engine:
+
+```bash
+# Debian/Ubuntu
+sudo apt install pandoc texlive-xetex
+
+# macOS
+brew install pandoc basictex
+
+# Arch
+sudo pacman -S pandoc texlive
+```
+
+### WeasyPrint system dependencies (PDF creation)
+
+```bash
+# Debian/Ubuntu
+sudo apt install libcairo2 libpango-1.0-0 libgdk-pixbuf-2.0-0
+
+# macOS
+brew install cairo pango gdk-pixbuf
+```
+
+## Installation from source
+
+```bash
+git clone https://github.com/dyiapanis/tabella.git
+cd tabella
+pip install -e ".[all]"
+```
+
+## Configuration
+
+| Variable | Purpose | Default |
+|----------|---------|---------|
+| `DOCS_VENV_PYTHON` | Python binary for document libraries | `PLUGIN_DATA/venv/bin/python` or `~/.venvs/docs/bin/python` |
+| `DOCS_OUTPUT_DIR` | Default output directory for generated documents | `~/Documents` |
+| `PLUGIN_DATA` | Client-managed data directory (set by v1 client) | — |
+| `PLUGIN_ROOT` | Plugin root directory (set by v1 client) | — |
+
+### Automatic bootstrap
+
+On first startup, the MCP server checks if the docs venv exists. If not,
+it runs `scripts/setup.sh` to create a venv in `PLUGIN_DATA` (provided by
+the v1 client) or `~/.venvs/docs` as fallback, and installs all dependencies:
+python-docx, openpyxl, python-pptx, weasyprint, odfpy, PyMuPDF,
+firecrawl-anydoc, liteparse.
+
+This means the v1 package is fully self-contained — no manual pip install
+required. The bootstrap runs once; subsequent startups use the existing venv.
+
+## Usage
+
+### Create a PDF from HTML/CSS
+
+```python
+from agent_docs.create import create_document
+
+result = create_document(
+    format="pdf",
+    content={"html": "<html><body><h1>Hello</h1></body></html>"},
+    output_path="/tmp/output.pdf",
+    options={"page_size": "A4"}
+)
+```
+
+### Read a DOCX file
+
+```python
+from agent_docs.read import read
+
+text = read("/path/to/document.docx")
+# Returns GitHub-Flavored Markdown
+```
+
+### Convert Markdown to PDF
+
+```python
+from agent_docs.convert import doc_convert
+
+result = doc_convert(
+    input_path="/path/to/input.md",
+    to_format="pdf",
+    output_path="/path/to/output.pdf"
+)
+```
+
+### Via MCP
+
+The bundled MCP server exposes five tools: `doc_read`, `doc_read_meta`,
+`doc_convert`, `doc_create_document`, `doc_edit_pdf`. Any MCP-compatible
+client can call these directly.
+
+## License
+
+MIT

tabella_docs-2.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+tabella/__init__.py,sha256=ZWesd1vh6548Mhzaph7RjCZLKpyvVHTcR5w3LblDcZo,1580
+tabella/convert.py,sha256=84a9V2IBjpZYNtnnTXCfGw15-DpczicEoUetOzi0GCg,6529
+tabella/create.py,sha256=uDIpK7slDakjJ3vXFbuOjfeZs14r5ja1JgnccEwPb2k,31105
+tabella/read.py,sha256=kJBYnLywYb3lYyfDyKPU2f3KxJC2Z5ogFQYMUSmOS2c,9423
+tabella/utils.py,sha256=m5hSj9Bep-GS1NOZ7NZk5MT3ZAElH6Q2uNIzMom3HR0,1216
+tabella_docs-2.0.1.dist-info/licenses/LICENSE,sha256=YY_7vguV9tONkLu76Y4S4Rhxkny4g2O-yY5pMq5KLqQ,1066
+tabella_docs-2.0.1.dist-info/METADATA,sha256=8XDi7ykrGyDoDMa0dZOK_F34owrKT1s26NkzQJ9kerg,10025
+tabella_docs-2.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+tabella_docs-2.0.1.dist-info/top_level.txt,sha256=ALebCE3nPaYfRNya0n5oiH6Llu4PJiiVRxuFHk0c9yo,8
+tabella_docs-2.0.1.dist-info/RECORD,,

tabella_docs-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tabella_docs-2.0.1.dist-info/licenses/LICENSE

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

tabella_docs-2.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+tabella