fastocr-mcp 0.1.0__py3-none-any.whl

fastocr_mcp/__init__.py

@@ -0,0 +1,6 @@
+"""FastOCR MCP server: OCR local PDFs from any MCP client."""
+
+from ._version import __version__
+from .server import create_server, main
+
+__all__ = ["__version__", "create_server", "main"]

fastocr_mcp/__main__.py

@@ -0,0 +1,3 @@
+from .server import main
+
+main()

fastocr_mcp/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

fastocr_mcp/server.py

@@ -0,0 +1,329 @@
+"""MCP server exposing the FastOCR Document OCR API as tools."""
+import json
+import tempfile
+from pathlib import Path
+from typing import Annotated, Any, Callable, Dict, Literal, Optional
+
+from fastocr_sdk import (
+    AsyncFastOCR,
+    AuthenticationError,
+    DocumentFailedError,
+    DocumentJob,
+    FastOCRError,
+    NotFoundError,
+    PollingTimeoutError,
+    RateLimitError,
+)
+from mcp.server.mcpserver import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
+from mcp.types import ToolAnnotations
+from pydantic import Field
+
+from ._version import __version__
+
+DOCS_URL = "https://fastocr.org/docs"
+KEYS_URL = "https://fastocr.org/developers/keys"
+BUY_PAGES_URL = f"{KEYS_URL}#buy-api-pages"
+MAX_INLINE_CHARS = 20_000
+# Stay under the 60 s request timeout many MCP clients use; longer documents are resumed with get_document.
+WAIT_SECONDS = 45.0
+
+ClientFactory = Callable[[], AsyncFastOCR]
+USER_AGENT = f"fastocr-mcp/{__version__}"
+
+
+def default_client() -> AsyncFastOCR:
+    """An SDK client whose User-Agent names this server, so API access logs can count MCP traffic."""
+    client = AsyncFastOCR()
+    sdk_agent = client._http.headers.get("User-Agent", "")
+    client._http.headers["User-Agent"] = f"{USER_AGENT} {sdk_agent}".strip()
+    return client
+
+INSTRUCTIONS = f"""\
+FastOCR extracts text from scanned PDFs and images and makes searchable PDFs, in 100+ languages.
+Use ocr_file for a local PDF, PNG, JPG, GIF, WebP or BMP file; pass an absolute path. Every processed
+page (an image is one page) uses one page of the account's FastOCR API allowance, so do not OCR the
+same file twice. The server reads the API key
+from the FASTOCR_API_KEY environment variable. Docs: {DOCS_URL}"""
+
+DocumentId = Annotated[str, Field(description="The document id returned by ocr_file or list_documents.")]
+InputPath = Annotated[str, Field(description="Absolute path to a local PDF, PNG, JPG, JPEG, GIF, WebP or BMP file.")]
+OcrOutput = Annotated[
+    Literal["text", "pdf"],
+    Field(description="'text' returns the extracted text; 'pdf' saves a searchable PDF with a text layer."),
+]
+OutputPath = Annotated[
+    Optional[str],
+    Field(description="Optional absolute path for the result file. An existing file there is replaced."),
+]
+
+
+def explain(error: FastOCRError) -> str:
+    """Turn an SDK error into a message an AI agent or a developer can act on."""
+    if isinstance(error, AuthenticationError):
+        return (
+            "FastOCR did not accept the API key, or none is set. Set FASTOCR_API_KEY in this MCP server's "
+            f"environment to a key from {KEYS_URL} (any signed-in account can create one "
+            "after accepting the API terms)."
+        )
+    if error.code == "buy_pages":
+        document = f" (document {error.document_id})" if isinstance(error, DocumentFailedError) else ""
+        return (
+            f"The FastOCR account is out of API pages{document}. Buy pages at {BUY_PAGES_URL}, "
+            "then run ocr_file again."
+        )
+    if error.code == "concurrency_limit":
+        return (
+            "Too many documents are already processing for this FastOCR account. Wait until one "
+            "finishes (check list_documents), then try again. Accounts with purchased API pages can "
+            f"process more documents at once: {KEYS_URL}"
+        )
+    if isinstance(error, RateLimitError):
+        wait = int(error.retry_after) if error.retry_after else 60
+        return f"FastOCR is rate limiting requests. Try again in {wait} seconds."
+    if isinstance(error, NotFoundError):
+        return "No document with that id exists in this FastOCR account."
+    if error.code == "document_processing":
+        return "The document is still processing and cannot be deleted yet. Try again when it has finished."
+    if isinstance(error, DocumentFailedError):
+        advice = "Trying again may work." if error.retryable else "Trying the same file again will not help."
+        return f"OCR failed for document {error.document_id} (code: {error.code}): {error.message} {advice}"
+    return f"FastOCR request failed: {error}. See {DOCS_URL}"
+
+
+def _summary(job: DocumentJob) -> Dict[str, Any]:
+    summary: Dict[str, Any] = {
+        "document_id": job.id,
+        "status": job.status,
+        "pages_total": job.pages_total,
+        "pages_billed": job.pages_billed,
+        "text_available": job.outputs.text_available,
+        "pdf_available": job.outputs.pdf_available,
+    }
+    if job.external_id:
+        summary["external_id"] = job.external_id
+    if job.error:
+        summary["error"] = {"code": job.error.code, "message": job.error.message, "retryable": job.error.retryable}
+    if job.is_failed:
+        summary["next_step"] = explain(_failure(job))
+    return summary
+
+
+def _partial_note(job: DocumentJob) -> str:
+    if not job.is_partial:
+        return ""
+    return (
+        f"\nNote: only {job.pages_billed} of {job.pages_total} pages were processed because the account "
+        f"ran out of API pages. Buy pages at {BUY_PAGES_URL} and run ocr_file again to process the whole file."
+    )
+
+
+def _beside(stem: Path, suffix: str) -> Path:
+    return stem.with_name(stem.name + suffix)
+
+
+def _write_text(path: Path, text: str) -> Path:
+    path = path.expanduser()
+    path.write_text(text, encoding="utf-8")
+    return path
+
+
+async def _deliver(
+    client: AsyncFastOCR,
+    job: DocumentJob,
+    output: str,
+    output_path: Optional[str],
+    default_stem: Path,
+) -> str:
+    header = f"Document {job.id}: {job.status}, {job.pages_billed} page(s) billed."
+    if output == "pdf":
+        if not job.outputs.pdf_available:
+            raise ToolError(f"Document {job.id} has no searchable PDF. Use output='text' instead.")
+        destination = Path(output_path).expanduser() if output_path else _beside(default_stem, ".searchable.pdf")
+        await client.documents.download_searchable_pdf(job.id, destination)
+        return f"{header}\nSearchable PDF saved to {destination}{_partial_note(job)}"
+
+    text = await client.documents.get_text(job.id)
+    saved = None
+    if output_path:
+        saved = _write_text(Path(output_path), text)
+    elif len(text) > MAX_INLINE_CHARS:
+        saved = _write_text(_beside(default_stem, ".ocr.txt"), text)
+    if len(text) > MAX_INLINE_CHARS:
+        return (
+            f"{header}{_partial_note(job)}\nThe text has {len(text)} characters; the first "
+            f"{MAX_INLINE_CHARS} are below. The full text is in {saved}.\n\n{text[:MAX_INLINE_CHARS]}"
+        )
+    where = f"\nFull text saved to {saved}." if saved else ""
+    return f"{header}{where}{_partial_note(job)}\n\n{text}"
+
+
+def _output_file(output_path: Optional[str], source: Optional[Path] = None) -> None:
+    if not output_path:
+        return
+    target = Path(output_path).expanduser()
+    if not target.is_absolute():
+        raise ToolError(f"output_path must be an absolute path, not '{output_path}'.")
+    if source and target.resolve() == source.resolve():
+        raise ToolError("output_path must differ from the input file.")
+
+
+SUPPORTED_SUFFIXES = (".pdf", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp")
+
+
+def _source(path: str) -> Path:
+    source = Path(path).expanduser()
+    if not source.is_absolute():
+        raise ToolError(f"Pass an absolute path to the file, not '{path}'.")
+    if not source.is_file():
+        raise ToolError(f"No file at {source}.")
+    if source.suffix.lower() not in SUPPORTED_SUFFIXES:
+        raise ToolError("FastOCR's API accepts PDF, PNG, JPG, JPEG, GIF, WebP and BMP files.")
+    return source
+
+
+def create_server(client_factory: ClientFactory = default_client) -> MCPServer:
+    server = MCPServer(
+        "fastocr",
+        title="FastOCR",
+        instructions=INSTRUCTIONS,
+        website_url=DOCS_URL,
+        version=__version__,
+    )
+
+    async def run(action: Callable[[AsyncFastOCR], Any]) -> Any:
+        try:
+            async with client_factory() as client:
+                return await action(client)
+        except FastOCRError as error:
+            raise ToolError(explain(error)) from error
+        except OSError as error:
+            raise ToolError(f"Could not read or write a local file: {error}") from error
+
+    async def ocr(path: str, output: str, output_path: Optional[str]) -> str:
+        source = _source(path)
+        _output_file(output_path, source)
+
+        async def action(client: AsyncFastOCR) -> str:
+            try:
+                job = await client.documents.process(source, timeout=WAIT_SECONDS)
+            except PollingTimeoutError as pending:
+                return (
+                    f"Document {pending.document_id} is still processing. Call get_document with "
+                    f"document_id='{pending.document_id}' and output='{output}' to wait for and fetch the result. "
+                    "Do not run ocr_file on the same file again."
+                )
+            return await _deliver(client, job, output, output_path, source.with_suffix(""))
+
+        result: str = await run(action)
+        return result
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=False, open_world_hint=True))
+    async def ocr_file(
+        path: InputPath,
+        output: OcrOutput = "text",
+        output_path: OutputPath = None,
+    ) -> str:
+        """OCR a local PDF or image with FastOCR and return its text or save a searchable PDF.
+
+        Uploads the file, runs OCR and waits up to 45 seconds. With output='text' the
+        text is returned; text longer than 20,000 characters is cut, and the full text is
+        written to output_path or to <file>.ocr.txt next to the input file. With
+        output='pdf' the searchable PDF is saved to output_path or to <file>.searchable.pdf
+        next to the input file. Either default file replaces an earlier result with the
+        same name. Each processed page uses one page of the account's API allowance; an
+        image is one page. Large documents take longer: then this returns a document id,
+        and get_document with the same output fetches the result. Never call ocr_file
+        again for that file, which bills it again.
+        """
+        return await ocr(path, output, output_path)
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=False, open_world_hint=True))
+    async def ocr_pdf(
+        path: InputPath,
+        output: OcrOutput = "text",
+        output_path: OutputPath = None,
+    ) -> str:
+        """The same tool as ocr_file, kept under its earlier name. Prefer ocr_file."""
+        return await ocr(path, output, output_path)
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=False, idempotent_hint=True, open_world_hint=True))
+    async def get_document(
+        document_id: DocumentId,
+        output: Annotated[
+            Literal["status", "text", "pdf"],
+            Field(description="'status' (default) returns the status at once; 'text' or 'pdf' waits for the document to finish and fetches the result."),
+        ] = "status",
+        output_path: OutputPath = None,
+    ) -> str:
+        """Get a FastOCR document's status, and optionally its text or searchable PDF.
+
+        Statuses: awaiting_upload, processing, completed, partial (the account ran out of
+        pages partway), failed. With output='text' or 'pdf' this waits up to 45 seconds;
+        if the document is still processing, call it again. Fetching a result again costs
+        no pages. Without output_path, long text and PDFs are saved in the system temp
+        directory.
+        """
+        _output_file(output_path)
+
+        async def action(client: AsyncFastOCR) -> str:
+            if output == "status":
+                return _format(_summary(await client.documents.get(document_id)))
+            try:
+                job = await client.documents.wait_for_completion(document_id, timeout=WAIT_SECONDS)
+            except PollingTimeoutError:
+                return f"Document {document_id} is still processing. Call get_document again with the same arguments."
+            default_stem = Path(tempfile.gettempdir()) / f"fastocr-{job.id}"
+            return await _deliver(client, job, output, output_path, default_stem)
+
+        result: str = await run(action)
+        return result
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True))
+    async def list_documents(
+        limit: Annotated[int, Field(ge=1, le=100, description="How many documents to return, newest first (1 to 100).")] = 20,
+    ) -> str:
+        """List the most recent documents in the FastOCR account with their status and page counts."""
+
+        async def action(client: AsyncFastOCR) -> str:
+            page = await client.documents.list(limit=limit)
+            if not page.documents:
+                return "No documents in this FastOCR account yet."
+            return "\n".join(_format(_summary(job)) for job in page.documents)
+
+        result: str = await run(action)
+        return result
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=True, idempotent_hint=True, open_world_hint=True))
+    async def delete_document(document_id: DocumentId) -> str:
+        """Permanently delete a FastOCR document and its stored files (original, text, searchable PDF).
+
+        A document that is still processing cannot be deleted. Local files are not touched.
+        """
+
+        async def action(client: AsyncFastOCR) -> str:
+            await client.documents.delete(document_id)
+            return f"Document {document_id} is being deleted."
+
+        result: str = await run(action)
+        return result
+
+    return server
+
+
+def _failure(job: DocumentJob) -> DocumentFailedError:
+    error = job.error
+    return DocumentFailedError(
+        (error.message if error else "") or "Document processing failed",
+        document_id=job.id,
+        code=error.code if error else "processing_failed",
+        retryable=error.retryable if error else True,
+    )
+
+
+def _format(summary: Dict[str, Any]) -> str:
+    return json.dumps({key: value for key, value in summary.items() if value is not None})
+
+
+def main() -> None:
+    create_server().run()

fastocr_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.5
+Name: fastocr-mcp
+Version: 0.1.0
+Summary: MCP server for the FastOCR Document OCR API: OCR scanned PDFs into text or searchable PDFs from Claude, Cursor and other MCP clients.
+Project-URL: Homepage, https://fastocr.org
+Project-URL: Documentation, https://fastocr.org/docs
+Project-URL: Repository, https://github.com/fastocr-org/fastocr-mcp
+Project-URL: Changelog, https://github.com/fastocr-org/fastocr-mcp/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/fastocr-org/fastocr-mcp/issues
+Author-email: FastOCR <support@fastocr.org>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,fastocr,mcp,model-context-protocol,ocr,pdf,searchable-pdf
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: fastocr-sdk<0.3,>=0.2.0
+Requires-Dist: mcp<3,>=2.3.0
+Provides-Extra: dev
+Requires-Dist: jsonschema>=4.20.0; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: respx>=0.21.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<a href="https://fastocr.org"><img src="https://raw.githubusercontent.com/fastocr-org/fastocr-mcp/main/docs/images/logo.png" alt="FastOCR" width="56" height="56"></a>
+
+# FastOCR MCP server
+
+OCR any scanned PDF or image from Claude, Cursor and other MCP clients, in 100+ languages. **[fastocr.org](https://fastocr.org)** · [Docs](https://fastocr.org/docs) · [Get an API key](https://fastocr.org/developers/keys)
+
+<!-- mcp-name: io.github.fastocr-org/fastocr-mcp -->
+
+[![PyPI](https://img.shields.io/pypi/v/fastocr-mcp.svg)](https://pypi.org/project/fastocr-mcp/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+An [MCP](https://modelcontextprotocol.io) server for the
+[FastOCR Document OCR API](https://fastocr.org/docs). It lets Claude Desktop,
+Claude Code, Cursor and other MCP clients OCR a local scanned PDF or image and get
+back its text or a searchable PDF.
+
+- PDF files up to 1 GiB, and PNG, JPG, JPEG, GIF, WebP and BMP images up to 20 MiB; 100+ languages.
+- Built on the official [`fastocr-sdk`](https://pypi.org/project/fastocr-sdk/) and the
+  official MCP Python SDK. Runs locally over stdio; your files go only to the FastOCR API.
+
+![A scanned Arabic book page beside the text FastOCR returned for it](https://raw.githubusercontent.com/fastocr-org/fastocr-mcp/main/docs/images/ocr-before-after.png)
+
+A real scanned page and the first lines of the text FastOCR returned for it, unedited.
+
+API reference and guides: **https://fastocr.org/docs**
+
+## Get an API key
+
+Any signed-in FastOCR account can create an API key and start right away.
+
+1. Sign in and create an API key in the
+   [developer console](https://fastocr.org/developers/keys). You accept the
+   [API terms](https://fastocr.org/api-terms) with your first key.
+2. Set the key as `FASTOCR_API_KEY` in your MCP client config (see below).
+3. When you need more than the free pages, buy a prepaid API page pack by card in the
+   [developer console](https://fastocr.org/developers/keys#buy-api-pages).
+
+Each account gets 50 free document pages per month.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) there is nothing to install; MCP clients run it with
+`uvx fastocr-mcp`. Or install it with pip and run `fastocr-mcp`:
+
+```bash
+pip install fastocr-mcp
+```
+
+Python 3.10 or newer. The server reads the key from `FASTOCR_API_KEY`.
+
+## Configure your MCP client
+
+### Claude Code
+
+```bash
+claude mcp add fastocr -e FASTOCR_API_KEY=your_api_key -- uvx fastocr-mcp
+```
+
+### Claude Desktop
+
+Add this to `claude_desktop_config.json` (Settings > Developer > Edit Config), then restart
+Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "fastocr": {
+      "command": "uvx",
+      "args": ["fastocr-mcp"],
+      "env": { "FASTOCR_API_KEY": "your_api_key" }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add the same block to `~/.cursor/mcp.json` (all projects) or `.cursor/mcp.json` (one project):
+
+```json
+{
+  "mcpServers": {
+    "fastocr": {
+      "command": "uvx",
+      "args": ["fastocr-mcp"],
+      "env": { "FASTOCR_API_KEY": "your_api_key" }
+    }
+  }
+}
+```
+
+If you installed with pip, use `"command": "fastocr-mcp"` and `"args": []`.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `ocr_file(path, output="text", output_path=None)` | Uploads a local PDF or image, runs OCR and waits up to 45 seconds; a larger document returns its id for `get_document`. `output="text"` returns the text (text over 20,000 characters is cut, and the full text is saved to `output_path` or `<file>.ocr.txt` next to the input file). `output="pdf"` saves a searchable PDF to `output_path` or `<file>.searchable.pdf`. |
+| `ocr_pdf(path, output="text", output_path=None)` | The same tool as `ocr_file` under its earlier name, kept so existing setups keep working. |
+| `get_document(document_id, output="status", output_path=None)` | Status and page counts of a document; with `output="text"` or `"pdf"`, waits up to 45 seconds and fetches the finished result. Fetching a result again costs no pages. |
+| `list_documents(limit=20)` | The most recent documents in the account, newest first. |
+| `delete_document(document_id)` | Deletes a document and its stored files on FastOCR. Local files are not touched. |
+
+Try asking: *"OCR ~/Downloads/scanned-contract.pdf and summarize the termination clause"*,
+*"Read the text in /Users/me/Desktop/receipt.jpg"* or
+*"Make a searchable copy of /Users/me/archive/1998-letters.pdf"*.
+
+Every processed page uses one page of the account's API allowance; an image is one page. A document that runs out
+of pages fails with `buy_pages`; the tool says so and links to the
+[developer console](https://fastocr.org/developers/keys#buy-api-pages).
+
+## Errors
+
+Tool errors are written for the agent to act on: a rejected key, an account out of pages
+(`buy_pages`), too many documents processing at once (`concurrency_limit`), a missing file, or an
+unsupported file type. Each message says what to do next. Error codes are listed in the
+[API docs](https://fastocr.org/docs/documents).
+
+## Configuration
+
+| Variable | Purpose |
+|---|---|
+| `FASTOCR_API_KEY` | Required. Your API key. |
+| `FASTOCR_BASE_URL` | Optional. Overrides `https://api.fastocr.org`. |
+
+## Links
+
+- Docs: https://fastocr.org/docs
+- API keys and page packs: https://fastocr.org/developers/keys
+- Python SDK: https://github.com/fastocr-org/fastocr-python
+- Support: support@fastocr.org
+
+## License
+
+MIT

fastocr_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+fastocr_mcp/__init__.py,sha256=RqiKHUtiXjI4HV8v1qFXj7G9bGgcr4uyLZwKq02UnEw,189
+fastocr_mcp/__main__.py,sha256=3dYKHfmWsrdExFlTFlcR5a_icR9fAkn06Yh14TQkEd8,33
+fastocr_mcp/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+fastocr_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastocr_mcp/server.py,sha256=1XSaCtJfreLiR2aXgzDCRmtAWlSxxPteO1xAVnSMdDs,14169
+fastocr_mcp-0.1.0.dist-info/METADATA,sha256=OwGOXhqrQ1tk03KfuaA8SWb9sHNzpCpxVSk92z1_eVs,7062
+fastocr_mcp-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+fastocr_mcp-0.1.0.dist-info/entry_points.txt,sha256=IzpVLUD-ltIL-SFZpkECQfOuVErkkqpIufZDxTcy4hE,56
+fastocr_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=iAEJvhOAbbRmyZP6iiDxfCJrifPj_5COWm4eVHmbOQ8,1064
+fastocr_mcp-0.1.0.dist-info/RECORD,,

fastocr_mcp-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

fastocr_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fastocr-mcp = fastocr_mcp.server:main

fastocr_mcp-0.1.0.dist-info/licenses/LICENSE

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