edwh-editorjs 1.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

editorjs/core.py

@@ -0,0 +1,119 @@
+import json
+import typing as t
+
+import markdown2
+import mdast
+from typing_extensions import Self
+
+from .blocks import BLOCKS
+from .helpers import unix_timestamp
+from .types import MDRootNode
+
+EDITORJS_VERSION = "2.30.6"
+
+
+class EditorJS:
+    # internal representation is mdast, because we can convert to other types
+    _mdast: MDRootNode
+
+    def __init__(
+        self,
+        _mdast: str | dict,
+        extras: list = ("task_list", "fenced-code-blocks", "tables", "editorjs"),
+    ):
+        if not isinstance(_mdast, str | dict):
+            raise TypeError("Only `str` or `dict` is supported!")
+
+        self._mdast = t.cast(
+            MDRootNode, json.loads(_mdast) if isinstance(_mdast, str) else _mdast
+        )
+
+        self._md = markdown2.Markdown(extras=extras)  # todo: striketrough, ?
+
+    @classmethod
+    def from_json(cls, data: str | dict) -> Self:
+        """
+        Load from EditorJS JSON Blocks
+        """
+        data = data if isinstance(data, dict) else json.loads(data)
+        markdown_items = []
+        for child in data["blocks"]:
+            _type = child["type"]
+            if not (block := BLOCKS.get(_type)):
+                raise TypeError(f"Unsupported block type `{_type}`")
+
+            markdown_items.append(block.to_markdown(child.get("data", {})))
+
+        markdown = "".join(markdown_items)
+        return cls.from_markdown(markdown)
+
+    @classmethod
+    def from_markdown(cls, data: str) -> Self:
+        """
+        Load from markdown string
+        """
+
+        return cls(mdast.md_to_json(data))
+
+    @classmethod
+    def from_mdast(cls, data: str | dict) -> Self:
+        """
+        Existing mdast representation
+        """
+        return cls(data)
+
+    def to_json(self) -> str:
+        """
+        Export EditorJS JSON Blocks
+        """
+        # logic based on https://github.com/carrara88/editorjs-md-parser/blob/main/src/MarkdownImporter.js
+        blocks = []
+        for child in self._mdast["children"]:
+            _type = child["type"]
+            if not (block := BLOCKS.get(_type)):
+                raise TypeError(f"Unsupported block type `{_type}`")
+
+            blocks.extend(block.to_json(child))
+
+        data = {"time": unix_timestamp(), "blocks": blocks, "version": EDITORJS_VERSION}
+
+        return json.dumps(data)
+
+    def to_markdown(self) -> str:
+        """
+        Export Markdown string
+        """
+        md = mdast.json_to_md(self.to_mdast())
+        # idk why this happens:
+        md = md.replace(r"\[ ]", "[ ]")
+        md = md.replace(r"\[x]", "[x]")
+        return md
+
+    def to_mdast(self) -> str:
+        """
+        Export mdast representation
+        """
+        return json.dumps(self._mdast)
+
+    def to_html(self) -> str:
+        """
+        Export HTML string
+        """
+        md = self.to_markdown()
+        # todo: deal with custom elements like linktool, attaches
+        return self._md.convert(md)
+
+    def __repr__(self):
+        md = self.to_markdown()
+        md = md.replace("\n", "\\n")
+        return f"EditorJS({md})"
+
+    def __str__(self):
+        return self.to_markdown()
+
+    # def __eq__(self, other: Self) -> bool:
+    #     a = self.to_markdown()
+    #     b = other.to_markdown()
+    #
+    #     remove = string.punctuation + string.whitespace
+    #     return a.translate(remove) == b.translate(remove)

editorjs/exceptions.py

@@ -0,0 +1,3 @@
+class TODO(NotImplementedError):
+    def __init__(self, msg: str = "todo"):
+        super().__init__(msg)

editorjs/helpers.py

@@ -0,0 +1,5 @@
+import time
+
+
+def unix_timestamp():
+    return round(time.time() * 1000)

editorjs/types.py

@@ -0,0 +1,43 @@
+import typing as t
+
+
+class MDPosition(t.TypedDict):
+    line: int
+    column: int
+    offset: int
+
+
+class MDPositionRange(t.TypedDict):
+    start: MDPosition
+    end: MDPosition
+
+
+class MDChildNode(t.TypedDict, total=False):
+    type: str  # General identifier for node types
+    children: list["MDChildNode"]  # Recursive children of any node type
+    position: MDPositionRange
+    value: str  # Optional, for nodes like text that hold a value
+    depth: int  # Optional, for nodes like headings that have a depth
+    url: t.NotRequired[str]
+
+
+class MDRootNode(t.TypedDict):
+    type: t.Literal["root"]  # Constrains to 'root' for the root node
+    children: list[MDChildNode]  # Allows any ChildNode type in children
+    position: MDPositionRange
+
+
+class EditorChildData(t.TypedDict, total=False):
+    text: str
+    items: list["EditorChildNode"]
+
+
+class EditorChildNode(t.TypedDict):
+    type: str
+    data: EditorChildData
+
+
+class EditorRootNode(t.TypedDict):
+    time: int
+    blocks: list[EditorChildNode]
+    version: str

edwh_editorjs-2.0.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.3
+Name: edwh-editorjs
+Version: 2.0.0
+Summary: EditorJS.py
+Project-URL: Homepage, https://github.com/educationwarehouse/edwh-EditorJS
+Author-email: SKevo <skevo.cw@gmail.com>, Robin van der Noord <robin.vdn@educationwarehouse.nl>
+License: MIT
+License-File: LICENSE
+Keywords: bleach,clean,editor,editor.js,html,javascript,json,parser,wysiwyg
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: markdown2
+Requires-Dist: mdast
+Provides-Extra: dev
+Requires-Dist: edwh; extra == 'dev'
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: su6[all]; extra == 'dev'
+Requires-Dist: types-bleach; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# edwh-editorjs
+

edwh_editorjs-2.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+editorjs/__about__.py,sha256=_7OlQdbVkK4jad0CLdpI0grT-zEAb-qgFmH5mFzDXiA,22
+editorjs/__init__.py,sha256=-OHUf7ZXfkbdFB1r85eIjpHRfql-GCNUCKuBEdEt2Rc,58
+editorjs/blocks.py,sha256=CTZPKIxjRQy1R1LPrqpB9NTvhSeSjekcMls6QAPdDoI,21664
+editorjs/core.py,sha256=CdZnprX-vkjFJATxPfG1acDqGKkHa3mDfbMEeXiR6eI,3331
+editorjs/exceptions.py,sha256=TyfHvk2Z5RbKxTDK7lrjgwAgVgInXIuDW63eO5jzVFw,106
+editorjs/helpers.py,sha256=q861o5liNibMTp-Ozay17taF7CTNsRe901lYhhxdwHg,73
+editorjs/types.py,sha256=W7IZWMWgzJaQulybIt0Gx5N63rVj4mEy73VJWo4VAQA,1029
+edwh_editorjs-2.0.0.dist-info/METADATA,sha256=WnNAx-XckoOeSuXbNdJQHs2zto0xSeN1g3yPXXZ8T34,1007
+edwh_editorjs-2.0.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+edwh_editorjs-2.0.0.dist-info/licenses/LICENSE,sha256=zzllbk0pvnmgzk31iq8Zkg0GkA8vVx_Zc3OHjVlTjxo,1101
+edwh_editorjs-2.0.0.dist-info/RECORD,,

{edwh_editorjs-1.1.0.dist-info → edwh_editorjs-2.0.0.dist-info}/licenses/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
 Copyright (c) 2021 SKevo
+Copyright (c) 2024 Education Warehouse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

edwh_editorjs-1.1.0.dist-info/METADATA

@@ -1,104 +0,0 @@
-Metadata-Version: 2.3
-Name: edwh-editorjs
-Version: 1.1.0
-Summary: pyEditorJS
-Project-URL: Homepage, https://github.com/educationwarehouse/edwh-EditorJS
-Author-email: SKevo <skevo.cw@gmail.com>, Robin van der Noord <robin.vdn@educationwarehouse.nl>
-License: MIT
-License-File: LICENSE
-Keywords: bleach,clean,editor,editor.js,html,javascript,json,parser,wysiwyg
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Requires-Dist: bleach
-Provides-Extra: dev
-Requires-Dist: edwh; extra == 'dev'
-Requires-Dist: hatch; extra == 'dev'
-Requires-Dist: su6[all]; extra == 'dev'
-Requires-Dist: types-bleach; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# edwh-editorjs
-
-A minimal, fast Python 3.10+ package for parsing [Editor.js](https://editorjs.io) content.
-This package is a fork of [pyEditorJS by SKevo](https://github.com/SKevo18/pyEditorJS) with additional capabilities.
-
-## New Features
-
-- Expanded support for additional block types: Quote, Table, Code, Warning, and Raw blocks
-- Issues a warning if an unknown block type is encountered, rather than ignoring it
-- Adds a `strict` mode, raising an `EditorJSUnsupportedBlock` exception for unknown block types when `strict=True`
-- Allows adding new blocks by decorating a subclass of `EditorJsParser` with `@block("name")`
-
-## Installation
-
-```bash
-pip install edwh-editorjs
-```
-
-## Usage
-
-### Quickstart
-
-```python
-from pyeditorjs import EditorJsParser
-
-editor_js_data = ...  # your Editor.js JSON data
-parser = EditorJsParser(editor_js_data)  # initialize the parser
-
-html = parser.html(sanitize=True)  # `sanitize=True` uses the included `bleach` dependency
-print(html)  # your clean HTML
-```
-
-### Enforcing Strict Block Types
-
-```python
-from pyeditorjs import EditorJsParser, EditorJSUnsupportedBlock
-
-editor_js_data: dict = ...
-parser = EditorJsParser(editor_js_data)
-
-try:
-    html = parser.html(strict=True)
-except EditorJSUnsupportedBlock as e:
-    print(f"Unsupported block type encountered: {e}")
-```
-
-### Adding a Custom Block
-
-To add a custom block type, create a new class that subclasses `EditorJsBlock` and decorates it with `@block("name")`,
-where `"name"` is the custom block type. Implement an `html` method to define how the block’s content should be
-rendered. This method should accept a `sanitize` parameter and can access block data via `self.data`.
-
-```python
-from pyeditorjs import EditorJsParser, EditorJsBlock, block
-
-@block("custom")
-class CustomBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        # Access data with self.data and return the rendered HTML
-        content = self.data.get("something", "")
-        if sanitize:
-            content = self.sanitize(content)
-        
-        return f"<div class='custom-block'>{content}</div>"
-
-# Usage
-class CustomEditorJsParser(EditorJsParser):
-    pass  # Custom blocks are automatically detected
-
-editor_js_data = ...  # Editor.js JSON data with a "customBlock" type
-parser = CustomEditorJsParser(editor_js_data)
-html = parser.html()
-print(html)  # Includes rendered custom blocks
-```
-
-## Disclaimer
-
-This is a community-provided project and is not affiliated with the Editor.js team. 
-Contributions, bug reports, and suggestions are welcome!

edwh_editorjs-1.1.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-pyeditorjs/__about__.py,sha256=LGVQyDsWifdACo7qztwb8RWWHds1E7uQ-ZqD8SAjyw4,22
-pyeditorjs/__init__.py,sha256=63UoNCWJo6NuPXXYnANQE3SKm1PQu2ggs89KCXSq-44,807
-pyeditorjs/blocks.py,sha256=4A8dXbh_oUKCctOHtMV6BrR7-UpyqFREPvwPEe_6vUo,8304
-pyeditorjs/exceptions.py,sha256=Uni8r3FwJ-6xQIdSmBsHLs_htWLHD0Arp1KJEvjGU1U,439
-pyeditorjs/parser.py,sha256=6DCqqi-FuXDFxn9xb-dgQ19alvVu7Pjx6x3rTAx9IsI,2154
-edwh_editorjs-1.1.0.dist-info/METADATA,sha256=Aq3-6WNcqqhbufFvnigNO-txrmV_6OppGmliWoK7tf4,3519
-edwh_editorjs-1.1.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-edwh_editorjs-1.1.0.dist-info/licenses/LICENSE,sha256=bY9MhHLeuW8w1aAl-i1O1uSNP5IMOGaL6AWvHcdnt0k,1062
-edwh_editorjs-1.1.0.dist-info/RECORD,,

pyeditorjs/__about__.py

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

pyeditorjs/__init__.py

@@ -1,30 +0,0 @@
-from pathlib import Path
-
-from .blocks import BLOCKS_MAP, EditorJsBlock, block
-from .exceptions import EditorJsException, EditorJsParseError, EditorJSUnsupportedBlock
-from .parser import EditorJsParser
-
-__all__ = [
-    "EditorJsParser",
-    "EditorJsParseError",
-    "EditorJsException",
-    "EditorJSUnsupportedBlock",
-    "EditorJsBlock",
-    "block",
-    "BLOCKS_MAP",
-]
-
-
-# Overwrite __doc__ with README, so that pdoc can render it:
-README_PATH = Path(__file__).parent.parent.absolute() / Path("README.md")
-try:
-    with open(README_PATH, "r", encoding="UTF-8") as readme:
-        __readme__ = readme.read()
-except Exception:
-    __readme__ = "Failed to read README.md!"  # fallback message, for example when there's no README
-
-__doc__ = __readme__
-
-
-if __name__ == "__main__":
-    _ = [EditorJsParser]

pyeditorjs/blocks.py

@@ -1,313 +0,0 @@
-import abc
-import typing as t
-from dataclasses import dataclass
-
-import bleach
-
-from .exceptions import EditorJsParseError
-
-__all__ = [
-    "block",
-    "BLOCKS_MAP",
-    "EditorJsBlock",
-]
-
-
-def _sanitize(html: str) -> str:
-    return bleach.clean(
-        html,
-        tags=["b", "i", "u", "a", "mark", "code"],
-        attributes=["class", "data-placeholder", "href"],
-    )
-
-
-BLOCKS_MAP: t.Dict[str, t.Type["EditorJsBlock"]] = {
-    # 'header': HeaderBlock,
-    # 'paragraph': ParagraphBlock,
-    # 'list': ListBlock,
-    # 'delimiter': DelimiterBlock,
-    # 'image': ImageBlock,
-}
-
-
-def block(_type: str):
-    def wrapper(cls: t.Type["EditorJsBlock"]):
-        BLOCKS_MAP[_type] = cls
-        return cls
-
-    return wrapper
-
-
-@dataclass
-class EditorJsBlock(abc.ABC):
-    """
-    A generic parsed Editor.js block
-    """
-
-    _data: dict
-    """The raw JSON data of the entire block"""
-
-    @classmethod
-    def sanitize(cls, html: str) -> str:
-        return _sanitize(html)
-
-    @property
-    def id(self) -> t.Optional[str]:
-        """
-        Returns ID of the block, generated client-side.
-        """
-
-        return self._data.get("id", None)
-
-    @property
-    def type(self) -> t.Optional[str]:
-        """
-        Returns the type of the block.
-        """
-
-        return self._data.get("type", None)
-
-    @property
-    def data(self) -> dict:
-        """
-        Returns the actual block data.
-        """
-
-        return self._data.get("data", {})
-
-    @abc.abstractmethod
-    def html(self, sanitize: bool = False) -> str:
-        """
-        Returns the HTML representation of the block.
-
-        ### Parameters:
-        - `sanitize` - if `True`, then the block's text/contents will be sanitized.
-        """
-
-        raise NotImplementedError()
-
-
-@block("header")
-class HeaderBlock(EditorJsBlock):
-    VALID_HEADER_LEVEL_RANGE = range(1, 7)
-    """Valid range for header levels. Default is `range(1, 7)` - so, `0` - `6`."""
-
-    @property
-    def text(self) -> str:
-        """
-        Returns the header's text.
-        """
-
-        return self.data.get("text", "")
-
-    @property
-    def level(self) -> int:
-        """
-        Returns the header's level (`0` - `6`).
-        """
-
-        _level = self.data.get("level", 1)
-
-        if not isinstance(_level, int) or _level not in self.VALID_HEADER_LEVEL_RANGE:
-            raise EditorJsParseError(f"`{_level}` is not a valid header level.")
-
-        return _level
-
-    def html(self, sanitize: bool = False) -> str:
-        text = self.text
-        if sanitize:
-            text = _sanitize(text)
-        return rf'<h{self.level} class="cdx-block ce-header">{text}</h{self.level}>'
-
-
-@block("paragraph")
-class ParagraphBlock(EditorJsBlock):
-    @property
-    def text(self) -> str:
-        """
-        The text content of the paragraph.
-        """
-
-        return self.data.get("text", "")
-
-    def html(self, sanitize: bool = False) -> str:
-        return rf'<p class="cdx-block ce-paragraph">{_sanitize(self.text) if sanitize else self.text}</p>'
-
-
-@block("list")
-class ListBlock(EditorJsBlock):
-    VALID_STYLES = ("unordered", "ordered")
-    """Valid list order styles."""
-
-    @property
-    def style(self) -> t.Optional[str]:
-        """
-        The style of the list. Can be `ordered` or `unordered`.
-        """
-
-        return self.data.get("style", None)
-
-    @property
-    def items(self) -> t.List[str]:
-        """
-        Returns the list's items, in raw format.
-        """
-
-        return self.data.get("items", [])
-
-    def html(self, sanitize: bool = False) -> str:
-        if self.style not in self.VALID_STYLES:
-            raise EditorJsParseError(f"`{self.style}` is not a valid list style.")
-
-        _items = [
-            f"<li>{_sanitize(item) if sanitize else item}</li>" for item in self.items
-        ]
-        _type = "ul" if self.style == "unordered" else "ol"
-        _items_html = "".join(_items)
-
-        return rf'<{_type} class="cdx-block cdx-list cdx-list--{self.style}">{_items_html}</{_type}>'
-
-
-@block("delimiter")
-class DelimiterBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        return r'<div class="cdx-block ce-delimiter"></div>'
-
-
-@block("image")
-class ImageBlock(EditorJsBlock):
-    @property
-    def file_url(self) -> str:
-        """
-        URL of the image file.
-        """
-
-        return self.data.get("file", {}).get("url", "")
-
-    @property
-    def caption(self) -> str:
-        """
-        The image's caption.
-        """
-
-        return self.data.get("caption", "")
-
-    @property
-    def with_border(self) -> bool:
-        """
-        Whether the image has a border.
-        """
-
-        return self.data.get("withBorder", False)
-
-    @property
-    def stretched(self) -> bool:
-        """
-        Whether the image is stretched.
-        """
-
-        return self.data.get("stretched", False)
-
-    @property
-    def with_background(self) -> bool:
-        """
-        Whether the image has a background.
-        """
-
-        return self.data.get("withBackground", False)
-
-    def html(self, sanitize: bool = False) -> str:
-        if self.file_url.startswith("data:image/"):
-            _img = self.file_url
-        else:
-            _img = _sanitize(self.file_url) if sanitize else self.file_url
-
-        parts = [
-            rf'<div class="cdx-block image-tool image-tool--filled {"image-tool--stretched" if self.stretched else ""} {"image-tool--withBorder" if self.with_border else ""} {"image-tool--withBackground" if self.with_background else ""}">'
-            r'<div class="image-tool__image">',
-            r'<div class="image-tool__image-preloader"></div>',
-            rf'<img class="image-tool__image-picture" src="{_img}"/>',
-            r"</div>"
-            rf'<div class="image-tool__caption" data-placeholder="{_sanitize(self.caption) if sanitize else self.caption}"></div>'
-            r"</div>"
-            r"</div>",
-        ]
-
-        return "".join(parts)
-
-
-@block("quote")
-class QuoteBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        quote = self.data.get("text", "")
-        caption = self.data.get("caption", "")
-        if sanitize:
-            quote = _sanitize(quote)
-            caption = _sanitize(caption)
-        _alignment = self.data.get("alignment", "left")  # todo
-        return f"""
-        <blockquote class="cdx-block cdx-quote">
-            <div class="cdx-input cdx-quote__text">{quote}</div>
-            <cite class="cdx-input cdx-quote__caption">{caption}</cite>
-        </blockquote>
-        """
-
-
-@block("table")
-class TableBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        content = self.data.get("content", [])
-        _stretched = self.data.get("stretched", False)  # todo
-        _with_headings = self.data.get("withHeadings", False)  # todo
-
-        html_table = '<table class="tc-table">'
-
-        # Add content rows
-        for row in content:
-            html_table += '<tr class="tc-row">'
-            for cell in row:
-                html_table += (
-                    f'<td class="tc-cell">{_sanitize(cell) if sanitize else cell}</td>'
-                )
-            html_table += "</tr>"
-
-        html_table += "</table>"
-        return html_table
-
-
-@block("code")
-class CodeBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        code = self.data.get("code", "")
-        if sanitize:
-            code = _sanitize(code)
-        return f"""
-        <code class="ce-code__textarea cdx-input" data-empty="false">{code}</code>
-        """
-
-
-@block("warning")
-class WarningBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        title = self.data.get("title", "")
-        message = self.data.get("message", "")
-
-        if sanitize:
-            title = _sanitize(title)
-            message = _sanitize(message)
-
-        return f"""
-            <div class="cdx-block cdx-warning">
-                <div class="cdx-input cdx-warning__title">{title}</div>
-                <div class="cdx-input cdx-warning__message">{message}</div>
-            </div>
-        """
-
-
-@block("raw")
-class RawBlock(EditorJsBlock):
-    def html(self, sanitize: bool = False) -> str:
-        html = self.data.get("html", "")
-        if sanitize:
-            html = _sanitize(html)
-        return html