toa 0.1.0__py3-none-any.whl

toa/__init__.py

@@ -0,0 +1,18 @@
+from .__version__ import __version__
+from ._base_converter import BaseConverter, ConversionResult, ConverterInfo
+from ._error import ConversionFailedError, ConverterNotFoundError, UnsupportedError
+from ._toa import Toa
+from .utils import InputInfo, OutputInfo
+
+__all__ = [
+    "__version__",
+    "Toa",
+    "BaseConverter",
+    "ConversionResult",
+    "ConverterInfo",
+    "ConversionFailedError",
+    "ConverterNotFoundError",
+    "UnsupportedError",
+    "InputInfo",
+    "OutputInfo",
+]

toa/__main__.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+from pathlib import Path
+
+from ._toa import Toa
+from .utils import InputInfo, OutputInfo
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="toa",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # basic
+  %(prog)s document.pdf
+
+  # output content to filename
+  %(prog)s document.pdf -o pdf.html
+
+  # fetch remote resource
+  %(prog)s https://example.org/html
+
+  # Enable advanced features
+  %(prog)s readme.md --mermaid --formula --highlight
+
+  # Output to standard output
+  cat pdf.pdf | %(prog)s
+            """,
+    )
+
+    parser.add_argument('file', nargs="?", help="Input source")
+    # input options
+    input_group = parser.add_argument_group(title="Input options")
+    input_group.add_argument("-e", "--extension", help="File extension (e.g., .pdf, .mp3)")
+    input_group.add_argument("-m", "--mime-type", help="MIME type of the input file (e.g., application/pdf, audio/mpeg). If the `--extension` is already specified, the MIME type does not need to be specified.")
+    input_group.add_argument("--is-text", action="store_true", help="The file is a text file")
+    input_group.add_argument("--encoding", help="Only text files are supported, character set for non-text files is meaningless (default: utf-8)")
+    # output options
+    output_group = parser.add_argument_group(title="Output options")
+    output_group.add_argument("-o", "--output", help="Output file (default: stdout)")
+    output_group.add_argument("--engine", help="Engine to use")
+    output_group.add_argument("--wrapper", help="Method name used to wrap HTML content (a built-in wrapper named `default`)")
+    output_group.add_argument("--mermaid", action="store_true", help="Enable Mermaid diagram rendering")
+    output_group.add_argument("--highlight", action="store_true", help="Enable highlight")
+    output_group.add_argument("--formula", action="store_true", help="Enable mathematical formula rendering")
+    output_group.add_argument("--source-url", help="Source file address. An address accessible on a webpage. This parameter is required for some file types, such as PDF, MP3, etc.")
+    output_group.add_argument("--list-converters", action="store_true", help="List converter description information")
+
+    args = parser.parse_args()
+
+    toa = Toa()
+
+    if args.list_converters:
+        for item in list(toa.list_converters()):
+            print(f"  - {item.name}: {item.description}")
+        sys.exit(0)
+
+    # Check if the flow information is empty.
+    b = all([args.extension is None, args.mime_type is None])
+
+    if b:
+        """Only text files are supported, character set for non-text files is meaningless."""
+        args.is_text = None
+        args.encoding = None
+
+    input_info = InputInfo(
+        extension=args.extension,
+        mime_type=args.mime_type,
+        is_text=args.is_text,
+        encoding=args.encoding,
+    )
+    output_info = OutputInfo(
+        wrapper=args.wrapper,
+        mermaid=args.mermaid,
+        highlight=args.highlight,
+        formula=args.formula,
+        engine=args.engine,
+        filename=args.output,
+        source_url=args.source_url,
+    )
+
+    if args.file is None or args.file == "-":
+        result = toa.convert_stdin_stream(
+            sys.stdin.buffer,
+            input_info=input_info if input_info and not input_info.is_empty else None,
+            output_info=output_info,
+        )
+    else:
+        result = toa.convert(
+            args.file,
+            input_info=input_info if input_info and not input_info.is_empty else None,
+            output_info=output_info,
+        )
+
+    if args.output:
+        Path(args.output).write_text(result.content, encoding=args.encoding or "utf-8")
+    else:
+        print(result.content)
+
+
+if __name__ == "__main__":
+    main()

toa/__mcp__.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+import argparse
+import contextlib
+from collections.abc import AsyncIterator
+
+import uvicorn
+from mcp.server import FastMCP
+from mcp.server.sse import SseServerTransport
+from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+from mcp.server.websocket import websocket_server
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import Mount, Route, WebSocketRoute
+from starlette.websockets import WebSocket
+
+from toa import Toa
+
+_converter = Toa()
+mcp = FastMCP("toa-mcp")
+
+@mcp.tool()
+async def convert_to_html(uri: str) -> str:
+    return _converter.convert(uri).content
+
+@mcp.tool()
+async def convert_html2md(html_content: str) -> str:
+    return Toa.html2md(html_content)
+
+
+def main() -> None:
+    """Start HTTP/SSE/STDIO server"""
+    parser = argparse.ArgumentParser(
+        prog="toa-mcp",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # web
+  %(prog)s --transport http
+
+  # stdio
+  %(prog)s
+            """,
+    )
+
+    parser.add_argument("--transport", default="stdio", choices=("http", "sse", "ws", "stdio"), help="The transport to use to run the service")
+    parser.add_argument("--host", default="0.0.0.0", help="Which host to bind to - default is 0.0.0.0")
+    parser.add_argument("--port", default=56156, help="Port to listen on")
+
+    args = parser.parse_args()
+
+    if str(args.transport).lower() in ("http", "sse", "ws"):
+        mcp_server = mcp._mcp_server
+
+        sse = SseServerTransport("/messages/")
+        async def handle_sse(request: Request):
+            async with sse.connect_sse(
+                request.scope, request.receive, request._send
+            ) as (read_stream, write_stream):
+                await mcp_server.run(
+                    read_stream, write_stream, mcp_server.create_initialization_options()
+                )
+            return Response()
+
+        async def handle_ws(websocket: WebSocket):
+            async with websocket_server(
+                    websocket.scope, websocket.receive, websocket.send
+            ) as (read_stream, write_stream):
+                await mcp_server.run(
+                    read_stream, write_stream, mcp_server.create_initialization_options()
+                )
+
+        session_manager = StreamableHTTPSessionManager(
+            app=mcp_server,
+            event_store=None,
+            json_response=True,
+            stateless=True,
+        )
+
+        @contextlib.asynccontextmanager
+        async def lifespan(app: Starlette) -> AsyncIterator[None]:
+            """Manage the lifecycle of the session manager; each request has a corresponding session."""
+            async with session_manager.run():
+                origin = get_origin(args.host, args.port)
+                print(f"{'':=^60}")
+                print("   MCP Server is running")
+                print()
+                print(f"   - Streamable HTTP endpoint: {origin}/mcp")
+                print(f"   - Message endpoint: {origin}/messages/")
+                print(f"   - SSE endpoint: {origin}/sse")
+                print(f"   - WebSocket endpoint: {origin}/ws")
+                print(f"{'':=^60}")
+                yield
+                print("MCP Server is closing...")
+
+        app = Starlette(
+            routes=[
+                Route("/sse", endpoint=handle_sse, methods=["GET", "POST"]),
+                Mount("/messages/", app=sse.handle_post_message),
+                Mount("/mcp", app=session_manager.handle_request),
+                WebSocketRoute("/ws", endpoint=handle_ws),
+                Route(
+                    "/ping",
+                    endpoint=lambda request: Response("pong"),
+                    methods=["GET", "POST"],
+                ),
+            ],
+            lifespan=lifespan,
+        )
+
+        uvicorn.run(app, host=args.host, port=args.port)
+    else:
+        mcp.run()
+
+
+def get_origin(host: str, port: int) -> str:
+    from urllib.parse import urlparse, urlunparse
+
+    parsed = urlparse(host)
+
+    if parsed.scheme:
+        scheme = parsed.scheme
+        netloc = parsed.netloc if parsed.netloc else parsed.path
+    else:
+        scheme = "https" if port == 443 else "http"
+        netloc = host
+
+    netloc = netloc.split(":")[0]
+
+    return urlunparse((scheme, f"{netloc}:{port}", "", "", "", ""))
+
+
+if __name__ == "__main__":
+    main()

toa/__version__.py

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

toa/_base_converter.py

@@ -0,0 +1,87 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import BinaryIO
+
+from .utils import InputInfo, OutputInfo
+
+
+class ConversionResult:
+    """
+    Conversion result
+    """
+
+    def __init__(
+        self,
+        content: str,
+    ) -> None:
+        self.content = content
+
+@dataclass(kw_only=True, frozen=True)
+class ConverterInfo:
+    name: str
+    description: str | None
+
+
+@dataclass
+class BaseConverter(ABC):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @property
+    @abstractmethod
+    def check_dependencies(self) -> bool:
+        """
+        Returns a boolean value. Returns True if there are no external dependencies;
+        otherwise, the conversion will throw an error.
+        """
+        raise NotImplementedError(
+            "Subclasses must implement the property to check dependencies."
+        )
+
+    @property
+    @abstractmethod
+    def suffixes(self) -> list[str]:
+        """extensions are supported (Format: ['.txt', '.md'])"""
+        raise NotImplementedError("file extensions are supported for conversion")
+
+    @property
+    @abstractmethod
+    def mime_types(self) -> list[str]:
+        """
+        The format is ['text/markdown', 'application/pdf'].
+        """
+        raise NotImplementedError("MIME types are supported for conversion")
+
+    @abstractmethod
+    def convert(
+        self,
+        input_stream: BinaryIO,
+        input_info: InputInfo,
+        output_info: OutputInfo | None = None,
+        **kwargs,
+    ) -> ConversionResult:
+        """
+        The core logic of the conversion needs to be overridden by the subclass.
+
+        Args:
+            input_stream: Converting paths, file streams, and remote addresses into accessible streams.
+            input_info: stream information
+            output_info: output information
+        """
+        raise NotImplementedError("Subclasses must implement the convert method.")
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} suffixes={self.suffixes}>"
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        if self.__class__ != other.__class__:
+            return False
+        return self.suffixes == other.suffixes
+
+    def __hash__(self):
+        return hash((self.__class__, tuple(self.suffixes)))
+
+    def __getitem__(self, item: str):
+        return getattr(self, item)

toa/_error.py

@@ -0,0 +1,10 @@
+class ConverterNotFoundError(Exception):
+    pass
+
+
+class ConversionFailedError(Exception):
+    pass
+
+
+class UnsupportedError(Exception):
+    pass