python-color-math 0.1.0__py3-none-any.whl

color_math/__init__.py

@@ -0,0 +1,8 @@
+"""Public helpers for converting Obsidian LaTeX color markup."""
+
+from .adapters import detect_format, transform_document
+from .config import ColorMathOptions
+from .converters.block import convert_text
+from .undo import uncolor_text
+
+__all__ = ["ColorMathOptions", "convert_text", "detect_format", "transform_document", "uncolor_text"]

color_math/__main__.py

@@ -0,0 +1,5 @@
+from .main import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

color_math/adapters.py

@@ -0,0 +1,288 @@
+"""Thin document adapters around the existing Markdown math converter."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .converters.block import convert_math_block, convert_text
+from .undo import uncolor_fragment, uncolor_text
+from .utils.latex_helpers import read_comment_end, read_verb_end
+
+
+FORMATS = ("auto", "markdown", "jupyter", "anki", "tex")
+ANKI_DELIMITERS = (
+    (r"\[", r"\]"),
+    (r"\(", r"\)"),
+    ("[$$]", "[/$$]"),
+    ("[$]", "[/$]"),
+)
+MATH_ENVIRONMENTS = {
+    "align", "align*", "alignat", "alignat*", "displaymath",
+    "equation", "equation*", "eqnarray", "eqnarray*", "flalign",
+    "flalign*", "gather", "gather*", "math", "multline", "multline*",
+}
+VERBATIM_ENVIRONMENTS = {"Verbatim", "lstlisting", "minted", "verbatim", "verbatim*"}
+BEGIN_RE = re.compile(r"\\begin\{([^{}]+)\}")
+HEX_COLOR_RE = re.compile(r"\\textcolor\{#([0-9A-Fa-f]{6})\}")
+NATIVE_COLOR_RE = re.compile(r"\\textcolor\{colormath([0-9A-Fa-f]{6})\}")
+NATIVE_BEGIN = "% color-math: begin generated xcolor support"
+NATIVE_END = "% color-math: end generated xcolor support"
+NATIVE_BLOCK_RE = re.compile(
+    rf"(?m)^{re.escape(NATIVE_BEGIN)}(?:\r?\n).*?^{re.escape(NATIVE_END)}(?:\r?\n)?",
+    re.DOTALL,
+)
+
+
+class AdapterError(ValueError):
+    """A document cannot be safely handled by its selected adapter."""
+
+
+def detect_format(path: Path | None, requested: str = "auto") -> str:
+    if requested != "auto":
+        return requested
+    if path is not None and path.suffix.lower() == ".ipynb":
+        return "jupyter"
+    if path is not None and path.suffix.lower() in {".tex", ".latex"}:
+        return "tex"
+    return "markdown"
+
+
+def transform_document(text: str, format_name: str, undo: bool = False) -> str:
+    if format_name == "markdown":
+        return uncolor_text(text) if undo else convert_text(text)
+    if format_name == "jupyter":
+        return _transform_notebook(text, undo)
+    if format_name == "anki":
+        return _transform_delimited(text, ANKI_DELIMITERS, undo)
+    if format_name == "tex":
+        return _transform_tex(text, undo)
+    raise AdapterError(f"unsupported format: {format_name}")
+
+
+def _transform_fragment(text: str, undo: bool) -> str:
+    if undo:
+        return uncolor_fragment(text)
+    converted = convert_math_block(f"$${text}$$")
+    return converted[2:-2]
+
+
+def _transform_notebook(text: str, undo: bool) -> str:
+    try:
+        notebook = json.loads(text)
+    except json.JSONDecodeError as error:
+        raise AdapterError(f"invalid Jupyter JSON at line {error.lineno}: {error.msg}") from error
+
+    if not isinstance(notebook, dict) or not isinstance(notebook.get("cells"), list):
+        raise AdapterError("Jupyter notebook must contain a cells list")
+
+    changed = False
+    for index, cell in enumerate(notebook["cells"]):
+        if not isinstance(cell, dict) or cell.get("cell_type") != "markdown":
+            continue
+        source = cell.get("source", "")
+        if isinstance(source, str):
+            joined = source
+        elif isinstance(source, list) and all(isinstance(part, str) for part in source):
+            joined = "".join(source)
+        else:
+            raise AdapterError(f"markdown cell {index + 1} has an invalid source")
+
+        converted = uncolor_text(joined) if undo else convert_text(joined)
+        if converted == joined:
+            continue
+        cell["source"] = (
+            converted
+            if isinstance(source, str)
+            else converted.splitlines(keepends=True) or ([""] if source else [])
+        )
+        changed = True
+
+    if not changed:
+        return text
+
+    indentation = re.search(r"\n([ \t]+)\"", text)
+    if indentation is None:
+        output = json.dumps(notebook, ensure_ascii=False, separators=(",", ":"))
+    else:
+        output = json.dumps(notebook, ensure_ascii=False, indent=indentation.group(1))
+    ending = "\r\n" if text.endswith("\r\n") else "\n" if text.endswith("\n") else ""
+    return output + ending
+
+
+def _is_escaped(text: str, index: int) -> bool:
+    backslashes = 0
+    index -= 1
+    while index >= 0 and text[index] == "\\":
+        backslashes += 1
+        index -= 1
+    return backslashes % 2 == 1
+
+
+def _next_delimiter(
+    text: str,
+    start: int,
+    delimiters: tuple[tuple[str, str], ...],
+) -> tuple[int, str, str] | None:
+    matches = [
+        (position, opening, closing)
+        for opening, closing in delimiters
+        if (position := _find_unescaped(text, opening, start)) >= 0
+    ]
+    return min(matches, default=None, key=lambda match: match[0])
+
+
+def _find_unescaped(text: str, token: str, start: int) -> int:
+    while (position := text.find(token, start)) >= 0:
+        if not _is_escaped(text, position):
+            return position
+        start = position + len(token)
+    return -1
+
+
+def _transform_delimited(
+    text: str,
+    delimiters: tuple[tuple[str, str], ...],
+    undo: bool,
+) -> str:
+    output: list[str] = []
+    index = 0
+    while match := _next_delimiter(text, index, delimiters):
+        start, opening, closing = match
+        end = _find_unescaped(text, closing, start + len(opening))
+        if end < 0:
+            break
+        output.append(text[index:start + len(opening)])
+        output.append(_transform_fragment(text[start + len(opening):end], undo))
+        output.append(closing)
+        index = end + len(closing)
+    output.append(text[index:])
+    return "".join(output)
+
+
+def _find_active(text: str, token: str, start: int) -> int:
+    index = start
+    while index < len(text):
+        if text[index] == "%" and not _is_escaped(text, index):
+            index = read_comment_end(text, index)
+            continue
+        if text[index] == "\\":
+            verb = read_verb_end(text, index)
+            if verb is not None:
+                index = verb[0]
+                continue
+        if text.startswith(token, index) and not _is_escaped(text, index):
+            return index
+        index += 1
+    return -1
+
+
+def _find_dollar(text: str, start: int, width: int) -> int:
+    token = "$" * width
+    index = start
+    while (index := _find_active(text, token, index)) >= 0:
+        before = index > 0 and text[index - 1] == "$"
+        after = index + width < len(text) and text[index + width] == "$"
+        if not before and not after:
+            return index
+        index += width
+    return -1
+
+
+def _transform_tex_math(text: str, undo: bool) -> str:
+    output: list[str] = []
+    index = 0
+    while index < len(text):
+        if text[index] == "%" and not _is_escaped(text, index):
+            end = read_comment_end(text, index)
+            output.append(text[index:end])
+            index = end
+            continue
+
+        if text[index] == "\\":
+            verb = read_verb_end(text, index)
+            if verb is not None:
+                end = verb[0]
+                output.append(text[index:end])
+                index = end
+                continue
+
+            environment = BEGIN_RE.match(text, index)
+            if environment is not None:
+                name = environment.group(1)
+                closing = rf"\end{{{name}}}"
+                end_start = _find_active(text, closing, environment.end())
+                if end_start >= 0 and name in VERBATIM_ENVIRONMENTS:
+                    end = end_start + len(closing)
+                    output.append(text[index:end])
+                    index = end
+                    continue
+                if end_start >= 0 and name in MATH_ENVIRONMENTS:
+                    end = end_start + len(closing)
+                    output.append(_transform_fragment(text[index:end], undo))
+                    index = end
+                    continue
+
+            pair = next(
+                ((opening, closing) for opening, closing in ((r"\[", r"\]"), (r"\(", r"\)")) if text.startswith(opening, index)),
+                None,
+            )
+            if pair is not None:
+                opening, closing = pair
+                end_start = _find_active(text, closing, index + len(opening))
+                if end_start >= 0:
+                    output.append(opening)
+                    output.append(_transform_fragment(text[index + len(opening):end_start], undo))
+                    output.append(closing)
+                    index = end_start + len(closing)
+                    continue
+
+        if text[index] == "$" and not _is_escaped(text, index):
+            width = 2 if text.startswith("$$", index) else 1
+            end_start = _find_dollar(text, index + width, width)
+            if end_start >= 0:
+                delimiter = "$" * width
+                output.append(delimiter)
+                output.append(_transform_fragment(text[index + width:end_start], undo))
+                output.append(delimiter)
+                index = end_start + width
+                continue
+
+        output.append(text[index])
+        index += 1
+    return "".join(output)
+
+
+def _native_support(text: str) -> str:
+    translated = HEX_COLOR_RE.sub(
+        lambda match: rf"\textcolor{{colormath{match.group(1).lower()}}}",
+        text,
+    )
+    colors = sorted({match.lower() for match in NATIVE_COLOR_RE.findall(translated)})
+    if not colors:
+        return translated
+
+    newline = "\r\n" if "\r\n" in translated else "\n"
+    lines = [NATIVE_BEGIN]
+    user_document = NATIVE_BLOCK_RE.sub("", translated)
+    if not re.search(r"\\usepackage(?:\[[^]]*\])?\{[^}]*\bxcolor\b[^}]*\}", user_document):
+        lines.append(r"\usepackage{xcolor}")
+    lines.extend(
+        rf"\definecolor{{colormath{color}}}{{HTML}}{{{color.upper()}}}"
+        for color in colors
+    )
+    lines.append(NATIVE_END)
+    block = newline.join(lines) + newline
+
+    if NATIVE_BLOCK_RE.search(translated):
+        return NATIVE_BLOCK_RE.sub(lambda _: block, translated, count=1)
+    document_class = re.search(r"(?m)^\\documentclass[^\r\n]*(?:\r?\n|$)", translated)
+    insertion = document_class.end() if document_class else 0
+    return translated[:insertion] + block + translated[insertion:]
+
+
+def _transform_tex(text: str, undo: bool) -> str:
+    if undo:
+        return _transform_tex_math(NATIVE_BLOCK_RE.sub("", text), True)
+    return _native_support(_transform_tex_math(text, False))

color_math/config.py

@@ -0,0 +1,351 @@
+# config.py
+from __future__ import annotations
+from dataclasses import dataclass
+
+DEFAULT_COLORS = {
+    "main": "#7aa2f7",
+    "orange": "#e0af68",
+    "dot": "white",
+    "derivative": "#bb9af7",
+    "chain": "#9ece6a",
+    "upper": "#bb9af7",
+    "relation": "white",
+    "arrow": "#f7768e",
+    "set": "#bb9af7",
+    "spacing": "white",
+    "parameter": "#bb9af7",
+    "unit": "#73daca",
+}
+
+COLORS = dict(DEFAULT_COLORS)
+
+
+BIG_OPERATORS = {
+    r"\sum",
+    r"\prod",
+    r"\coprod",
+    r"\bigcup",
+    r"\bigcap",
+    r"\bigsqcup",
+    r"\bigvee",
+    r"\bigwedge",
+    r"\bigoplus",
+    r"\bigotimes",
+}
+
+
+INTEGRALS = {
+    r"\int",
+    r"\iint",
+    r"\iiint",
+    r"\oint",
+}
+
+
+LIMIT_OPERATORS = {
+    r"\lim",
+    r"\sup",
+    r"\inf",
+    r"\max",
+    r"\min",
+}
+
+
+RELATIONS = {
+    r"\le",
+    r"\ge",
+    r"\ne",
+    r"\neq",
+    r"\leq",
+    r"\geq",
+    r"\approx",
+    r"\sim",
+    r"\equiv",
+    r"\propto",
+    r"\simeq",
+    r"\cong",
+    r"\pm",
+    r"\mp",
+    r"\div",
+    r"\ast",
+    r"\star",
+    r"\circ",
+    r"\bullet",
+    "=",
+    "<",
+    ">",
+}
+
+
+ARROWS = {
+    r"\xrightarrow",
+    r"\xleftarrow",
+    r"\hookrightarrow",
+    r"\hookleftarrow",
+    r"\uparrow",
+    r"\downarrow",
+    r"\implies",
+    r"\iff",
+    r"\longrightarrow",
+    r"\longleftarrow",
+    r"\leftrightarrow",
+    r"\rightarrow",
+    r"\leftarrow",
+    r"\Rightarrow",
+    r"\Leftarrow",
+    r"\Leftrightarrow",
+    r"\mapsto",
+    r"\to",
+}
+
+
+SET_SYMBOLS = {
+    r"\forall",
+    r"\exists",
+    r"\land",
+    r"\lor",
+    r"\ni",
+    r"\sqsubset",
+    r"\sqsubseteq",
+    r"\uplus",
+    r"\notin",
+    r"\subseteq",
+    r"\supseteq",
+    r"\subset",
+    r"\supset",
+    r"\setminus",
+    r"\emptyset",
+    r"\in",
+    r"\cup",
+    r"\cap",
+}
+
+
+SPACING_COMMANDS = {
+    r"\,",
+    r"\:",
+    r"\;",
+    r"\quad",
+    r"\qquad",
+}
+
+
+MULTIPLICATION_SYMBOLS = {
+    r"\cdot",
+    r"\times",
+    "·",
+    "*",
+}
+
+
+FUNCTION_COMMANDS = {
+    r"\arccos",
+    r"\arcsin",
+    r"\arctan",
+    r"\cos",
+    r"\cosh",
+    r"\exp",
+    r"\ln",
+    r"\log",
+    r"\sec",
+    r"\sin",
+    r"\sinh",
+    r"\tan",
+    r"\tanh",
+}
+
+
+# Combined commands that should receive special coloring
+COLOR_COMMANDS = (
+    BIG_OPERATORS
+    | INTEGRALS
+    | LIMIT_OPERATORS
+    | RELATIONS
+    | ARROWS
+    | SET_SYMBOLS
+    | SPACING_COMMANDS
+    | MULTIPLICATION_SYMBOLS
+)
+
+
+# Longest first so scanner matches \longrightarrow before \to
+SORTED_COLOR_COMMANDS = sorted(
+    COLOR_COMMANDS,
+    key=len,
+    reverse=True,
+)
+
+
+MATH_CONSTANTS = {
+    r"\pi",
+    r"\varpi",
+    r"\hbar",
+    r"\infty",
+    r"\ell",
+    r"\aleph",
+    r"\Re",
+    r"\Im",
+    r"\top",
+    r"\bot",
+}
+
+
+MATH_ACCENTS = {
+    r"\dot",
+    r"\ddot",
+    r"\dddot",
+    r"\ddddot",
+    r"\hat",
+    r"\widehat",
+    r"\tilde",
+    r"\widetilde",
+    r"\bar",
+    r"\vec",
+    r"\check",
+    r"\breve",
+    r"\acute",
+    r"\grave",
+    r"\mathring",
+}
+
+
+MATH_PARAMETERS = {
+    r"\alpha",
+    r"\beta",
+    r"\gamma",
+    r"\delta",
+    r"\epsilon",
+    r"\varepsilon",
+    r"\zeta",
+    r"\eta",
+    r"\theta",
+    r"\vartheta",
+    r"\iota",
+    r"\kappa",
+    r"\lambda",
+    r"\mu",
+    r"\nu",
+    r"\xi",
+    r"\rho",
+    r"\varrho",
+    r"\sigma",
+    r"\varsigma",
+    r"\tau",
+    r"\upsilon",
+    r"\phi",
+    r"\varphi",
+    r"\chi",
+    r"\psi",
+    r"\omega",
+    r"\Gamma",
+    r"\Delta",
+    r"\Theta",
+    r"\Lambda",
+    r"\Xi",
+    r"\Pi",
+    r"\Sigma",
+    r"\Upsilon",
+    r"\Phi",
+    r"\Psi",
+    r"\Omega",
+}
+
+
+MATH_FUNCTIONS = {
+    r"\sin",
+    r"\cos",
+    r"\tan",
+    r"\csc",
+    r"\sec",
+    r"\cot",
+    r"\arcsin",
+    r"\arccos",
+    r"\arctan",
+    r"\sinh",
+    r"\cosh",
+    r"\tanh",
+    r"\coth",
+    r"\ln",
+    r"\log",
+    r"\exp",
+    r"\det",
+    r"\gcd",
+    r"\max",
+    r"\min",
+    r"\dim",
+    r"\ker",
+    r"\hom",
+    r"\deg",
+    r"\arg",
+    r"\Pr",
+    r"\sup",
+    r"\inf",
+}
+
+
+RAINBOW_DELIMITER_COLORS: list[str] = [
+    "#e0af68",  # Tier 0: Gold
+    "#7aa2f7",  # Tier 1: Cyan / Blue
+    "#bb9af7",  # Tier 2: Purple / Lavender
+    "#f7768e",  # Tier 3: Coral / Pink
+]
+
+
+VARIABLE_HASH_PALETTE: list[str] = [
+    "#7aa2f7",  # Tokyo Blue
+    "#7dcfff",  # Tokyo Cyan
+    "#bb9af7",  # Tokyo Purple
+    "#f7768e",  # Tokyo Pink
+    "#e0af68",  # Tokyo Orange/Gold
+    "#9ece6a",  # Tokyo Green
+    "#2ac3de",  # Light Cyan
+    "#ff9e64",  # Peach
+]
+
+
+def hash_string_to_color(s: str, palette: list[str] = VARIABLE_HASH_PALETTE) -> str:
+    """Deterministic string hashing for variable data-flow coloring."""
+    h = 0
+    for char in s:
+        h = (h * 31 + ord(char)) & 0xFFFFFFFF
+        if h >= 0x80000000:
+            h -= 0x100000000
+    idx = abs(h) % len(palette)
+    return palette[idx]
+
+
+@dataclass
+class ColorMathOptions:
+    enable_taxonomy: bool = False
+    rainbow_delimiters: bool = False
+    variable_data_flow: bool = False
+    color_units: bool = False
+    color_differentials: bool = False
+    color_braket: bool = False
+    color_dimensionless: bool = False
+
+    @classmethod
+    def extended(cls) -> ColorMathOptions:
+        """Returns standard extended options matching Obsidian plugin defaults."""
+        return cls(
+            enable_taxonomy=True,
+            rainbow_delimiters=True,
+            variable_data_flow=False,
+            color_units=True,
+            color_differentials=True,
+            color_braket=True,
+            color_dimensionless=True,
+        )
+
+    @classmethod
+    def all_enabled(cls) -> ColorMathOptions:
+        """Returns options with all features enabled including variable data-flow."""
+        return cls(
+            enable_taxonomy=True,
+            rainbow_delimiters=True,
+            variable_data_flow=True,
+            color_units=True,
+            color_differentials=True,
+            color_braket=True,
+            color_dimensionless=True,
+        )

color_math/converters/__init__.py

@@ -0,0 +1,27 @@
+# converters/__init__.py
+
+from .align import convert_align_block
+from .derivative import convert_derivative_line
+from .equation import convert_equation_line
+from .generic import color_latex_body, color_generic_math_line
+from .integral import convert_integral_line
+from .limit import convert_limit_line
+from .matrix import convert_matrix_block
+from .block import convert_math_block, convert_line, convert_text
+
+
+__all__ = [
+    "convert_align_block",
+    "convert_derivative_line",
+    "convert_equation_line",
+    "convert_integral_line",
+    "convert_limit_line",
+    "convert_matrix_block",
+
+    "color_latex_body",
+    "color_generic_math_line",
+
+    "convert_math_block",
+    "convert_line",
+    "convert_text",
+]

color_math/converters/align.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import re
+
+from .generic import color_latex_body
+from .semantic import parse_math_block
+
+
+ALIGN_ENV_RE = re.compile(
+    r"\\begin\s*\{\s*(?:align\*?|aligned|gather\*?|gathered|split)\s*\}"
+)
+
+
+def convert_align_block(block: str) -> str | None:
+    parsed = parse_math_block(block)
+    if parsed is None or ALIGN_ENV_RE.search(parsed.body) is None:
+        return None
+    return parsed.render(color_latex_body(parsed.body))