openprocess 0.7.0__py3-none-any.whl

openprocess/gui/studio/markdown_view.py

@@ -0,0 +1,127 @@
+"""Markdown with maths, as the exercises and the definitions show it.
+
+``markdown_html`` turns GitHub-flavoured Markdown (tables, lists, emphasis)
+with maths between ``$…$`` or ``$$…$$`` (typeset by :mod:`.mathtext`) into
+Qt rich text; :class:`MarkdownLabel` shows it in a label that grows with its
+text, so a worksheet reads as one page.
+"""
+
+from __future__ import annotations
+
+import re
+from html import escape
+from pathlib import Path
+
+from PySide6.QtCore import QUrl, Qt
+from PySide6.QtGui import QTextDocument
+from PySide6.QtWidgets import QFrame, QLabel, QSizePolicy, QTextBrowser
+
+from .mathtext import MATH_FONT, render
+
+
+# ---------------------------------------------------------------------------
+# Markdown with maths
+# ---------------------------------------------------------------------------
+_DISPLAY = re.compile(r"\$\$(.+?)\$\$", re.S)
+_INLINE = re.compile(r"(?<![\\$])\$([^$\n]+?)\$")
+
+
+def _maths(source: str, size: int) -> str:
+    try:
+        body = render(source.strip())
+    except ValueError:                 # not in the supported subset: show it as written
+        body = escape(source.strip())
+    return f"<span style='font-family: {MATH_FONT}; font-size: {size}px'>{body}</span>"
+
+
+def markdown_html(text: str) -> str:
+    """Markdown (GitHub flavour: tables, lists, emphasis) with ``$…$`` maths, as HTML."""
+    formulas: list[str] = []
+
+    def stash(match, size: int) -> str:
+        formulas.append(_maths(match.group(1), size))
+        return f"MATHXPLACEHOLDER{len(formulas) - 1}X"
+
+    text = _DISPLAY.sub(lambda m: "\n\n" + stash(m, 17) + "\n\n", text)
+    text = _INLINE.sub(lambda m: stash(m, 15), text)
+    document = QTextDocument()
+    document.setMarkdown(text, QTextDocument.MarkdownDialectGitHub)
+    html = document.toHtml()
+    return re.sub(r"MATHXPLACEHOLDER(\d+)X", lambda m: formulas[int(m.group(1))], html)
+
+
+def plain_browser() -> QTextBrowser:
+    browser = QTextBrowser()
+    browser.setObjectName("plainBrowser")        # borderless inside its card
+    browser.setOpenExternalLinks(True)
+    browser.setFrameShape(QFrame.NoFrame)
+    return browser
+
+
+def show_document(browser: QTextBrowser, path: Path) -> None:
+    """A Markdown (or plain text) file in ``browser``, images relative to its folder."""
+    text = path.read_text(encoding="utf-8", errors="replace")
+    browser.document().setBaseUrl(QUrl.fromLocalFile(str(path.parent) + "/"))
+    browser.setSearchPaths([str(path.parent)])
+    if path.suffix.lower() == ".md":
+        browser.setHtml(markdown_html(text))
+    else:
+        browser.setPlainText(text)
+
+
+
+#: Pictures wider than this are shown scaled down to it (the worksheet's width).
+IMAGE_WIDTH = 640
+
+
+def _absolute_images(html: str, folder: Path) -> str:
+    """``<img src="figure.png">`` relative to the question's folder, scaled
+    down when wider than the worksheet."""
+    from PySide6.QtGui import QImageReader
+
+    def absolute(match) -> str:
+        source = match.group(2)
+        if re.match(r"^[a-z]+:", source):
+            return match.group(0)
+        path = folder / source
+        width = QImageReader(str(path)).size().width()
+        scaled = f' width="{IMAGE_WIDTH}"' if width > IMAGE_WIDTH else ""
+        return f"{match.group(1)}{QUrl.fromLocalFile(str(path)).toString()}{match.group(3)}{scaled}"
+    return re.sub(r'(<img[^>]*src=")([^"]+)(")', absolute, html)
+
+
+class MarkdownLabel(QLabel):
+    """Markdown in a label: wraps, grows with its text, links open in the browser."""
+
+    def __init__(self, text: str = "", folder: Path | None = None, size: int | None = None,
+                 parent=None) -> None:
+        super().__init__(parent)
+        self.setObjectName("markdown")
+        self.setTextFormat(Qt.RichText)
+        self.setWordWrap(True)
+        self.setOpenExternalLinks(True)
+        self.setTextInteractionFlags(Qt.TextBrowserInteraction)
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
+        self.folder = folder
+        if size:
+            self.setStyleSheet(f"font-size: {size}px;")
+        self.set_markdown(text)
+
+    def set_markdown(self, text: str) -> None:
+        self.source = text
+        html = markdown_html(text)
+        # The label's own font (the document pins one of its own), and room
+        # between paragraphs so a worksheet reads easily.
+        html = re.sub(r"<body style=\"[^\"]*\">", "<body>", html)
+        html = re.sub(r"<p style=\" margin-top:\d+px; margin-bottom:\d+px;",
+                      "<p style=\" margin-top:4px; margin-bottom:10px;", html)
+        html = re.sub(r"<li style=\" margin-top:\d+px; margin-bottom:\d+px;",
+                      "<li style=\" margin-top:2px; margin-bottom:3px;", html)
+        if self.folder is not None:
+            html = _absolute_images(html, self.folder)
+        self.setText(html)
+
+    def plain_text(self) -> str:
+        document = QTextDocument()
+        document.setHtml(self.text())
+        return document.toPlainText()

openprocess/gui/studio/mathtext.py

@@ -0,0 +1,260 @@
+"""Typeset a small subset of LaTeX maths as Qt rich text (HTML).
+
+Qt's rich-text engine has no maths support, but formulas about Petri nets need
+little: italic symbols, sub- and superscripts, an overline, and Unicode for
+∀ ∃ ∈ ⇒ •.  This module turns the LaTeX used in
+:mod:`openprocess.mining.definitions` (and in formulas the analysis builds for a
+concrete net) into that HTML, so one source serves both GitHub, where MathJax
+renders ``docs/definitions.md``, and the app.
+
+Spacing follows TeX's idea rather than the source text: spaces in the source
+are ignored, relations (= ∈ ⇒ …) and binary operators (∩ ∧ + …) get space on
+both sides, and ``\\;``, ``\\quad`` and ``\\text{ … }`` add space explicitly.
+
+Supported: letters (italic), digits, ``( ) [ ] , . | ! ' * + - < > = /``,
+groups ``{…}``, ``_`` and ``^``, and the commands in :data:`SYMBOLS`,
+:data:`RELATIONS`, :data:`BINARY` plus ``\\text``, ``\\mathrm``,
+``\\mathit``, ``\\mathbb``, ``\\overline``, ``\\xrightarrow`` and ``\\not``.
+Anything else raises :class:`ValueError`, so a typo shows up in the tests
+instead of as a stray backslash on screen.
+"""
+
+from __future__ import annotations
+
+from html import escape
+
+#: The font stack for formulas (serif, like a textbook).
+MATH_FONT = ("'STIX Two Math', 'STIX Two Text', 'Cambria Math', 'Latin Modern Math', "
+             "'Times New Roman', serif")
+
+#: Ordinary symbols: no extra space around them.
+SYMBOLS = {
+    "forall": "∀", "exists": "∃", "neg": "¬", "bullet": "•", "emptyset": "∅",
+    "langle": "⟨", "rangle": "⟩", "lbrace": "{", "rbrace": "}", "{": "{", "}": "}",
+    "ldots": "…", "cdots": "⋯", "infty": "∞", "omega": "ω", "sigma": "σ",
+    "tau": "τ", "alpha": "α", "star": "∗", "max": "max", "bigcap": "⋂", "bigcup": "⋃",
+}
+#: Relations: a thick space on both sides.
+RELATIONS = {
+    "in": "∈", "notin": "∉", "subseteq": "⊆", "neq": "≠", "leq": "≤", "geq": "≥",
+    "Rightarrow": "⇒", "iff": "⟺", "to": "→", "rightarrow": "→", "leftarrow": "←",
+    "mid": "|", "parallel": "‖", "colon": ":", "#": "#", "subsetneq": "⊊",
+    "Leftrightarrow": "⇔", "cong": "≅",
+}
+#: Binary operators: a medium space on both sides.
+BINARY = {"cap": "∩", "cup": "∪", "times": "×", "land": "∧", "lor": "∨", "setminus": "∖",
+          "cdot": "·"}
+#: Explicit spaces.
+SPACES = {",": "&#8201;", ";": "&nbsp;", "quad": "&emsp;", "qquad": "&emsp;&emsp;", " ": "&nbsp;",
+          "!": ""}
+BLACKBOARD = {"N": "ℕ", "Z": "ℤ", "R": "ℝ", "B": "𝔹"}
+
+_ASCII_RELATIONS = {"=": "=", "<": "&lt;", ">": "&gt;"}
+_ASCII_BINARY = {"+": "+", "-": "−"}
+#: Commands that are negated by \not, and what the negation looks like.
+_NEGATED = {"in": "∉", "=": "≠", "subseteq": "⊈", "exists": "∄"}
+
+
+class _Parser:
+    def __init__(self, source: str) -> None:
+        self.text = source
+        self.index = 0
+
+    # -- low level ---------------------------------------------------------------------
+    def peek(self) -> str:
+        return self.text[self.index] if self.index < len(self.text) else ""
+
+    def take(self) -> str:
+        char = self.peek()
+        self.index += 1
+        return char
+
+    def skip_spaces(self) -> None:
+        while self.peek().isspace():
+            self.index += 1
+
+    def command(self) -> str:
+        """The name after a backslash (letters, or one other character)."""
+        start = self.index
+        if self.peek().isalpha():
+            while self.peek().isalpha():
+                self.index += 1
+            return self.text[start:self.index]
+        return self.take()
+
+    def group_source(self) -> str:
+        """The raw text of a ``{…}`` argument (nested braces allowed)."""
+        self.skip_spaces()
+        if self.take() != "{":
+            raise ValueError(f"expected '{{' at {self.index} in {self.text!r}")
+        depth, start = 1, self.index
+        while depth:
+            char = self.take()
+            if not char:
+                raise ValueError(f"unbalanced braces in {self.text!r}")
+            if char == "\\":
+                self.take()
+            elif char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+        return self.text[start:self.index - 1]
+
+    # -- rendering ---------------------------------------------------------------------
+    def argument(self) -> str:
+        """One token or group, rendered (for ``_``, ``^`` and commands)."""
+        self.skip_spaces()
+        if self.peek() == "{":
+            return render(self.group_source())
+        return self.atom()
+
+    def atom(self) -> str:
+        char = self.take()
+        if char == "\\":
+            return self.backslash()
+        if char.isalpha():
+            letters = char
+            while self.peek().isalpha():
+                letters += self.take()
+            return f"<i>{letters}</i>"
+        if char.isdigit():
+            digits = char
+            while self.peek().isdigit():
+                digits += self.take()
+            return digits
+        if char == "{":
+            self.index -= 1
+            return render(self.group_source())
+        if char in _ASCII_RELATIONS:
+            return f" {_ASCII_RELATIONS[char]} "
+        if char in _ASCII_BINARY:
+            return f" {_ASCII_BINARY[char]} "
+        if char == "'":
+            return "′"
+        if char == ",":
+            return ", "
+        if char == "*":
+            return "∗"            # the asterisk operator sits at maths height
+        if char in "()[]|.!/;:":
+            return escape(char)
+        raise ValueError(f"unsupported character {char!r} in {self.text!r}")
+
+    def backslash(self) -> str:
+        name = self.command()
+        if name in SYMBOLS:
+            return SYMBOLS[name]
+        if name in RELATIONS:
+            symbol = RELATIONS[name]
+            return f"{symbol} " if name == "colon" else f" {symbol} "
+        if name in BINARY:
+            return f" {BINARY[name]} "
+        if name in SPACES:
+            return SPACES[name]
+        if name in ("text", "mathrm"):
+            return _text(self.group_source())
+        if name == "mathit":
+            return f"<i>{_text(self.group_source())}</i>"
+        if name == "mathbb":
+            letter = self.group_source().strip()
+            return BLACKBOARD.get(letter, letter)
+        if name == "overline":
+            return f"<span style='text-decoration: overline'>{self.argument()}</span>"
+        if name == "xrightarrow":
+            return f" →<sup>{render(self.group_source())}</sup> "
+        if name == "not":
+            self.skip_spaces()
+            if self.peek() == "\\":
+                self.take()
+                negated = self.command()
+                if negated == "xrightarrow":
+                    return f" ↛<sup>{render(self.group_source())}</sup> "
+                if negated in _NEGATED:
+                    return f" {_NEGATED[negated]} "
+                raise ValueError(f"cannot negate \\{negated}")
+            if self.peek() == "=":
+                self.take()
+                return " ≠ "
+            raise ValueError(f"cannot negate {self.peek()!r}")
+        raise ValueError(f"unsupported command \\{name} in {self.text!r}")
+
+    def run(self) -> str:
+        parts: list[str] = []
+        while True:
+            self.skip_spaces()
+            if not self.peek():
+                break
+            char = self.peek()
+            if char in "_^":
+                self.take()
+                tag = "sub" if char == "_" else "sup"
+                script = f"<{tag}>{self.argument().strip()}</{tag}>"
+                # Attach to the symbol before it; a relation keeps its space after.
+                previous = parts.pop() if parts else ""
+                spaced = previous.endswith(" ")
+                parts.append(previous.rstrip() + script + (" " if spaced else ""))
+            elif char == "}":
+                raise ValueError(f"unbalanced '}}' in {self.text!r}")
+            else:
+                parts.append(self.atom())
+        return _tidy("".join(parts))
+
+
+def _text(source: str) -> str:
+    """``\\text{…}``: upright words; ``\\{ \\}`` are literal braces, edge spaces kept."""
+    plain = source.replace("\\{", "{").replace("\\}", "}").replace("\\_", "_")
+    body = escape(plain.strip())
+    lead = "&nbsp;" if plain[:1].isspace() else ""
+    trail = "&nbsp;" if plain[-1:].isspace() else ""
+    return f"{lead}<span style='font-family: sans-serif'>{body}</span>{trail}"
+
+
+def _tidy(html: str) -> str:
+    """Collapse the spaces operators added next to each other and at the ends."""
+    while "  " in html:
+        html = html.replace("  ", " ")
+    return html.replace("( ", "(").replace(" )", ")").strip()
+
+
+def render(source: str) -> str:
+    """HTML for the LaTeX formula ``source`` (without the ``$`` delimiters)."""
+    return _Parser(source).run()
+
+
+def render_text(text: str) -> str:
+    """HTML for prose with inline ``$…$`` maths and ``*emphasis*``."""
+    out: list[str] = []
+    for index, chunk in enumerate(text.split("$")):
+        if index % 2:
+            out.append(f"<span style='font-family: {MATH_FONT}'>{render(chunk)}</span>")
+        else:
+            words = escape(chunk).split("*")
+            out.append("".join(f"<i>{w}</i>" if n % 2 else w for n, w in enumerate(words)))
+    return "".join(out)
+
+
+def display(source: str, size: int = 15) -> str:
+    """A formula on its own line, centred like display maths."""
+    return (f"<p align='center' style='font-family: {MATH_FONT}; font-size: {size}px; "
+            f"margin: 4px 0'>{render(source)}</p>")
+
+
+# ---------------------------------------------------------------------------
+# Writing formulas about a concrete net
+# ---------------------------------------------------------------------------
+def name(text: str) -> str:
+    """A node name for use inside a formula (``\\text{…}`` with braces escaped)."""
+    cleaned = text.replace("\\", "").replace("{", "\\{").replace("}", "\\}")
+    return "\\text{" + cleaned + "}"
+
+
+def name_set(names) -> str:
+    items = list(names)
+    return "\\emptyset" if not items else \
+        "\\lbrace " + ", ".join(name(n) for n in items) + " \\rbrace"
+
+
+def sequence(names, limit: int = 8) -> str:
+    items = list(names)
+    if len(items) > limit:
+        items = items[:limit - 1] + ["…"]
+    return "\\langle " + ", ".join(name(n) for n in items) + " \\rangle"

openprocess/gui/studio/ml_highlighter.py

@@ -0,0 +1,75 @@
+"""Syntax highlighting for CPN ML (declarations and inscriptions).
+
+A small regular-expression highlighter, enough to make declarations easy to
+scan: keywords, colour-set and function names, strings, numbers and
+``(* comments *)`` -- including comments that span several lines.
+"""
+
+from __future__ import annotations
+
+import re
+
+from PySide6.QtGui import QColor, QFont, QSyntaxHighlighter, QTextCharFormat
+
+from . import style
+
+KEYWORDS = (
+    "colset var val fun fn let in end if then else case of andalso orelse with and "
+    "globref timed product record list index subset union by declare ms op not"
+).split()
+TYPES = "int bool string unit real time intinf".split()
+
+_WORD = re.compile(r"\b(" + "|".join(KEYWORDS) + r")\b")
+_TYPE = re.compile(r"\b(" + "|".join(TYPES) + r")\b")
+_DEFINED = re.compile(r"\b(?:colset|fun|val|var|globref)\s+([A-Za-z_][\w']*(?:\s*,\s*[A-Za-z_][\w']*)*)")
+_NUMBER = re.compile(r"(?<![\w.])~?\d+(\.\d+)?")
+_STRING = re.compile(r'"(?:[^"\\]|\\.)*"')
+_OPERATOR = re.compile(r"``|`|\+\+|--|@\+|::|\^\^|<>|<=|>=|=>")
+
+
+def _format(colour: str, bold: bool = False, italic: bool = False) -> QTextCharFormat:
+    fmt = QTextCharFormat()
+    fmt.setForeground(QColor(colour))
+    if bold:
+        fmt.setFontWeight(QFont.DemiBold)
+    fmt.setFontItalic(italic)
+    return fmt
+
+
+class MlHighlighter(QSyntaxHighlighter):
+    IN_COMMENT = 1
+
+    def highlightBlock(self, text: str) -> None:  # noqa: N802 - Qt naming
+        t = style.tokens()
+        keyword = _format(style.categorical(6), bold=True)
+        type_ = _format(style.categorical(0))
+        defined = _format(t.text, bold=True)
+        number = _format(style.categorical(1))
+        string = _format(style.categorical(2))
+        operator = _format(t.text_secondary, bold=True)
+        comment = _format(t.text_muted, italic=True)
+
+        for pattern, fmt in ((_TYPE, type_), (_WORD, keyword), (_NUMBER, number),
+                             (_OPERATOR, operator)):
+            for match in pattern.finditer(text):
+                self.setFormat(match.start(), match.end() - match.start(), fmt)
+        for match in _DEFINED.finditer(text):
+            self.setFormat(match.start(1), match.end(1) - match.start(1), defined)
+        for match in _STRING.finditer(text):
+            self.setFormat(match.start(), match.end() - match.start(), string)
+
+        # (* comments *), possibly spanning lines.
+        self.setCurrentBlockState(0)
+        start = 0
+        if self.previousBlockState() != self.IN_COMMENT:
+            start = text.find("(*")
+        while start >= 0:
+            end = text.find("*)", start + 2 if self.previousBlockState() != self.IN_COMMENT
+                            or start > 0 else 0)
+            if end < 0:
+                self.setCurrentBlockState(self.IN_COMMENT)
+                length = len(text) - start
+            else:
+                length = end - start + 2
+            self.setFormat(start, length, comment)
+            start = text.find("(*", start + length)