mistune-json 0.1.0__py3-none-any.whl

mistune_json/__init__.py

@@ -0,0 +1,11 @@
+"""
+Mistune JSON Renderer.
+
+A renderer for Mistune that outputs Markdown as JSON structures
+instead of HTML.
+"""
+
+from .json_renderer import JsonRenderer
+
+__version__ = "0.1.0"
+__all__ = ["JsonRenderer"]

mistune_json/json_renderer.py

@@ -0,0 +1,147 @@
+from typing import Any, Dict, Iterable, List, Optional
+
+import mistune
+
+
+class JsonRenderer(mistune.HTMLRenderer):
+    """
+    A renderer for Mistune that outputs Markdown as JSON structures
+    instead of HTML.
+    """
+
+    def __init__(self, output: Optional[Dict[str, Any]] = None) -> None:
+        """
+        Initialize the JSON renderer.
+
+        Args:
+            output: Optional dictionary to update with rendered content
+        """
+        # No need for escape HTML or skip style in JSON renderer
+        super().__init__(escape=False, allow_harmful_protocols=False)
+        self._output: Dict[str, Any] = output if output is not None else {}
+
+    def render_tokens(self, tokens: Iterable[Dict[str, Any]], state: Any) -> List[Dict[str, Any]]:
+        """
+        Render a list of tokens into JSON structures.
+
+        Args:
+            tokens: Iterable of tokens to render
+            state: State object from Mistune parser
+
+        Returns:
+            List of rendered JSON structures
+        """
+        return list(self.iter_tokens(tokens, state))
+
+    def iter_tokens(self, tokens: Iterable[Dict[str, Any]], state: Any) -> Iterable[Dict[str, Any]]:
+        """
+        Iterate through tokens and yield rendered JSON structures.
+
+        Args:
+            tokens: Iterable of tokens to render
+            state: State object from Mistune parser
+
+        Yields:
+            Rendered JSON structures
+        """
+        for tok in tokens:
+            yield self.render_token(tok, state)
+
+    def __call__(self, tokens: Iterable[Dict[str, Any]], state: Any) -> Dict[str, Any]:
+        """
+        Main entry point for rendering.
+
+        Args:
+            tokens: Iterable of tokens to render
+            state: State object from Mistune parser
+
+        Returns:
+            Dictionary with rendered content
+        """
+        content = self.render_tokens(tokens, state)
+        # Filter out empty items
+        filtered_content = [item for item in content if item]
+        self._output.update({"content": filtered_content})
+        return self._output
+
+    # Block level tokens
+
+    def blank_line(self) -> Dict[str, Any]:
+        """Render a blank line."""
+        return {}
+
+    def paragraph(self, text: str) -> Dict[str, Any]:
+        """Render a paragraph."""
+        return {"type": "p", "content": text}
+
+    def heading(self, text: str, level: int) -> Dict[str, Any]:
+        """Render a heading."""
+        return {"type": "h", "content": text, "level": level}
+
+    def block_code(self, code: str, info: Optional[str] = None) -> Dict[str, Any]:
+        """Render a code block."""
+        result = {"type": "code", "content": code.strip()}
+        if info:
+            result["lang"] = info.strip()
+        return result
+
+    def block_quote(self, text: str) -> Dict[str, Any]:
+        """Render a block quote."""
+        return {"type": "blockquote", "content": text}
+
+    def list(self, text: str, ordered: bool, **attrs: int) -> Dict[str, Any]:
+        """Render an ordered or unordered list."""
+        if ordered:
+            result = {"type": "ol", "content": text}
+            start = attrs.get("start")
+            if start is not None:
+                result["start"] = start
+            return result
+        else:
+            return {"type": "ul", "content": text}
+
+    def list_item(self, text: str) -> Dict[str, Any]:
+        """Render a list item."""
+        return {"content": text}
+
+    def thematic_break(self) -> Dict[str, Any]:
+        """Render a thematic break (horizontal rule)."""
+        return {"type": "hr"}
+
+    # Span level tokens
+
+    def strong(self, text: str) -> Dict[str, Any]:
+        """Render strong emphasis."""
+        return {"type": "strong", "content": text}
+
+    def emphasis(self, text: str) -> Dict[str, Any]:
+        """Render emphasis."""
+        return {"type": "em", "content": text}
+
+    def codespan(self, text: str) -> Dict[str, Any]:
+        """Render inline code."""
+        return {"type": "codespan", "content": text}
+
+    def link(self, text: str, url: str, title: Optional[str] = None) -> Dict[str, Any]:
+        """Render a link."""
+        link = {"type": "a", "href": self.safe_url(url), "content": text}
+        if title:
+            link["title"] = title
+        return link
+
+    def image(self, text: str, url: str, title: Optional[str] = None) -> Dict[str, Any]:
+        """Render an image."""
+        return {
+            "type": "img",
+            "src": self.safe_url(url),
+            "alt": text,
+            **({"title": title} if title else {}),
+        }
+
+    def linebreak(self) -> Dict[str, Any]:
+        """Render a line break."""
+        return {"type": "br"}
+
+    def text(self, text: str) -> Dict[str, Any]:
+        """Render plain text."""
+        return {"type": "text", "content": text}

mistune_json-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.3
+Name: mistune-json
+Version: 0.1.0
+Summary: 
+License: MIT
+Author: fernandonino
+Author-email: nino.fernando@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: mistune (>=3.1.3,<4.0.0)
+Description-Content-Type: text/markdown
+
+# Mistune JSON
+A JSON renderer for the [Mistune](https://github.com/lepture/mistune) Markdown parser.
+
+## Supported HTML elements
+So far, the HTML elements supported by this renderer are limited to:
+
+* Paragraph, `<p>`
+* Image, `<img>`
+* Ordered lists, `<ol>`
+* Unordered lists, `<ul>`
+* All heading elements, `<h1>` through `<h6>`
+* Links, `<a>`
+* Emphasis, `<em>`
+* Strong, `<strong>`
+* Blockquote, `<blockquote>`
+* Line breake, `<br>`
+* Thematic breake, `<hr>`
+* Both inline and block code
+
+## How to use the JSON renderer
+### Installation
+The package is not yet published in PyPI, but once it is, it will be installed with:
+```shell
+pip install mistune-json
+```
+
+### Usage
+```python
+import mistune
+from mistune_json import JsonRenderer
+
+# Create a renderer instance
+renderer = JsonRenderer()
+
+# Create a Markdown parser with the JSON renderer
+markdown = mistune.create_markdown(renderer=renderer)
+
+# Parse Markdown text
+result = markdown("# Hello, world!")
+
+print(result)
+# {'content': [{'type': 'h', 'content': ['type': 'text', 'content': 'Hello, world!'], 'level': 1}]}
+```
+
+## Improvements and bugs
+
+### Tables
+There is currently no support for rendering tables (headers and rows). It might be added in the future, if there is enough need for it. You can rise an issue [here](https://github.com/fernandonino/mistune-json/issues) and label it as _enhancement_.
+
+### Integration testing
+Tests for a full Markdown document will be added to assure that the JSON render works as expected.
+
+### Bugs
+If you find a problem with the JSON output structure, feel free to [report a bug](https://github.com/fernandonino/mistune-json/issues).

mistune_json-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+mistune_json/__init__.py,sha256=YhcKlkNUFuuq9Xf_-zGDK3XJ26RxGnVHXD5H1ZR61AI,204
+mistune_json/json_renderer.py,sha256=xusj9_pqJMC_WymRSEQWdLajcgNjNqlcLyrHGi73HPs,4792
+mistune_json-0.1.0.dist-info/METADATA,sha256=vChrWJhlv9kTZ2Pty8PwTVo1hdfJOfUyhHwtqCSeznA,2081
+mistune_json-0.1.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+mistune_json-0.1.0.dist-info/RECORD,,

mistune_json-0.1.0.dist-info/WHEEL

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