marktip 0.1.0__tar.gz

marktip-0.1.0/.github/workflows/build-distributions.yml

@@ -0,0 +1,65 @@
+name: Build distributions
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.x"
+
+      - name: Install build tools
+        run: python -m pip install build twine
+
+      - name: Build sdist
+        run: python -m build --sdist --outdir dist
+
+      - name: Check sdist
+        run: python -m twine check dist/*
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: marktip-sdist
+          path: dist/*.tar.gz
+
+  wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-15-intel, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-python@v6
+
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==4.1.0
+
+      - name: Build wheels
+        run: python -m cibuildwheel --output-dir wheelhouse
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: marktip-wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl

marktip-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+build/
+dist/
+*.egg-info/
+*.whl
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.venv/

marktip-0.1.0/CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(marktip LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(NOT DEFINED SKBUILD_PROJECT_VERSION)
+  set(SKBUILD_PROJECT_VERSION "0.1.0")
+endif()
+
+set(PYBIND11_FINDPYTHON ON)
+find_package(pybind11 CONFIG REQUIRED)
+
+add_library(md4c STATIC
+  third_party/md4c/src/md4c.c
+  third_party/md4c/src/entity.c
+)
+target_include_directories(md4c PUBLIC third_party/md4c/src)
+target_compile_definitions(md4c PRIVATE MD4C_USE_UTF8)
+set_target_properties(md4c PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+pybind11_add_module(_core
+  src/ast.cpp
+  src/marktip.cpp
+  src/parser.cpp
+  src/serializer.cpp
+)
+target_link_libraries(_core PRIVATE md4c)
+target_include_directories(_core PRIVATE third_party/md4c/src)
+target_compile_definitions(_core PRIVATE MARKTIP_VERSION="${SKBUILD_PROJECT_VERSION}")
+
+if(MSVC)
+  target_compile_options(_core PRIVATE /O2)
+else()
+  target_compile_options(_core PRIVATE -O3 -Wall -Wextra -Wpedantic)
+endif()
+
+install(TARGETS _core LIBRARY DESTINATION marktip)

marktip-0.1.0/LICENSE

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

marktip-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: marktip
+Version: 0.1.0
+Summary: Fast C++/MD4C Markdown parser and canonical Markdown serializer for Tiptap-style JSON
+Keywords: markdown,tiptap,md4c,parser
+Author: Saneaven (Minjae Kyung)
+License-Expression: MIT
+License-File: LICENSE
+License-File: third_party/md4c/LICENSE.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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 :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.9
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Description-Content-Type: text/markdown
+
+# marktip
+
+Fast C++/MD4C Markdown conversion for Tiptap-style JSON.
+
+## Installation
+
+```bash
+python -m pip install marktip
+```
+
+Release wheels are built for common CPython versions on Linux, macOS, and
+Windows. If a wheel is not available for a platform, pip can build from the
+source distribution with a C++17 compiler and standard Python build tooling.
+
+## Usage
+
+```python
+import marktip as tm
+
+doc = tm.from_markdown("# Hello")
+ast = doc.to_dict()
+markdown = doc.to_markdown()
+
+doc = tm.from_dict(ast)
+```
+
+The first version targets GFM core syntax and canonical Markdown output rather
+than byte-identical source preservation.
+
+## Development
+
+```bash
+python -m pip install .[test]
+python -m pytest
+```
+
+For a direct local CMake build:
+
+```bash
+cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+cmake --build build
+PYTHONPATH=python python -m pytest
+PYTHONPATH=python python scripts/benchmark.py
+```

marktip-0.1.0/README.md

@@ -0,0 +1,45 @@
+# marktip
+
+Fast C++/MD4C Markdown conversion for Tiptap-style JSON.
+
+## Installation
+
+```bash
+python -m pip install marktip
+```
+
+Release wheels are built for common CPython versions on Linux, macOS, and
+Windows. If a wheel is not available for a platform, pip can build from the
+source distribution with a C++17 compiler and standard Python build tooling.
+
+## Usage
+
+```python
+import marktip as tm
+
+doc = tm.from_markdown("# Hello")
+ast = doc.to_dict()
+markdown = doc.to_markdown()
+
+doc = tm.from_dict(ast)
+```
+
+The first version targets GFM core syntax and canonical Markdown output rather
+than byte-identical source preservation.
+
+## Development
+
+```bash
+python -m pip install .[test]
+python -m pytest
+```
+
+For a direct local CMake build:
+
+```bash
+cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+cmake --build build
+PYTHONPATH=python python -m pytest
+PYTHONPATH=python python scripts/benchmark.py
+```

marktip-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["scikit-build-core>=0.10", "pybind11>=2.12"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "marktip"
+version = "0.1.0"
+description = "Fast C++/MD4C Markdown parser and canonical Markdown serializer for Tiptap-style JSON"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE", "third_party/md4c/LICENSE.md"]
+authors = [{ name = "Saneaven (Minjae Kyung)" }]
+keywords = ["markdown", "tiptap", "md4c", "parser"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: C++",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Text Processing :: Markup :: Markdown",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8"]
+
+[tool.scikit-build]
+cmake.build-type = "Release"
+wheel.packages = ["python/marktip"]
+sdist.include = [
+  "third_party/md4c/src/md4c.c",
+  "third_party/md4c/src/md4c.h",
+  "third_party/md4c/src/entity.c",
+  "third_party/md4c/src/entity.h",
+  "third_party/md4c/LICENSE.md",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.cibuildwheel]
+build = "cp39-* cp310-* cp311-* cp312-* cp313-* cp314-*"
+skip = ["*-win32", "*-manylinux_i686", "*-musllinux*"]
+test-extras = ["test"]
+test-command = "pytest {project}/tests"

marktip-0.1.0/python/marktip/__init__.py

@@ -0,0 +1,27 @@
+"""Fast Markdown conversion for Tiptap-style JSON."""
+
+try:
+    from ._core import Document, __version__, from_dict, from_markdown
+except ImportError:  # pragma: no cover - development-only CMake build fallback
+    import importlib.util
+    import pathlib
+    import sys
+
+    _root = pathlib.Path(__file__).resolve().parents[2]
+    _candidates = sorted(_root.glob("build/**/_core*.so")) + sorted(_root.glob("build/**/_core*.pyd"))
+    if not _candidates:
+        raise
+
+    _spec = importlib.util.spec_from_file_location("marktip._core", _candidates[0])
+    if _spec is None or _spec.loader is None:
+        raise
+    _module = importlib.util.module_from_spec(_spec)
+    sys.modules[_spec.name] = _module
+    _spec.loader.exec_module(_module)
+
+    __version__ = _module.__version__
+    Document = _module.Document
+    from_dict = _module.from_dict
+    from_markdown = _module.from_markdown
+
+__all__ = ["__version__", "Document", "from_markdown", "from_dict"]

marktip-0.1.0/scripts/benchmark.py

@@ -0,0 +1,131 @@
+"""Local performance smoke test with a large mixed Markdown document.
+
+Run after building/installing the package:
+
+    PYTHONPATH=python python scripts/benchmark.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import time
+import tracemalloc
+
+import marktip as tm
+
+
+LOREM = (
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
+    "Praesent vitae augue sed neque efficitur vulputate. "
+    "Integer non sem at orci pretium aliquet. "
+    "Suspendisse potenti, sed fermentum risus sagittis in. "
+    "Curabitur blandit, nibh in dignissim gravida, sapien risus feugiat arcu, "
+    "vel pretium erat sem vitae erat. "
+)
+
+
+def lorem_words(repetitions: int) -> str:
+    return LOREM * repetitions
+
+
+def make_fixture(sections: int = 1_200, lorem_repetitions: int = 4) -> str:
+    chunks: list[str] = ["# Synthetic Lorem Markdown Corpus\n\n"]
+    long_lorem = lorem_words(lorem_repetitions)
+
+    for index in range(sections):
+        checked = "x" if index % 2 == 0 else " "
+        chunks.append(
+            f"## Section {index}: Lorem Throughput\n\n"
+            f"{long_lorem}"
+            f"This paragraph mixes **bold emphasis {index}**, *italic phrasing*, "
+            f"~~deleted context~~, `inline_code_{index}`, "
+            f"[reference link](https://example.com/docs/{index}), and <span data-i=\"{index}\">inline HTML</span>.  \n"
+            f"It also keeps a hard break before continuing with more prose. {long_lorem}\n\n"
+            f"> {long_lorem}"
+            f"> Nested quotation with **strong text**, [a citation](https://example.com/cite/{index}), "
+            f"> and enough lorem ipsum to look like a real imported document.\n\n"
+            f"- [{checked}] Review generated section {index}\n"
+            f"- [ ] Normalize serializer output for section {index}\n"
+            f"- [ ] Compare parse and serialization latency\n\n"
+            f"1. Ordered item alpha for section {index}\n"
+            f"2. Ordered item beta with `code` and **marks**\n"
+            f"   - Nested bullet carries {long_lorem[:180]}\n\n"
+            "| Metric | Value | Notes |\n"
+            "| :--- | ---: | :--- |\n"
+            f"| section | {index} | lorem table cell with **markdown** and pipes escaped later |\n"
+            f"| bytes | {len(long_lorem)} | [source](https://example.com/bench/{index}) |\n\n"
+            "```cpp\n"
+            f"// synthetic code block for section {index}\n"
+            "int accumulate_markdown_nodes(int base) {\n"
+            "    int total = base;\n"
+            "    for (int i = 0; i < 32; ++i) {\n"
+            "        total += i * 3;\n"
+            "    }\n"
+            "    return total;\n"
+            "}\n"
+            "```\n\n"
+        )
+
+        if index % 10 == 0:
+            chunks.append(f"<section data-benchmark=\"{index}\">raw html block</section>\n\n")
+
+    return "".join(chunks)
+
+
+def count_nodes(node: dict) -> int:
+    return 1 + sum(count_nodes(child) for child in node.get("content", []))
+
+
+def mib(value: int) -> float:
+    return value / (1024 * 1024)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--sections", type=int, default=1_200)
+    parser.add_argument("--lorem-repetitions", type=int, default=4)
+    parser.add_argument("--threads", type=int, default=4)
+    args = parser.parse_args()
+
+    markdown = make_fixture(args.sections, args.lorem_repetitions)
+    input_bytes = len(markdown.encode("utf-8"))
+    size_mb = mib(input_bytes)
+
+    start = time.perf_counter()
+    doc = tm.from_markdown(markdown)
+    parse_seconds = time.perf_counter() - start
+
+    start = time.perf_counter()
+    ast = doc.to_dict()
+    to_dict_seconds = time.perf_counter() - start
+    node_count = count_nodes(ast)
+
+    tracemalloc.start()
+    tm.from_markdown(markdown)
+    _, peak_bytes = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    start = time.perf_counter()
+    serialized = doc.to_markdown()
+    serialize_seconds = time.perf_counter() - start
+    output_bytes = len(serialized.encode("utf-8"))
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=args.threads) as pool:
+        start = time.perf_counter()
+        list(pool.map(tm.from_markdown, [markdown] * args.threads))
+        threaded_seconds = time.perf_counter() - start
+
+    print(f"sections: {args.sections}")
+    print(f"input: {size_mb:.2f} MiB")
+    print(f"output: {mib(output_bytes):.2f} MiB")
+    print(f"ast nodes: {node_count:,}")
+    print(f"markdown -> Document: {size_mb / parse_seconds:.2f} MiB/s ({parse_seconds:.3f}s)")
+    print(f"python peak during parse: {peak_bytes / (1024 * 1024):.2f} MiB")
+    print(f"Document -> Markdown: {size_mb / serialize_seconds:.2f} MiB/s ({serialize_seconds:.3f}s)")
+    print(f"Document -> dict: {node_count / to_dict_seconds:.0f} nodes/s ({to_dict_seconds:.3f}s)")
+    print(f"{args.threads} threaded parses: {(size_mb * args.threads) / threaded_seconds:.2f} MiB/s ({threaded_seconds:.3f}s)")
+
+
+if __name__ == "__main__":
+    main()