mdformat-py-edu-fr 0.1.5__py3-none-any.whl

mdformat_myst_pef/LICENSE

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

mdformat_myst_pef/__init__.py

@@ -0,0 +1,3 @@
+"""Mdformat plugin for MyST compatibility."""
+
+__version__ = "0.2.2"

mdformat_myst_pef/_directives.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableMapping, Sequence
+import io
+
+from markdown_it import MarkdownIt
+from mdformat.renderer import LOGGER, RenderContext, RenderTreeNode
+import ruamel.yaml
+
+yaml = ruamel.yaml.YAML()
+yaml.indent(mapping=2, sequence=4, offset=2)
+
+
+def longest_consecutive_sequence(seq: str, char: str) -> int:
+    """Return length of the longest consecutive sequence of `char` characters
+    in string `seq`."""
+    assert len(char) == 1
+    longest = 0
+    current_streak = 0
+    for c in seq:
+        if c == char:
+            current_streak += 1
+        else:
+            current_streak = 0
+        if current_streak > longest:
+            longest = current_streak
+    return longest
+
+
+def fence(node: "RenderTreeNode", context: "RenderContext") -> str:
+    """Render fences (and directives).
+
+    Copied from upstream `mdformat` core and should be kept up-to-date
+    if upstream introduces changes. Note that only two lines are added
+    to the upstream implementation, i.e. the condition that calls
+    `format_directive_content` function.
+    """
+    info_str = node.info.strip()
+    lang = info_str.split(maxsplit=1)[0] if info_str else ""
+    code_block = node.content
+
+    # Info strings of backtick code fences can not contain backticks or tildes.
+    # If that is the case, we make a tilde code fence instead.
+    if "`" in info_str or "~" in info_str:
+        fence_char = "~"
+    else:
+        fence_char = "`"
+
+    # Format the code block using enabled codeformatter funcs
+    if lang in context.options.get("codeformatters", {}):
+        fmt_func = context.options["codeformatters"][lang]
+        try:
+            code_block = fmt_func(code_block, info_str)
+        except Exception:
+            # Swallow exceptions so that formatter errors (e.g. due to
+            # invalid code) do not crash mdformat.
+            assert node.map is not None, "A fence token must have `map` attribute set"
+            LOGGER.warning(
+                f"Failed formatting content of a {lang} code block "
+                f"(line {node.map[0] + 1} before formatting)"
+            )
+    # This "elif" is the *only* thing added to the upstream `fence` implementation!
+    elif lang.startswith("{") and lang.endswith("}"):
+        code_block = format_directive_content(code_block)
+
+    # The code block must not include as long or longer sequence of `fence_char`s
+    # as the fence string itself
+    fence_len = max(3, longest_consecutive_sequence(code_block, fence_char) + 1)
+    fence_str = fence_char * fence_len
+
+    return f"{fence_str}{info_str}\n{code_block}{fence_str}"
+
+
+def format_directive_content(raw_content: str) -> str:
+    parse_result = parse_opts_and_content(raw_content)
+    if not parse_result:
+        return raw_content
+    unformatted_yaml, content = parse_result
+    dump_stream = io.StringIO()
+    try:
+        parsed = yaml.load(unformatted_yaml)
+        yaml.dump(parsed, stream=dump_stream)
+    except ruamel.yaml.YAMLError:
+        LOGGER.warning("Invalid YAML in MyST directive options.")
+        return raw_content
+    formatted_yaml = dump_stream.getvalue()
+
+    # Remove the YAML closing tag if added by `ruamel.yaml`
+    if formatted_yaml.endswith("\n...\n"):
+        formatted_yaml = formatted_yaml[:-4]
+
+    # Convert empty YAML to most concise form
+    if formatted_yaml == "null\n":
+        formatted_yaml = ""
+
+    formatted = "---\n" + formatted_yaml + "---\n"
+    if content:
+        formatted += content + "\n"
+    return formatted
+
+
+def parse_opts_and_content(raw_content: str) -> tuple[str, str] | None:
+    if not raw_content:
+        return None
+    lines = raw_content.splitlines()
+    line = lines.pop(0)
+    yaml_lines = []
+    if all(c == "-" for c in line) and len(line) >= 3:
+        while lines:
+            line = lines.pop(0)
+            if all(c == "-" for c in line) and len(line) >= 3:
+                break
+            yaml_lines.append(line)
+    elif line.lstrip().startswith(":"):
+        yaml_lines.append(line.lstrip()[1:])
+        while lines:
+            if not lines[0].lstrip().startswith(":"):
+                break
+            line = lines.pop(0).lstrip()[1:]
+            yaml_lines.append(line)
+    else:
+        return None
+
+    first_line_is_empty_but_second_line_isnt = (
+        len(lines) >= 2 and not lines[0].strip() and lines[1].strip()
+    )
+    exactly_one_empty_line = len(lines) == 1 and not lines[0].strip()
+    if first_line_is_empty_but_second_line_isnt or exactly_one_empty_line:
+        lines.pop(0)
+
+    unformatted_yaml = "\n".join(yaml_lines)
+    content = "\n".join(lines)
+    return unformatted_yaml, content
+
+
+def render_fence_html(
+    self: MarkdownIt, tokens: Sequence, idx: int, options: Mapping, env: MutableMapping
+) -> str:
+    return ""

mdformat_myst_pef/plugin.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import re
+import textwrap
+
+from markdown_it import MarkdownIt
+import mdformat.plugins
+from mdformat.renderer import RenderContext, RenderTreeNode
+from mdit_py_plugins.dollarmath import dollarmath_plugin
+from mdit_py_plugins.myst_blocks import myst_block_plugin
+from mdit_py_plugins.myst_role import myst_role_plugin
+from mdit_py_plugins.container import container_plugin
+
+from mdformat_myst_pef._directives import fence, render_fence_html
+
+_TARGET_PATTERN = re.compile(r"^\s*\(.+\)=\s*$")
+_ROLE_NAME_PATTERN = re.compile(r"({[a-zA-Z0-9_\-+:]+})")
+_YAML_HEADER_PATTERN = re.compile(r"(?m)(^:\w+: .*$\n?)+|^---$\n(?s:.).*\n---\n")
+
+container_names = [
+    "admonition",
+    "attention",
+    "caution",
+    "danger",
+    "div",
+    "dropdown",
+    "embed",
+    "error",
+    "exercise",
+    "exercise-end",
+    "exercise-start",
+    "figure",
+    "glossary",
+    "grid",
+    "grid-item",
+    "grid-item-card",
+    "hint",
+    "image",
+    "important",
+    "include",
+    "index",
+    "literal-include",
+    "margin",
+    "math",
+    "note",
+    "prf:algorithm",
+    "prf:assumption",
+    "prf:axiom",
+    "prf:conjecture",
+    "prf:corollary",
+    "prf:criterion",
+    "prf:definition",
+    "prf:example",
+    "prf:lemma",
+    "prf:observation",
+    "prf:proof",
+    "prf:property",
+    "prf:proposition",
+    "prf:remark",
+    "prf:theorem",
+    "seealso",
+    "show-index",
+    "sidebar",
+    "solution",
+    "solution-end",
+    "solution-start",
+    "span",
+    "tab-item",
+    "tab-set",
+    "table",
+    "tip",
+    "todo",
+    "topics",
+    "warning",
+]
+
+
+def update_mdit(mdit: MarkdownIt) -> None:
+    # Enable mdformat-tables plugin
+    tables_plugin = mdformat.plugins.PARSER_EXTENSIONS["tables"]
+    if tables_plugin not in mdit.options["parser_extension"]:
+        mdit.options["parser_extension"].append(tables_plugin)
+        tables_plugin.update_mdit(mdit)
+
+    # Enable mdformat-frontmatter plugin
+    frontmatter_plugin = mdformat.plugins.PARSER_EXTENSIONS["frontmatter"]
+    if frontmatter_plugin not in mdit.options["parser_extension"]:
+        mdit.options["parser_extension"].append(frontmatter_plugin)
+        frontmatter_plugin.update_mdit(mdit)
+
+    # Enable mdformat-footnote plugin
+    footnote_plugin = mdformat.plugins.PARSER_EXTENSIONS["footnote"]
+    if footnote_plugin not in mdit.options["parser_extension"]:
+        mdit.options["parser_extension"].append(footnote_plugin)
+        footnote_plugin.update_mdit(mdit)
+
+    # Enable MyST role markdown-it extension
+    mdit.use(myst_role_plugin)
+
+    # Enable MyST block markdown-it extension (including "LineComment",
+    # "BlockBreak" and "Target" syntaxes)
+    mdit.use(myst_block_plugin)
+
+    # Enable dollarmath markdown-it extension
+    mdit.use(dollarmath_plugin)
+
+    # Trick `mdformat`s AST validation by removing HTML rendering of code
+    # blocks and fences. Directives are parsed as code fences and we
+    # modify them in ways that don't break MyST AST but do break
+    # CommonMark AST, so we need to do this to make validation pass.
+    mdit.add_render_rule("fence", render_fence_html)
+    mdit.add_render_rule("code_block", render_fence_html)
+
+    for name in container_names:
+        container_plugin(mdit, name="{" + name + "}", marker=":")
+
+
+def container_renderer(
+    node: RenderTreeNode, context: RenderContext, *args, **kwargs
+) -> str:
+    children = node.children
+    paragraphs = []
+    if children:
+        # Look at the tokens forming the first paragraph and see if
+        # they form a YAML header. This could be stricter: there
+        # should be exactly three tokens: paragraph open, YAML
+        # header, paragraph end.
+        tokens = children[0].to_tokens()
+        if all(
+            token.type in {"paragraph_open", "paragraph_close"}
+            or _YAML_HEADER_PATTERN.fullmatch(token.content)
+            for token in tokens
+        ):
+            paragraphs.append(
+                "\n".join(token.content.strip() for token in tokens if token.content)
+            )
+            # and skip that first paragraph
+            children = children[1:]
+
+    paragraphs.extend(child.render(context) for child in children)
+
+    return node.markup + node.info + "\n" + "\n\n".join(paragraphs) + "\n" + node.markup
+
+
+def _role_renderer(node: RenderTreeNode, context: RenderContext) -> str:
+    role_name = "{" + node.meta["name"] + "}"
+    role_content = f"`{node.content}`"
+    return role_name + role_content
+
+
+def _comment_renderer(node: RenderTreeNode, context: RenderContext) -> str:
+    return "%" + node.content.replace("\n", "\n%")
+
+
+def _blockbreak_renderer(node: RenderTreeNode, context: RenderContext) -> str:
+    text = "+++"
+    if node.content:
+        text += f" {node.content}"
+    return text
+
+
+def _target_renderer(node: RenderTreeNode, context: RenderContext) -> str:
+    return f"({node.content})="
+
+
+def _math_inline_renderer(node: RenderTreeNode, context: RenderContext) -> str:
+    return f"${node.content}$"
+
+
+def _math_block_renderer(node: RenderTreeNode, context: RenderContext) -> str:
+    indent_width = context.env.get("indent_width", 0)
+    if indent_width > 0:
+        return f"$${textwrap.dedent(node.content)}$$"
+    return f"$${node.content}$$"
+
+
+def _math_block_label_renderer(node: RenderTreeNode, context: RenderContext) -> str:
+    return f"{_math_block_renderer(node, context)} ({node.info})"
+
+
+def _math_block_safe_blockquote_renderer(
+    node: RenderTreeNode, context: RenderContext
+) -> str:
+    marker = "> "
+    with context.indented(len(marker)):
+        lines = []
+        for i, child in enumerate(node.children):
+            if child.type in ("math_block", "math_block_label"):
+                lines.append(child.render(context))
+            else:
+                lines.extend(child.render(context).splitlines())
+            if i < (len(node.children) - 1):
+                lines.append("")
+        if not lines:
+            return ">"
+        quoted_lines = (f"{marker}{line}" if line else ">" for line in lines)
+        quoted_str = "\n".join(quoted_lines)
+        return quoted_str
+
+
+def _render_children(node: RenderTreeNode, context: RenderContext) -> str:
+    return "\n\n".join(child.render(context) for child in node.children)
+
+
+def _escape_paragraph(text: str, node: RenderTreeNode, context: RenderContext) -> str:
+    lines = text.split("\n")
+
+    for i in range(len(lines)):
+        # Three or more "+" chars are interpreted as a block break. Escape them.
+        space_removed = lines[i].replace(" ", "")
+        if space_removed.startswith("+++"):
+            lines[i] = lines[i].replace("+", "\\+", 1)
+
+        # A line starting with "%" is a comment. Escape.
+        if lines[i].startswith("%"):
+            lines[i] = f"\\{lines[i]}"
+
+        # Escape lines that look like targets
+        if _TARGET_PATTERN.search(lines[i]):
+            lines[i] = lines[i].replace("(", "\\(", 1)
+
+    return "\n".join(lines)
+
+
+def _escape_text(text: str, node: RenderTreeNode, context: RenderContext) -> str:
+    # Escape MyST role names
+    text = _ROLE_NAME_PATTERN.sub(r"\\\1", text)
+
+    # Escape inline and block dollarmath
+    text = text.replace("$", "\\$")
+
+    return text
+
+
+RENDERERS = {
+    "blockquote": _math_block_safe_blockquote_renderer,
+    "myst_role": _role_renderer,
+    "myst_line_comment": _comment_renderer,
+    "myst_block_break": _blockbreak_renderer,
+    "myst_target": _target_renderer,
+    "math_inline": _math_inline_renderer,
+    "math_block_label": _math_block_label_renderer,
+    "math_block": _math_block_renderer,
+    "fence": fence,
+}
+
+
+for name in container_names:
+    RENDERERS["container_{" + name + "}"] = container_renderer
+
+POSTPROCESSORS = {"paragraph": _escape_paragraph, "text": _escape_text}

mdformat_myst_pef/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

mdformat_py_edu_fr/__init__.py

@@ -0,0 +1,118 @@
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import mdformat
+
+from .format_with_jupytext import format_str
+
+try:
+    from importlib.metadata import version
+
+    __version__ = version("mdformat-py-edu-fr")
+except Exception:
+    __version__ = "unknown"
+
+from mdformat._conf import DEFAULT_OPTS
+
+options = DEFAULT_OPTS.copy()
+options.update({"number": True, "wrap": 89, "end_of_line": "lf"})
+
+
+def _match_patterns(path: Path, patterns: List[str]) -> bool:
+    """
+    Check if a path matches any of the given glob patterns.
+
+    Args:
+        path: Path to check
+        patterns: List of glob patterns
+
+    Returns:
+        True if path matches any pattern, False otherwise
+    """
+    for pattern in patterns:
+        if path.match(pattern) or path.full_match(pattern):
+            return True
+    return False
+
+
+def collect_markdown_files(
+    paths: List[Path], exclude_patterns: List[str] = None
+) -> List[Path]:
+    """
+    Collect all Markdown files from the given paths.
+
+    Args:
+        paths: List of file or directory paths
+        exclude_patterns: List of glob patterns to exclude
+
+    Returns:
+        List of Path objects pointing to Markdown files
+    """
+    if exclude_patterns is None:
+        exclude_patterns = []
+
+    markdown_files = []
+
+    for path in paths:
+        if not path.exists():
+            print(f"Error: Path does not exist: {path}", file=sys.stderr)
+            continue
+
+        if path.is_file():
+            if path.suffix in {".md", ".markdown"}:
+                # Check if file matches any exclude pattern
+                if not _match_patterns(path, exclude_patterns):
+                    markdown_files.append(path)
+            else:
+                print(f"Warning: Skipping non-Markdown file: {path}", file=sys.stderr)
+        elif path.is_dir():
+            # Recursively find all Markdown files
+            for md_file in path.rglob("*.md"):
+                if not _match_patterns(md_file, exclude_patterns):
+                    markdown_files.append(md_file)
+            for md_file in path.rglob("*.markdown"):
+                if not _match_patterns(md_file, exclude_patterns):
+                    markdown_files.append(md_file)
+        else:
+            print(f"Warning: Skipping special file: {path}", file=sys.stderr)
+
+    return sorted(set(markdown_files))
+
+
+def format_file(filepath: Path, check: bool = False, verbose: bool = False) -> bool:
+    """
+    Format a single Markdown file.
+
+    Args:
+        filepath: Path to the file to format
+        check: If True, only check formatting without modifying
+        verbose: If True, print detailed information
+
+    Returns:
+        True if file is properly formatted (or was formatted), False otherwise
+    """
+    if verbose:
+        print(f"Processing: {filepath}")
+
+    original_str = filepath.read_text()
+
+    enabled_parserplugins = mdformat.plugins.PARSER_EXTENSIONS
+
+    formatted_str = mdformat.text(
+        original_str,
+        options=options,
+        extensions=enabled_parserplugins,
+        _filename=str(filepath),
+    )
+
+    formatted_str = format_str(formatted_str)
+
+    formatted = formatted_str == original_str
+
+    if check or formatted:
+        return formatted
+
+    filepath.write_text(formatted_str)
+    print(f"{filepath} reformatted")
+    return formatted

mdformat_py_edu_fr/__main__.py

@@ -0,0 +1,100 @@
+"""
+Markdown formatter for py-edu-fr with mdformat, mdformat-myst, and jupytext support.
+"""
+
+import argparse
+import sys
+
+from pathlib import Path
+
+from . import __version__, format_file, collect_markdown_files
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="mdformat-py-edu-fr",
+        description="Format Markdown files for py-edu-fr project",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        type=Path,
+        help="Files or directories to format (if omitted, reads from stdin)",
+    )
+
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Check if files are formatted without modifying them (exit code 1 if changes needed)",
+    )
+
+    parser.add_argument(
+        "--exclude",
+        action="append",
+        default=[],
+        metavar="PATTERN",
+        help="Glob pattern to exclude files/directories (can be specified multiple times)",
+    )
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Print detailed information about processing",
+    )
+
+    return parser
+
+
+def main() -> int:
+    """
+    Main entrypoint for the mdformat-py-edu-fr command.
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    parser = get_parser()
+    args = parser.parse_args()
+
+    # Handle stdin if no paths provided
+    if not args.paths:
+        print("Error: Reading from stdin not yet implemented", file=sys.stderr)
+        return 1
+
+    # Collect all Markdown files
+    markdown_files = collect_markdown_files(args.paths, args.exclude)
+
+    if not markdown_files:
+        print("No Markdown files found", file=sys.stderr)
+        return 1
+
+    if args.verbose:
+        print(f"Found {len(markdown_files)} Markdown file(s)")
+
+    # Process each file
+    all_formatted = True
+    for filepath in markdown_files:
+        formatted = format_file(filepath, check=args.check, verbose=args.verbose)
+        if not formatted:
+            all_formatted = False
+            if args.check:
+                print(f"Would reformat: {filepath}")
+
+    # Return appropriate exit code
+    if args.check and not all_formatted:
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mdformat_py_edu_fr/format_with_jupytext.py

@@ -0,0 +1,53 @@
+import jupytext
+import re
+
+from pathlib import Path
+
+from mdformat_py_edu_fr.util_ruff import format_code_with_ruff, RuffFormattingError
+
+
+LABEL_PATTERN = re.compile("(?m)(^\\s*\\(\\w+\\)=)(\r?\n)(\\s*\r?\n)")
+
+path_config_file = Path(__file__).absolute().parent / "jupytext.toml"
+config = jupytext.config.load_jupytext_configuration_file(str(path_config_file))
+
+
+def format_str(text: str) -> str:
+    """Format the code of a notebook code using jupytext"""
+
+    notebook = jupytext.reads(text, fmt="md:myst")
+    if "kernelspec" not in notebook.metadata:
+        return text
+    language = notebook["metadata"]["kernelspec"]["language"]
+    if "learning" in notebook.metadata:
+        # Fix common errors in learning metadata
+        learning = notebook.metadata["learning"]
+        for a in ["prerequisites", "objectives"]:
+            # Fix singular instead of plural
+            singular = a[:-1]
+            if singular in learning:
+                learning[a] = learning[singular]
+                del learning[singular]
+
+            # Fix string instead of list of string
+            for b in ["discover", "remember", "understand", "apply"]:
+                if a in learning and isinstance(learning[a].get(b), str):
+                    learning[a][b] = [s.strip() for s in learning[a][b].split(",")]
+
+    for cell in notebook.cells:
+        if language == "python" and cell["cell_type"] == "code":
+            cell.source = format_code_with_ruff(cell["source"].strip())
+        if (
+            cell.metadata is not None
+            and "tags" in cell.metadata
+            and cell.metadata["tags"] == []
+        ):
+            del cell.metadata["tags"]
+        # Workaround mdformat-myst to remove empty lines between label and subsequent item
+        if cell.cell_type == "markdown":
+            cell.source = re.sub(LABEL_PATTERN, r"\1\2", cell.source)
+
+    result = jupytext.writes(notebook, fmt="md:myst", config=config)
+    if language == "python":
+        result = result.replace("```{code-cell} ipython3", "```{code-cell}")
+    return result

mdformat_py_edu_fr/jupytext.toml

@@ -0,0 +1,18 @@
+# This file configures which notebook or cell metadata is kept or
+# discarded upon saving a file with jupytext / jupyter lab.
+#
+# - discard jupytext.text_representation.jupytext_version: including
+#   the jupytext version in the metadata adds no value and causes
+#   conflicts.
+#
+# - keep learning metadata: this is used in certain notebooks for
+#   specifying learning objectives, etc.
+#
+# - discard cell metadata that describes the transient state of the
+#   notebook
+#
+# - discard editable / deletable metadata: these are to be set
+#   automatically upon preparing the student version of the notebooks
+
+notebook_metadata_filter="kernelspec,jupytext,exports,math,learning,-jupytext.text_representation.jupytext_version"
+cell_metadata_filter="all,-autoscroll,-collapsed,-scrolled,-trusted,-ExecuteTime,-jp-MarkdownHeadingCollapsed,-user_expressions,-editable,-deletable"

mdformat_py_edu_fr/util_ruff.py

@@ -0,0 +1,30 @@
+import subprocess
+import sys
+
+
+class RuffFormattingError(Exception):
+    """Exception raised when ruff formatting fails."""
+
+    pass
+
+
+def format_code_with_ruff(code: str) -> str:
+    """Format Python code using ruff.
+
+    Returns formatted code.
+
+    Raises:
+        RuffFormattingError: If ruff formatting fails.
+    """
+    result = subprocess.run(
+        ["ruff", "format", "-"],
+        input=code.encode("utf-8"),
+        capture_output=True,
+        check=False,
+    )
+
+    if result.returncode != 0:
+        error_msg = result.stderr.decode("utf-8")
+        raise RuffFormattingError(f"ruff formatting failed: {error_msg}")
+
+    return result.stdout.decode("utf-8")

mdformat_py_edu_fr-0.1.5.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: mdformat-py-edu-fr
+Version: 0.1.5
+Summary: Tiny wrapper around mdformat for the py-edu-fr project
+Author-Email: Pierre Augier <pierre.augier@univ-grenoble-alpes.fr>
+License: BSD-3-Clause
+Requires-Python: >=3.13
+Requires-Dist: jupytext
+Requires-Dist: mdformat>=0.7.0
+Requires-Dist: mdit-py-plugins>=0.3.0
+Requires-Dist: mdformat-frontmatter>=0.3.2
+Requires-Dist: mdformat-footnote>=0.1.1
+Requires-Dist: mdformat-gfm>=1.0.0
+Requires-Dist: ruamel.yaml>=0.16.0
+Requires-Dist: ruff
+Description-Content-Type: text/markdown
+
+# Tiny wrapper around mdformat for the py-edu-fr project

mdformat_py_edu_fr-0.1.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+mdformat_myst_pef/LICENSE,sha256=uAgWsNUwuKzLTCIReDeQmEpuO2GSLCte6S8zcqsnQv4,1072
+mdformat_myst_pef/__init__.py,sha256=aYAObHCbEiPg3WwadhJ_TB7SCk8bGlTTmNMO2tj1Q40,69
+mdformat_myst_pef/_directives.py,sha256=gr9XXHeE1OpEPrUKZdy2S9iI4aQVgX4kO2UyhJlmSEk,4793
+mdformat_myst_pef/plugin.py,sha256=fFqNG4UV_2aNSDYnJxbgV541K3qf7jQ53VMBSB1ktCU,7733
+mdformat_myst_pef/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+mdformat_py_edu_fr-0.1.5.dist-info/METADATA,sha256=UFPdefvVl5vYXSsKREkgKrreg3XOaTF8NqpAFWRQ1q4,603
+mdformat_py_edu_fr-0.1.5.dist-info/WHEEL,sha256=RSz6kXtM6TF3IJK4O7lm4V0QzFJUHF9t5pxUi4i5D34,104
+mdformat_py_edu_fr-0.1.5.dist-info/entry_points.txt,sha256=dNsCwKXSNYQUbo19idpAR7WOLX6XiklUmMmb_Tfj7gs,149
+mdformat_py_edu_fr/__init__.py,sha256=a87wI51gBRuFn1_IauF42noia0IE4t0kmOiJRIWVVl4,3312
+mdformat_py_edu_fr/__main__.py,sha256=SI9uVJaNxyo8MVoAzb2pJWdXszT-zdWl6afekldFn2c,2509
+mdformat_py_edu_fr/format_with_jupytext.py,sha256=GikvHM--0uO-bFKHWgzOExzhwjOluxDEc5lLVP6xUFU,2056
+mdformat_py_edu_fr/jupytext.toml,sha256=ZQwweaKSvIGXWw-lEwJfnzTPSbEqiGQjNmPBxsQVxmQ,872
+mdformat_py_edu_fr/util_ruff.py,sha256=SgzJOvSD0UWz71mHfBu9_EYdV3JFZaFqRxTfMV2_GoM,676
+mdformat_py_edu_fr-0.1.5.dist-info/RECORD,,

mdformat_py_edu_fr-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.6.dev3+g3976183)
+Root-Is-Purelib: true
+Tag: py3-none-any

mdformat_py_edu_fr-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+mdformat-py-edu-fr = mdformat_py_edu_fr.__main__:main
+
+[gui_scripts]
+
+[mdformat.parser_extension]
+myst = mdformat_myst_pef.plugin
+