MDit 0.0.0.dev0__tar.gz → 0.0.0.dev1__tar.gz

mdit-0.0.0.dev1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: MDit
+Version: 0.0.0.dev1
+Requires-Python: >=3.10
+Requires-Dist: sphinx<8
+Requires-Dist: myst-parser<4,>3
+Requires-Dist: pydata-sphinx-theme
+Requires-Dist: sphinx-togglebutton
+Requires-Dist: sphinx-design
+Requires-Dist: markdown-it-py
+Requires-Dist: mdit-py-plugins
+Requires-Dist: linkify-it-py
+Requires-Dist: readme-renderer
+Requires-Dist: cmarkgfm
+Requires-Dist: zundler
+Requires-Dist: PkgData
+Requires-Dist: PySerials
+Requires-Dist: PyLinks
+Requires-Dist: PyBadger
+Requires-Dist: PyColorIt
+Requires-Dist: IPython
+Requires-Dist: PyProtocol
+Requires-Dist: HTMP
+Requires-Dist: ansi-sgr

{mdit-0.0.0.dev0 → mdit-0.0.0.dev1}/pyproject.toml

@@ -17,15 +17,29 @@ namespaces = true
 # ----------------------------------------- Project Metadata -------------------------------------
 #
 [project]
-version = "0.0.0.dev0"
+version = "0.0.0.dev1"
 name = "MDit"
 requires-python = ">=3.10"
 dependencies = [
-    "IPython",
-    "PyProtocol",
+    "sphinx < 8",
+    "myst-parser > 3, < 4",
+    "pydata-sphinx-theme",
+    "sphinx-togglebutton",
+    "sphinx-design",
     "markdown-it-py",
     "mdit-py-plugins",
     "linkify-it-py",
     "readme-renderer",
     "cmarkgfm",
+    "zundler",
+    "PkgData",
+    "PySerials",
+    "PyLinks",
+    "PyBadger",
+    "PyColorIt",
+    "IPython",
+    "PyProtocol",
+    "HTMP",
+    "ansi-sgr",
+
 ]

mdit-0.0.0.dev1/src/MDit.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: MDit
+Version: 0.0.0.dev1
+Requires-Python: >=3.10
+Requires-Dist: sphinx<8
+Requires-Dist: myst-parser<4,>3
+Requires-Dist: pydata-sphinx-theme
+Requires-Dist: sphinx-togglebutton
+Requires-Dist: sphinx-design
+Requires-Dist: markdown-it-py
+Requires-Dist: mdit-py-plugins
+Requires-Dist: linkify-it-py
+Requires-Dist: readme-renderer
+Requires-Dist: cmarkgfm
+Requires-Dist: zundler
+Requires-Dist: PkgData
+Requires-Dist: PySerials
+Requires-Dist: PyLinks
+Requires-Dist: PyBadger
+Requires-Dist: PyColorIt
+Requires-Dist: IPython
+Requires-Dist: PyProtocol
+Requires-Dist: HTMP
+Requires-Dist: ansi-sgr

{mdit-0.0.0.dev0 → mdit-0.0.0.dev1}/src/MDit.egg-info/SOURCES.txt

@@ -9,6 +9,14 @@ src/MDit.egg-info/top_level.txt
 src/mdit/__init__.py
 src/mdit/container.py
 src/mdit/display.py
+src/mdit/document.py
 src/mdit/element.py
+src/mdit/generate.py
 src/mdit/parse.py
-src/mdit/render.py
+src/mdit/protocol.py
+src/mdit/render.py
+src/mdit/target.py
+src/mdit/template.py
+src/mdit/data/__init__.py
+src/mdit/data/file.py
+src/mdit/data/schema.py

mdit-0.0.0.dev1/src/MDit.egg-info/requires.txt

@@ -0,0 +1,20 @@
+sphinx<8
+myst-parser<4,>3
+pydata-sphinx-theme
+sphinx-togglebutton
+sphinx-design
+markdown-it-py
+mdit-py-plugins
+linkify-it-py
+readme-renderer
+cmarkgfm
+zundler
+PkgData
+PySerials
+PyLinks
+PyBadger
+PyColorIt
+IPython
+PyProtocol
+HTMP
+ansi-sgr

mdit-0.0.0.dev1/src/mdit/__init__.py

@@ -0,0 +1,133 @@
+"""Generate and process Markdown content.
+
+References
+----------
+- [GitHub Flavored Markdown Spec](https://github.github.com/gfm/)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+
+from mdit.container import Container, MDContainer, BlockMDContainer, InlineMDContainer
+from mdit.document import Document
+from mdit.generate import DocumentGenerator
+from mdit import render, target, element, display, parse, protocol, template
+__version__ = "XXX"
+
+if _TYPE_CHECKING:
+    from typing import Callable
+    from mdit.protocol import ContainerContentType, ContainerInputType, Stringable, TargetConfig, ANSITargetConfig
+
+
+def generate(config: dict):
+    return DocumentGenerator().generate(config)
+
+
+def document(
+    heading: element.Heading | ContainerInputType | None = None,
+    body: ContainerInputType = None,
+    section: Container | None = None,
+    footer: ContainerInputType = None,
+    frontmatter: dict | element.FrontMatter | None = None,
+    frontmatter_conditions: list[str] | None = None,
+    separate_sections: bool = False,
+    toctree_args: dict[str, str] | None = None,
+    toctree_dirhtml: bool = True,
+    target_config_md: dict[str, TargetConfig | dict] | None = None,
+    target_config_ansi: dict[str, ANSITargetConfig | dict] | None = None,
+    default_output_target: str = "sphinx",
+    deep_section_generator: Callable[[Document], str] | None = None,
+):
+    if heading and not isinstance(heading, element.Heading):
+        heading = element.heading(content=heading, level=1)
+    body = container(body, "\n\n")
+    if isinstance(section, Container):
+        pass
+    elif not section:
+        section = section_container()
+    elif isinstance(section, dict):
+        section = section_container(**section)
+    elif isinstance(section, (list, tuple)):
+        section = section_container(*section)
+    else:
+        section = section_container(section)
+    footer = container(footer, "\n\n")
+    if isinstance(frontmatter, dict):
+        frontmatter = element.frontmatter(frontmatter)
+    target_config = {}
+    for key, config in (target_config_md or {}).items():
+        config_obj = config if isinstance(config, protocol.TargetConfig) else target.custom(**config)
+        target_config[key] = config_obj
+    for key, config in (target_config_ansi or {}).items():
+        config_obj = config if isinstance(config, protocol.ANSITargetConfig) else target.ansi(**config)
+        if key in target_config:
+            raise ValueError(f"Target config key '{key}' already exists.")
+        target_config[key] = config_obj
+    return Document(
+        heading=heading,
+        body=body,
+        section=section,
+        footer=footer,
+        frontmatter=frontmatter,
+        frontmatter_conditions=frontmatter_conditions,
+        separate_sections=separate_sections,
+        toctree_args=toctree_args,
+        toctree_dirhtml=toctree_dirhtml,
+        target_config=target_config,
+        default_output_target=default_output_target,
+        deep_section_generator=deep_section_generator,
+    )
+
+
+def container(
+    content,
+    content_seperator: str,
+    html_container: Stringable | None = None,
+    html_container_attrs: dict | None = None,
+    html_container_conditions: list[str] | None = None,
+) -> MDContainer:
+    if isinstance(content, MDContainer):
+        return content
+    cont = MDContainer(
+        content_separator=content_seperator,
+        html_container=html_container,
+        html_container_attrs=html_container_attrs,
+        html_container_conditions=html_container_conditions,
+    )
+    if not content:
+        return cont
+    if isinstance(content, dict):
+        cont.extend(**content)
+    elif isinstance(content, (list, tuple)):
+        cont.extend(*content)
+    else:
+        cont.append(content)
+    return cont
+
+
+def block_container(
+    *unlabeled_contents: ContainerContentType,
+    **labeled_contents: ContainerContentType,
+) -> BlockMDContainer:
+    container_ = BlockMDContainer()
+    container_.extend(*unlabeled_contents, **labeled_contents)
+    return container_
+
+
+def inline_container(
+    *unlabeled_contents: ContainerContentType,
+    **labeled_contents: ContainerContentType,
+) -> InlineMDContainer:
+    container_ = InlineMDContainer()
+    container_.extend(*unlabeled_contents, **labeled_contents)
+    return container_
+
+
+def section_container(
+    *unlabeled_contents: ContainerContentType,
+    **labeled_contents: ContainerContentType,
+) -> Container:
+    container_ = Container()
+    container_.extend(*unlabeled_contents, **labeled_contents)
+    return container_

mdit-0.0.0.dev1/src/mdit/container.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING as _TYPE_CHECKING, NamedTuple as _NamedTuple
+import re as _re
+
+import htmp as _htmp
+
+from mdit.protocol import MDCode as _MDCode
+from mdit import display as _display
+
+
+if _TYPE_CHECKING:
+    from typing import Literal
+    from mdit.protocol import ContainerInputType, ContainerContentType, ContainerContentType, TargetConfigType, Stringable
+
+
+class ContainerContent(_NamedTuple):
+    content: ContainerContentType
+    conditions: list[str]
+
+
+class Container:
+
+    def __init__(self, data: dict[str | int, ContainerContent] | None = None):
+        self._data = data or {}
+        return
+
+    def append(
+        self,
+        content,
+        conditions: str | list[str] | None = None,
+        key: str | int | None = None
+    ) -> str | int:
+        if not key:
+            key = max((key for key in self._data.keys() if isinstance(key, int)), default=-1) + 1
+        if key in self._data:
+            raise ValueError("Key already exists in content.")
+        if not conditions:
+            conditions = []
+        elif isinstance(conditions, str):
+            conditions = [conditions]
+        else:
+            conditions = list(conditions)
+        self._data[key] = ContainerContent(content=content, conditions=conditions)
+        return key
+
+    def extend(self, *unlabeled_contents, **labeled_contents) -> list[str | int]:
+
+        def resolve_value(v):
+            if isinstance(v, (list, tuple)):
+                val = v[0]
+                cond = v[1] if len(v) > 1 else None
+                return val, cond
+            return v, None
+
+        added_keys = []
+        if unlabeled_contents:
+            first_available_key = max(
+                (key for key in self._data.keys() if isinstance(key, int)), default=-1
+            ) + 1
+            for idx, value in enumerate(unlabeled_contents):
+                content, conditions = resolve_value(value)
+                added_keys.append(self.append(content, conditions, first_available_key + idx))
+        if labeled_contents:
+            for key, value in labeled_contents.items():
+                content, conditions = resolve_value(value)
+                added_keys.append(self.append(content, conditions, key))
+        return added_keys
+
+    def elements(
+        self,
+        target: TargetConfigType | None = None,
+        filters: str | list[str] | None = None,
+        string: bool = False,
+    ) -> list:
+        elements = []
+        if isinstance(filters, str):
+            filters = [filters]
+        for content, conditions in self.values():
+            if not filters or not conditions or any(filter in conditions for filter in filters):
+                if not string:
+                    elements.append(content)
+                elif isinstance(content, _MDCode):
+                    elements.append(content.source(target=target, filters=filters))
+                else:
+                    elements.append(str(content))
+        return elements
+
+    def get(self, key: str | int, default=None):
+        return self._data.get(key, default)
+
+    def keys(self):
+        return self._data.keys()
+
+    def values(self):
+        return self._data.values()
+
+    def items(self):
+        return self._data.items()
+
+    def __getitem__(self, item):
+        return self._data[item]
+
+    def __setitem__(self, key, value):
+        self._data[key] = value
+        return
+
+    def __contains__(self, item):
+        return item in self._data
+
+    def __bool__(self):
+        return bool(self._data)
+
+
+class MDContainer(Container):
+
+    _IS_MD_CODE = True
+
+    def __init__(
+        self,
+        content: dict[str | int, ContainerContent] | None = None,
+        content_separator: str = "\n\n",
+        html_container: Stringable | None = None,
+        html_container_attrs: dict | None = None,
+        html_container_conditions: list[str] | None = None,
+    ):
+        super().__init__(content)
+        self.content_separator = content_separator
+        self.html_container = html_container
+        self.html_container_attrs = html_container_attrs or {}
+        self.html_container_conditions = html_container_conditions or []
+        return
+
+    def source(self, target: TargetConfigType | None = None, filters: str | list[str] | None = None) -> str:
+        elements = self.elements(target=target, filters=filters, string=True)
+        elements_str = self.content_separator.join(elements)
+        if self.html_container and self.html_container_attrs and (
+            not filters
+            or not self.html_container_conditions
+            or any(filter in self.html_container_conditions for filter in filters)
+        ):
+            container_func = getattr(_htmp.element, str(self.html_container))
+            return container_func(_htmp.elementor.markdown(elements_str), self.html_container_attrs).source(indent=-1)
+        return elements_str
+
+    def display(self, target: TargetConfigType | None = None, filters: str | list[str] | None = None) -> None:
+        """Display the element in an IPython notebook."""
+        _display.ipython(self.source(target=target, filters=filters))
+        return
+
+    @property
+    def code_fence_count(self) -> int:
+        pattern = _re.compile(r'^\s{0, 3}(`{3,}|~{3,}|:{3,})', _re.MULTILINE)
+        counts = []
+        for content, _ in self._data.values():
+            if isinstance(content, _MDCode):
+                counts.append(content.code_fence_count)
+            else:
+                matches = pattern.findall(str(content))
+                if matches:
+                    counts.append(max(len(match) for match in matches))
+        return max(counts, default=0)
+
+
+    # def __str__(self):
+    #     if not self._block:
+    #         if any(not isinstance(elem, str) for elem in self._content.values()):
+    #             raise ValueError("Inline elements must have string content.")
+    #     elif self._leaf:
+    #         if any(isinstance(elem, Element) and elem.is_block for elem in self._content.values()):
+    #             raise ValueError("Leaf block elements cannot contain block content.")
+    #     content = "".join(str(elem) for elem in self._content.values())
+    #     md = self._md.replace("${{content}}", content)
+    #     newlines_before, newlines_after = [
+    #         newlines_count if isinstance(newlines_count, int) else (1 if self._block else 0)
+    #         for newlines_count in (self.newlines_before, self.newlines_after)
+    #     ]
+    #     return f"{newlines_before * '\n'}{md}{newlines_after * '\n'}"
+
+    def __str__(self) -> str:
+        return self.source()
+
+
+class BlockMDContainer(MDContainer):
+
+    def __init__(self, content: dict[str | int, ContainerContent] | None = None):
+        super().__init__(content, content_separator="\n\n")
+        return
+
+
+class InlineMDContainer(MDContainer):
+
+    def __init__(self, content: dict[str | int, ContainerContent] | None = None):
+        super().__init__(content, content_separator="")
+        return

mdit-0.0.0.dev1/src/mdit/data/__init__.py

@@ -0,0 +1,3 @@
+"""Work with the package's data files and JSON schemas."""
+
+from mdit.data import file, schema

mdit-0.0.0.dev1/src/mdit/data/file.py

@@ -0,0 +1,75 @@
+"""Get package data files."""
+
+from pathlib import Path as _Path
+
+import pkgdata as _pkgdata
+import pyserials as _ps
+
+
+path = _pkgdata.get_package_path_from_caller(top_level=True) / "data"
+
+
+def template(group: str, name: str) -> str:
+    """Get the string content of a template."""
+    dir_path = path / "template" / group
+    for filepath in dir_path.iterdir():
+        if filepath.stem == name:
+            return filepath.read_text()
+
+
+def schema(schema_id: str | None = None, relative_uri: bool = True) -> dict:
+    """Get all JSON schemas as a dictionary of schema IDs to schema objects.
+
+    Parameters
+    ----------
+    schema_id : str, optional
+        If provided, return only the schema with the given ID, otherwise all schemas.
+        The schema ID can be either an absolute or relative URI, i.e., with or without
+        the "https://docsman.repodynamics.com/schema/" prefix.
+    relative_uri : bool, default: True
+        Only applies when `schema_id` is not provided:
+        If True, the schema IDs (i.e., the keys of the returned dictionary)
+        will be relative URIs instead of absolute URIs,
+        i.e., without the "https://docsman.repodynamics.com/schema/" prefix.
+
+    Returns
+    -------
+    dict
+        If `schema_id` is provided, the schema object is returned,
+        otherwise a dictionary of JSON schemas with their IDs as keys.
+        The schema IDs are relative URIs if `relative_uri` is True.
+    """
+    dir_path = path / "schema"
+    if schema_id:
+        filepath = dir_path / schema_id.removeprefix("https://docsman.repodynamics.com/schema/")
+        filepath_full = filepath.with_suffix(".yaml")
+        return _ps.read.yaml_from_file(path=filepath_full)
+    schemas = {}
+    for filepath in dir_path.glob("**/*.yaml"):
+        schema = _ps.read.yaml_from_file(path=filepath)
+        schema_id = schema["$id"].removeprefix(
+            "https://docsman.repodynamics.com/schema/" if relative_uri else ""
+        )
+        schemas[schema_id] = schema
+    return schemas
+
+
+def from_filepath(filepath: str | _Path) -> str | dict | list:
+    """Get a package data file from its relative path.
+
+    Parameters
+    ----------
+    filepath : str
+        Path of the data file relative to the package's `data` directory.
+
+    Returns
+    -------
+    file_content : str | dict | list
+        The content of the file.
+        If the file is a serialized data structure (e.g., JSON or YAML),
+        the content will be deserialized, otherwise a string is returned.
+    """
+    absolute_filepath = path / filepath
+    if absolute_filepath.suffix in (".json", ".yaml", ".yml", "toml"):
+        return _ps.read.from_file(path=absolute_filepath)
+    return absolute_filepath.read_text()

mdit-0.0.0.dev1/src/mdit/data/schema.py

@@ -0,0 +1,45 @@
+"""Work with JSON schemas defined by the package."""
+
+from typing import Callable as _Callable
+
+import referencing as _referencing
+from referencing import jsonschema as _ref_jsonschema
+import jsonschemata as _jsonschemata
+import pyserials as _ps
+
+from mdit.data import file as _file
+
+
+def make_registry(
+    dynamic: bool = False,
+    crawl: bool = True,
+    add_resources: list[dict | _referencing.Resource | tuple[str, dict | _referencing.Resource]] | None = None,
+    add_resources_default_spec: _referencing.Specification = _ref_jsonschema.DRAFT202012,
+    retrieval_func: _Callable[[str], str | _referencing.Resource] = None,
+) -> tuple[_referencing.Registry, dict[str, dict]]:
+    schemata = _file.schema(relative_uri=False)
+    resources = add_resources or []
+    for schema in schemata.values():
+        _jsonschemata.edit.required_last(schema)
+        resources.append(schema)
+    registry = _jsonschemata.registry.make(
+        dynamic=dynamic,
+        crawl=crawl,
+        add_resources=resources,
+        add_resources_default_spec=add_resources_default_spec,
+        retrieval_func=retrieval_func,
+    )
+    return registry, schemata
+
+
+def validate(data: dict, schema_id: str):
+    _ps.validate.jsonschema(
+        data=data,
+        schema=_SCHEMATA[schema_id],
+        registry=_REGISTRY,
+        fill_defaults=True,
+    )
+    return
+
+
+# _REGISTRY, _SCHEMATA = make_registry()

{mdit-0.0.0.dev0 → mdit-0.0.0.dev1}/src/mdit/display.py

@@ -3,7 +3,6 @@
 import webbrowser as _webbrowser
 import tempfile as _tempfile
 import time as _time
-from pathlib import Path as _Path
 
 from IPython import display as _display
 
@@ -20,17 +19,15 @@ def browser(content: str) -> None:
     content : str
         HTML content to display.
     """
-    with _tempfile.NamedTemporaryFile('w', delete=False, suffix='.html') as temp_file:
+    with _tempfile.NamedTemporaryFile('w', suffix='.html') as temp_file:
         temp_file.write(content)
         temp_file.flush()
-        temp_filepath = temp_file.name
-    _webbrowser.open(f'file://{temp_filepath}')
-    _time.sleep(10)
-    _Path(temp_filepath).unlink()
+        _webbrowser.open(f'file://{temp_file.name}')
+        _time.sleep(11)
     return
 
 
-def ipython(content: str, as_md: bool = False) -> None:
+def ipython(content: str, as_md: bool = True) -> None:
     """Display HTML or Markdown content in an IPython notebook.
 
     This function uses the `IPython.display` module to render the content
@@ -44,9 +41,6 @@ def ipython(content: str, as_md: bool = False) -> None:
         If True, the function uses the `IPython.display.Markdown` renderer,
         otherwise (by default) it uses the `IPython.display.HTML` renderer
     """
-    if ipython:
-        renderer = _display.Markdown if as_md else _display.HTML
-        _display.display(renderer(content))
-        return
-
+    renderer = _display.Markdown if as_md else _display.HTML
+    _display.display(renderer(content))
     return