markdown-exec 1.10.0__py3-none-any.whl → 1.10.2__py3-none-any.whl

markdown_exec/formatters/pycon.py

@@ -1,29 +1,17 @@
-"""Formatter for executing `pycon` code."""
+"""Deprecated. Import from `markdown_exec` directly."""
 
-from __future__ import annotations
+# YORE: Bump 2: Remove file.
 
-from typing import TYPE_CHECKING, Any
+import warnings
+from typing import Any
 
-from markdown_exec.formatters.base import base_format
-from markdown_exec.formatters.python import _run_python
-from markdown_exec.logger import get_logger
+from markdown_exec._internal.formatters import pycon
 
-if TYPE_CHECKING:
-    from markupsafe import Markup
 
-logger = get_logger(__name__)
-
-
-def _transform_source(code: str) -> tuple[str, str]:
-    python_lines = []
-    pycon_lines = []
-    for line in code.split("\n"):
-        if line.startswith((">>> ", "... ")):
-            pycon_lines.append(line)
-            python_lines.append(line[4:])
-    python_code = "\n".join(python_lines)
-    return python_code, "\n".join(pycon_lines)
-
-
-def _format_pycon(**kwargs: Any) -> Markup:
-    return base_format(language="pycon", run=_run_python, transform_source=_transform_source, **kwargs)
+def __getattr__(name: str) -> Any:
+    warnings.warn(
+        "Importing from `markdown_exec.formatters.pycon` is deprecated. Import from `markdown_exec` directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(pycon, name)

markdown_exec/formatters/pyodide.py

@@ -1,70 +1,17 @@
-"""Formatter for creating a Pyodide interactive editor."""
+"""Deprecated. Import from `markdown_exec` directly."""
 
-from __future__ import annotations
+# YORE: Bump 2: Remove file.
 
-from typing import TYPE_CHECKING, Any
+import warnings
+from typing import Any
 
-if TYPE_CHECKING:
-    from markdown import Markdown
+from markdown_exec._internal.formatters import pyodide
 
-# All Ace.js themes listed here:
-# https://github.com/ajaxorg/ace/tree/master/src/theme
 
-play_emoji = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M8 5.14v14l11-7-11-7Z"></path></svg>'
-clear_emoji = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M15.14 3c-.51 0-1.02.2-1.41.59L2.59 14.73c-.78.77-.78 2.04 0 2.83L5.03 20h7.66l8.72-8.73c.79-.77.79-2.04 0-2.83l-4.85-4.85c-.39-.39-.91-.59-1.42-.59M17 18l-2 2h7v-2"></path></svg>'
-
-assets = """
-<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.16.0/ace.js"></script>
-<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/highlight.min.js"></script>
-<script type="text/javascript" src="https://cdn.jsdelivr.net/pyodide/v{version}/full/pyodide.js"></script>
-<link title="light" rel="alternate stylesheet" href="https://cdn.jsdelivr.net/npm/highlightjs-themes@1.0.0/tomorrow.min.css" disabled="disabled">
-<link title="dark" rel="alternate stylesheet" href="https://cdn.jsdelivr.net/npm/highlightjs-themes@1.0.0/tomorrow-night-blue.min.css" disabled="disabled">
-"""
-
-template = """
-<div class="pyodide">
-<div class="pyodide-editor-bar">
-<span class="pyodide-bar-item">Editor (session: %(session)s)</span><span id="%(id_prefix)srun" title="Run: press Ctrl-Enter" class="pyodide-bar-item pyodide-clickable"><span class="twemoji">%(play_emoji)s</span> Run</span>
-</div>
-<div><pre id="%(id_prefix)seditor" class="pyodide-editor">%(initial_code)s</pre></div>
-<div class="pyodide-editor-bar">
-<span class="pyodide-bar-item">Output</span><span id="%(id_prefix)sclear" class="pyodide-bar-item pyodide-clickable"><span class="twemoji">%(clear_emoji)s</span> Clear</span>
-</div>
-<pre><code id="%(id_prefix)soutput" class="pyodide-output"></code></pre>
-</div>
-
-<script>
-document.addEventListener('DOMContentLoaded', (event) => {
-    setupPyodide('%(id_prefix)s', install=%(install)s, themeLight='%(theme_light)s', themeDark='%(theme_dark)s', session='%(session)s');
-});
-</script>
-"""
-
-_counter = 0
-
-
-def _format_pyodide(code: str, md: Markdown, session: str, extra: dict, **options: Any) -> str:  # noqa: ARG001
-    global _counter  # noqa: PLW0603
-    _counter += 1
-    version = extra.pop("version", "0.26.4").lstrip("v")
-    install = extra.pop("install", "")
-    install = install.split(",") if install else []
-    exclude_assets = extra.pop("assets", "1").lower() in {"0", "false", "no", "off"}
-    theme = extra.pop("theme", "tomorrow,tomorrow_night")
-    if "," not in theme:
-        theme = f"{theme},{theme}"
-    theme_light, theme_dark = theme.split(",")
-    data = {
-        "id_prefix": f"exec-{_counter}--",
-        "initial_code": code,
-        "install": install,
-        "theme_light": theme_light.strip(),
-        "theme_dark": theme_dark.strip(),
-        "session": session or "default",
-        "play_emoji": play_emoji,
-        "clear_emoji": clear_emoji,
-    }
-    rendered = template % data
-    if exclude_assets:
-        return rendered
-    return assets.format(version=version) + rendered
+def __getattr__(name: str) -> Any:
+    warnings.warn(
+        "Importing from `markdown_exec.formatters.pyodide` is deprecated. Import from `markdown_exec` directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(pyodide, name)

markdown_exec/formatters/python.py

@@ -1,85 +1,17 @@
-"""Formatter for executing Python code."""
+"""Deprecated. Import from `markdown_exec` directly."""
 
-from __future__ import annotations
+# YORE: Bump 2: Remove file.
 
-import re
-import sys
-import traceback
-from collections import defaultdict
-from functools import partial
-from io import StringIO
-from types import ModuleType
+import warnings
 from typing import Any
 
-from markdown_exec.formatters._exec_python import exec_python
-from markdown_exec.formatters.base import ExecutionError, base_format
-from markdown_exec.rendering import code_block
+from markdown_exec._internal.formatters import python
 
-_sessions_globals: dict[str, dict] = defaultdict(dict)
-_sessions_counter: dict[str | None, int] = defaultdict(int)
-_code_blocks: dict[str, list[str]] = {}
 
-
-def _buffer_print(buffer: StringIO, *texts: str, end: str = "\n", **kwargs: Any) -> None:  # noqa: ARG001
-    buffer.write(" ".join(str(text) for text in texts) + end)
-
-
-def _code_block_id(
-    id: str | None = None,  # noqa: A002
-    session: str | None = None,
-    title: str | None = None,
-) -> str:
-    _sessions_counter[session] += 1
-    if id:
-        code_block_id = f"id {id}"
-    elif session:
-        code_block_id = f"session {session}; n{_sessions_counter[session]}"
-        if title:
-            code_block_id = f"{code_block_id}; title {title}"
-    else:
-        code_block_id = f"n{_sessions_counter[session]}"
-        if title:
-            code_block_id = f"{code_block_id}; title {title}"
-    return f"<code block: {code_block_id}>"
-
-
-def _run_python(
-    code: str,
-    returncode: int | None = None,  # noqa: ARG001
-    session: str | None = None,
-    id: str | None = None,  # noqa: A002
-    **extra: str,
-) -> str:
-    title = extra.get("title")
-    code_block_id = _code_block_id(id, session, title)
-    _code_blocks[code_block_id] = code.split("\n")
-    exec_globals = _sessions_globals[session] if session else {}
-
-    # Other libraries expect functions to have a valid `__module__` attribute.
-    # To achieve this, we need to add a `__name__` attribute to the globals.
-    # We compute the name from the code block ID, replacing invalid characters with `_`.
-    # We also create a module object with the same name and add it to `sys.modules`,
-    # because that's what yet other libraries expect (`dataclasses` for example).
-    module_name = re.sub(r"[^a-zA-Z\d]+", "_", code_block_id)
-    exec_globals["__name__"] = module_name
-    sys.modules[module_name] = ModuleType(module_name)
-
-    buffer = StringIO()
-    exec_globals["print"] = partial(_buffer_print, buffer)
-
-    try:
-        exec_python(code, code_block_id, exec_globals)
-    except Exception as error:
-        trace = traceback.TracebackException.from_exception(error)
-        for frame in trace.stack:
-            if frame.filename.startswith("<code block: "):
-                if sys.version_info >= (3, 13):
-                    frame._lines = _code_blocks[frame.filename][frame.lineno - 1]  # type: ignore[attr-defined,operator]
-                else:
-                    frame._line = _code_blocks[frame.filename][frame.lineno - 1]  # type: ignore[attr-defined,operator]
-        raise ExecutionError(code_block("python", "".join(trace.format()), **extra)) from error
-    return buffer.getvalue()
-
-
-def _format_python(**kwargs: Any) -> str:
-    return base_format(language="python", run=_run_python, **kwargs)
+def __getattr__(name: str) -> Any:
+    warnings.warn(
+        "Importing from `markdown_exec.formatters.python` is deprecated. Import from `markdown_exec` directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(python, name)

markdown_exec/formatters/sh.py

@@ -1,32 +1,17 @@
-"""Formatter for executing shell code."""
+"""Deprecated. Import from `markdown_exec` directly."""
 
-from __future__ import annotations
+# YORE: Bump 2: Remove file.
 
-import subprocess
+import warnings
 from typing import Any
 
-from markdown_exec.formatters.base import ExecutionError, base_format
-from markdown_exec.rendering import code_block
+from markdown_exec._internal.formatters import sh
 
 
-def _run_sh(
-    code: str,
-    returncode: int | None = None,
-    session: str | None = None,  # noqa: ARG001
-    id: str | None = None,  # noqa: A002,ARG001
-    **extra: str,
-) -> str:
-    process = subprocess.run(  # noqa: S603
-        ["sh", "-c", code],  # noqa: S607
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        text=True,
-        check=False,
+def __getattr__(name: str) -> Any:
+    warnings.warn(
+        "Importing from `markdown_exec.formatters.sh` is deprecated. Import from `markdown_exec` directly.",
+        DeprecationWarning,
+        stacklevel=2,
     )
-    if process.returncode != returncode:
-        raise ExecutionError(code_block("sh", process.stdout, **extra), process.returncode)
-    return process.stdout
-
-
-def _format_sh(**kwargs: Any) -> str:
-    return base_format(language="sh", run=_run_sh, **kwargs)
+    return getattr(sh, name)

markdown_exec/formatters/tree.py

@@ -1,60 +1,17 @@
-"""Formatter for file-system trees."""
+"""Deprecated. Import from `markdown_exec` directly."""
 
-from __future__ import annotations
+# YORE: Bump 2: Remove file.
 
-from textwrap import dedent
-from typing import TYPE_CHECKING, Any
+import warnings
+from typing import Any
 
-from markdown_exec.rendering import MarkdownConverter, code_block
+from markdown_exec._internal.formatters import tree
 
-if TYPE_CHECKING:
-    from markdown import Markdown
 
-
-def _rec_build_tree(lines: list[str], parent: list, offset: int, base_indent: int) -> int:
-    while offset < len(lines):
-        line = lines[offset]
-        lstripped = line.lstrip()
-        indent = len(line) - len(lstripped)
-        if indent == base_indent:
-            parent.append((lstripped, []))
-            offset += 1
-        elif indent > base_indent:
-            offset = _rec_build_tree(lines, parent[-1][1], offset, indent)
-        else:
-            return offset
-    return offset
-
-
-def _build_tree(code: str) -> list[tuple[str, list]]:
-    lines = dedent(code.strip()).split("\n")
-    root_layer: list[tuple[str, list]] = []
-    _rec_build_tree(lines, root_layer, 0, 0)
-    return root_layer
-
-
-def _rec_format_tree(tree: list[tuple[str, list]], *, root: bool = True) -> list[str]:
-    lines = []
-    n_items = len(tree)
-    for index, node in enumerate(tree):
-        last = index == n_items - 1
-        prefix = "" if root else f"{'└' if last else '├'}── "
-        if node[1]:
-            lines.append(f"{prefix}📁 {node[0]}")
-            sublines = _rec_format_tree(node[1], root=False)
-            if root:
-                lines.extend(sublines)
-            else:
-                indent_char = " " if last else "│"
-                lines.extend([f"{indent_char}   {line}" for line in sublines])
-        else:
-            name = node[0].split()[0]
-            icon = "📁" if name.endswith("/") else "📄"
-            lines.append(f"{prefix}{icon} {node[0]}")
-    return lines
-
-
-def _format_tree(code: str, md: Markdown, result: str, **options: Any) -> str:
-    markdown = MarkdownConverter(md)
-    output = "\n".join(_rec_format_tree(_build_tree(code)))
-    return markdown.convert(code_block(result or "bash", output, **options.get("extra", {})))
+def __getattr__(name: str) -> Any:
+    warnings.warn(
+        "Importing from `markdown_exec.formatters.tree` is deprecated. Import from `markdown_exec` directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(tree, name)

markdown_exec/logger.py

@@ -1,92 +1,17 @@
-"""This module contains logging utilities.
+"""Deprecated. Import from `markdown_exec` directly."""
 
-We provide the [`patch_loggers`][markdown_exec.logger.patch_loggers]
-function so dependant libraries can patch loggers as they see fit.
+# YORE: Bump 2: Remove file.
 
-For example, to fit in the MkDocs logging configuration
-and prefix each log message with the module name:
+import warnings
+from typing import Any
 
-```python
-import logging
-from markdown_exec.logger import patch_loggers
+from markdown_exec._internal import logger
 
 
-class LoggerAdapter(logging.LoggerAdapter):
-    def __init__(self, prefix, logger):
-        super().__init__(logger, {})
-        self.prefix = prefix
-
-    def process(self, msg, kwargs):
-        return f"{self.prefix}: {msg}", kwargs
-
-
-def get_logger(name):
-    logger = logging.getLogger(f"mkdocs.plugins.{name}")
-    return LoggerAdapter(name.split(".", 1)[0], logger)
-
-
-patch_loggers(get_logger)
-```
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Callable, ClassVar
-
-
-class _Logger:
-    _default_logger: Any = logging.getLogger
-    _instances: ClassVar[dict[str, _Logger]] = {}
-
-    # See same code in Griffe project.
-    def __init__(self, name: str) -> None:
-        # Default logger that can be patched by third-party.
-        self._logger = self.__class__._default_logger(name)
-
-    def __getattr__(self, name: str) -> Any:
-        # Forward everything to the logger.
-        return getattr(self._logger, name)
-
-    @classmethod
-    def get(cls, name: str) -> _Logger:
-        """Get a logger instance.
-
-        Parameters:
-            name: The logger name.
-
-        Returns:
-            The logger instance.
-        """
-        if name not in cls._instances:
-            cls._instances[name] = cls(name)
-        return cls._instances[name]
-
-    @classmethod
-    def _patch_loggers(cls, get_logger_func: Callable) -> None:
-        # Patch current instances.
-        for name, instance in cls._instances.items():
-            instance._logger = get_logger_func(name)
-        # Future instances will be patched as well.
-        cls._default_logger = get_logger_func
-
-
-def get_logger(name: str) -> _Logger:
-    """Create and return a new logger instance.
-
-    Parameters:
-        name: The logger name.
-
-    Returns:
-        The logger.
-    """
-    return _Logger.get(name)
-
-
-def patch_loggers(get_logger_func: Callable[[str], Any]) -> None:
-    """Patch loggers.
-
-    Parameters:
-        get_logger_func: A function accepting a name as parameter and returning a logger.
-    """
-    _Logger._patch_loggers(get_logger_func)
+def __getattr__(name: str) -> Any:
+    warnings.warn(
+        "Importing from `markdown_exec.logger` is deprecated. Import from `markdown_exec` directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(logger, name)

markdown_exec/mkdocs_plugin.py

@@ -1,141 +1,17 @@
-"""This module contains an optional plugin for MkDocs."""
+"""Deprecated. Import from `markdown_exec` directly."""
 
-from __future__ import annotations
+# YORE: Bump 2: Remove file.
 
-import logging
-import os
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
+import warnings
+from typing import Any
 
-from mkdocs.config import config_options
-from mkdocs.config.base import Config
-from mkdocs.exceptions import PluginError
-from mkdocs.plugins import BasePlugin
-from mkdocs.utils import write_file
+from markdown_exec._internal import mkdocs_plugin
 
-from markdown_exec import formatter, formatters, validator
-from markdown_exec.logger import patch_loggers
-from markdown_exec.rendering import MarkdownConverter, markdown_config
 
-if TYPE_CHECKING:
-    from collections.abc import MutableMapping
-
-    from jinja2 import Environment
-    from mkdocs.config.defaults import MkDocsConfig
-    from mkdocs.structure.files import Files
-
-try:
-    __import__("pygments_ansi_color")
-except ImportError:
-    ansi_ok = False
-else:
-    ansi_ok = True
-
-
-class _LoggerAdapter(logging.LoggerAdapter):
-    def __init__(self, prefix: str, logger: logging.Logger) -> None:
-        super().__init__(logger, {})
-        self.prefix = prefix
-
-    def process(self, msg: str, kwargs: MutableMapping[str, Any]) -> tuple[str, MutableMapping[str, Any]]:
-        return f"{self.prefix}: {msg}", kwargs
-
-
-def _get_logger(name: str) -> _LoggerAdapter:
-    logger = logging.getLogger(f"mkdocs.plugins.{name}")
-    return _LoggerAdapter(name.split(".", 1)[0], logger)
-
-
-patch_loggers(_get_logger)
-
-
-class MarkdownExecPluginConfig(Config):
-    """Configuration of the plugin (for `mkdocs.yml`)."""
-
-    ansi = config_options.Choice(("auto", "off", "required", True, False), default="auto")
-    """Whether the `ansi` extra is required when installing the package."""
-    languages = config_options.ListOfItems(
-        config_options.Choice(formatters.keys()),
-        default=list(formatters.keys()),
+def __getattr__(name: str) -> Any:
+    warnings.warn(
+        "Importing from `markdown_exec.mkdocs_plugin` is deprecated. Import from `markdown_exec` directly.",
+        DeprecationWarning,
+        stacklevel=2,
     )
-    """Which languages to enabled the extension for."""
-
-
-class MarkdownExecPlugin(BasePlugin[MarkdownExecPluginConfig]):
-    """MkDocs plugin to easily enable custom fences for code blocks execution."""
-
-    def on_config(self, config: MkDocsConfig) -> MkDocsConfig | None:
-        """Configure the plugin.
-
-        Hook for the [`on_config` event](https://www.mkdocs.org/user-guide/plugins/#on_config).
-        In this hook, we add custom fences for all the supported languages.
-
-        We also save the Markdown extensions configuration
-        into [`markdown_config`][markdown_exec.rendering.markdown_config].
-
-        Arguments:
-            config: The MkDocs config object.
-
-        Returns:
-            The modified config.
-        """
-        if "pymdownx.superfences" not in config["markdown_extensions"]:
-            message = "The 'markdown-exec' plugin requires the 'pymdownx.superfences' Markdown extension to work."
-            raise PluginError(message)
-        if self.config.ansi in ("required", True) and not ansi_ok:
-            raise PluginError(
-                "The configuration for the 'markdown-exec' plugin requires "
-                "that it is installed with the 'ansi' extra. "
-                "Install it with 'pip install markdown-exec[ansi]'.",
-            )
-        self.mkdocs_config_dir = os.getenv("MKDOCS_CONFIG_DIR")
-        os.environ["MKDOCS_CONFIG_DIR"] = os.path.dirname(config["config_file_path"])
-        self.languages = self.config.languages
-        mdx_configs = config.setdefault("mdx_configs", {})
-        superfences = mdx_configs.setdefault("pymdownx.superfences", {})
-        custom_fences = superfences.setdefault("custom_fences", [])
-        for language in self.languages:
-            custom_fences.append(
-                {
-                    "name": language,
-                    "class": language,
-                    "validator": validator,
-                    "format": formatter,
-                },
-            )
-        markdown_config.save(config.markdown_extensions, config.mdx_configs)
-        return config
-
-    def on_env(  # noqa: D102
-        self,
-        env: Environment,
-        *,
-        config: MkDocsConfig,
-        files: Files,  # noqa: ARG002
-    ) -> Environment | None:
-        if self.config.ansi in ("required", True) or (self.config.ansi == "auto" and ansi_ok):
-            self._add_css(config, "ansi.css")
-        if "pyodide" in self.languages:
-            self._add_css(config, "pyodide.css")
-            self._add_js(config, "pyodide.js")
-        return env
-
-    def on_post_build(self, *, config: MkDocsConfig) -> None:  # noqa: ARG002,D102
-        MarkdownConverter.counter = 0
-        markdown_config.reset()
-        if self.mkdocs_config_dir is None:
-            os.environ.pop("MKDOCS_CONFIG_DIR", None)
-        else:
-            os.environ["MKDOCS_CONFIG_DIR"] = self.mkdocs_config_dir
-
-    def _add_asset(self, config: MkDocsConfig, asset_file: str, asset_type: str) -> None:
-        asset_filename = f"assets/_markdown_exec_{asset_file}"
-        asset_content = Path(__file__).parent.joinpath(asset_file).read_text()
-        write_file(asset_content.encode("utf-8"), os.path.join(config.site_dir, asset_filename))
-        config[f"extra_{asset_type}"].insert(0, asset_filename)
-
-    def _add_css(self, config: MkDocsConfig, css_file: str) -> None:
-        self._add_asset(config, css_file, "css")
-
-    def _add_js(self, config: MkDocsConfig, js_file: str) -> None:
-        self._add_asset(config, js_file, "javascript")
+    return getattr(mkdocs_plugin, name)