python-color-math 0.2.0__tar.gz → 0.2.1__tar.gz

{python_color_math-0.2.0/python_color_math.egg-info → python_color_math-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-color-math
-Version: 0.2.0
+Version: 0.2.1
 Summary: A fast, local semantic LaTeX colorizer for Markdown, Jupyter, and LaTeX math equations.
 Author: Aditya
 License: MIT License
@@ -51,6 +51,8 @@ Classifier: Topic :: Text Processing :: Markup :: Markdown
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == "mcp"
 Dynamic: license-file
 
 # 🎨 Python Color Math
@@ -230,7 +232,7 @@ Integrate `color-math` into your git workflow using [pre-commit](https://pre-com
 ```yaml
 repos:
   - repo: https://github.com/36ty-blip/color-math
-    rev: v0.2.0
+    rev: v0.2.1
     hooks:
       # Formatter: colorizes modified Markdown, LaTeX, and Jupyter files in-place
       - id: color-math

{python_color_math-0.2.0 → python_color_math-0.2.1}/README.md

@@ -175,7 +175,7 @@ Integrate `color-math` into your git workflow using [pre-commit](https://pre-com
 ```yaml
 repos:
   - repo: https://github.com/36ty-blip/color-math
-    rev: v0.2.0
+    rev: v0.2.1
     hooks:
       # Formatter: colorizes modified Markdown, LaTeX, and Jupyter files in-place
       - id: color-math

{python_color_math-0.2.0 → python_color_math-0.2.1}/color_math/__init__.py

@@ -5,7 +5,7 @@ from .config import ColorMathOptions
 from .converters.block import convert_text
 from .undo import uncolor_text
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = [
     "__version__",

{python_color_math-0.2.0 → python_color_math-0.2.1}/color_math/config.py

@@ -272,7 +272,7 @@ FONT_STYLE_MACROS = frozenset({
 })
 
 
-BARE_FUNCTIONS = frozenset({
+STANDARD_BARE_FUNCTIONS = frozenset({
     "sin",
     "cos",
     "tan",
@@ -313,6 +313,9 @@ BARE_FUNCTIONS = frozenset({
     "span",
     "diag",
     "sgn",
+})
+
+EXTENDED_BARE_FUNCTIONS = frozenset({
     "adj",
     "col",
     "row",
@@ -349,15 +352,40 @@ BARE_FUNCTIONS = frozenset({
     "lg",
     "lb",
     "aut",
-    "end",
     "gal",
     "ann",
     "tor",
     "ext",
     "pic",
     "cl",
+    "jac",
+    "hes",
+    "wr",
+    "vol",
+    "rms",
+    "fft",
+    "dft",
+    "ord",
+    "val",
+    "num",
+    "den",
+    "sn",
+    "cn",
+    "dn",
+    "avg",
+    "len",
 })
 
+FULL_BARE_FUNCTIONS = STANDARD_BARE_FUNCTIONS | EXTENDED_BARE_FUNCTIONS
+ALL_BARE_FUNCTIONS = FULL_BARE_FUNCTIONS
+BARE_FUNCTIONS = FULL_BARE_FUNCTIONS
+
+
+def get_bare_functions(options: ColorMathOptions | None = None) -> frozenset[str]:
+    if options is not None and not options.extended_functions:
+        return STANDARD_BARE_FUNCTIONS
+    return FULL_BARE_FUNCTIONS
+
 
 MATH_ACCENTS = {
     r"\dot",
@@ -497,6 +525,22 @@ MATH_FUNCTIONS = {
     r"\ext",
     r"\pic",
     r"\cl",
+    r"\jac",
+    r"\hes",
+    r"\wr",
+    r"\vol",
+    r"\rms",
+    r"\fft",
+    r"\dft",
+    r"\ord",
+    r"\val",
+    r"\num",
+    r"\den",
+    r"\sn",
+    r"\cn",
+    r"\dn",
+    r"\avg",
+    r"\len",
 }
 
 
@@ -540,8 +584,10 @@ class ColorMathOptions:
     color_differentials: bool = False
     color_braket: bool = False
     color_dimensionless: bool = False
-    color_alignment: bool = True
-    color_single_constants: bool = True
+    color_alignment: bool = False
+    color_single_constants: bool = False
+    normalize_braces: bool = False
+    extended_functions: bool = True
 
     @classmethod
     def extended(cls) -> ColorMathOptions:
@@ -556,6 +602,8 @@ class ColorMathOptions:
             color_dimensionless=True,
             color_alignment=True,
             color_single_constants=True,
+            normalize_braces=False,
+            extended_functions=True,
         )
 
     @classmethod
@@ -569,6 +617,10 @@ class ColorMathOptions:
             color_differentials=True,
             color_braket=True,
             color_dimensionless=True,
+            color_alignment=True,
+            color_single_constants=True,
+            normalize_braces=False,
+            extended_functions=True,
         )
 
 

{python_color_math-0.2.0 → python_color_math-0.2.1}/color_math/converters/block.py

@@ -130,18 +130,28 @@ def convert_text(
 
     Handles:
       - single-line and multiline $$ ... $$ math blocks
+      - inline $ ... $ math expressions
       - normal text passthrough
     """
-
-    math_blocks = scan_markdown(text).math_blocks
-    if not math_blocks:
+    scan = scan_markdown(text)
+    all_spans = sorted(
+        [*scan.math_blocks, *scan.math_inlines],
+        key=lambda s: s.start,
+    )
+    if not all_spans:
         return text
 
     converted: list[str] = []
     index = 0
-    for span in math_blocks:
+    for span in all_spans:
         converted.append(text[index:span.start])
-        converted.append(convert_math_block(text[span.start:span.end], palette, options))
+        if span.kind == "math_inline":
+            raw = text[span.content_start:span.content_end]
+            converted.append(f"${color_latex_body(raw, palette, options)}$")
+        else:
+            converted.append(
+                convert_math_block(text[span.start:span.end], palette, options)
+            )
         index = span.end
     converted.append(text[index:])
     return "".join(converted)

{python_color_math-0.2.0 → python_color_math-0.2.1}/color_math/converters/derivative.py

@@ -15,6 +15,7 @@ from ..parsers.latex_spans import (
 from ..parsers.scanner import collect_operator_spans
 from ..utils.latex_helpers import contains_color_wrapper
 from ..utils.spans import ColorSpan, apply_color_spans
+from ..undo import uncolor_text
 from .semantic import first_equality, parse_math_block, relation_spans, trim_range
 
 
@@ -221,7 +222,8 @@ def _rhs_spans(body: str, start: int, end: int | None = None) -> list[ColorSpan]
 
 def convert_derivative_line(source: str) -> str | None:
     """Color a derivative block by inserting wrappers into its exact source."""
-    block = parse_math_block(source)
+    clean_source = uncolor_text(source) if contains_color_wrapper(source) else source
+    block = parse_math_block(clean_source)
     if block is None:
         return None
 
@@ -229,8 +231,6 @@ def convert_derivative_line(source: str) -> str | None:
     prefix = read_operand(block.body, body_start)
     if prefix is None or not _is_derivative_prefix(prefix.text(block.body)):
         return None
-    if contains_color_wrapper(block.body):
-        return source
 
     equality = first_equality(block.body)
     if equality is None or equality[0] <= prefix.end:

{python_color_math-0.2.0 → python_color_math-0.2.1}/color_math/converters/generic.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import re
 
-from ..config import COLORS, ColorMathOptions
+from ..config import COLORS, ColorMathOptions, get_bare_functions, BARE_FUNCTIONS
 from ..parsers.constants import collect_single_constant_spans
 from ..parsers.math_parser import find_semantic_spans
 from ..parsers.scanner import collect_scanner_spans
@@ -17,6 +17,7 @@ from ..parsers.taxonomy import collect_taxonomy_spans
 from ..parsers.variable_hash import collect_variable_spans
 from ..utils.latex_helpers import contains_color_wrapper, normalize_latex_braces
 from ..utils.spans import ColorSpan, apply_color_spans
+from ..undo import uncolor_fragment
 
 
 MATH_LINE_RE = re.compile(
@@ -25,10 +26,14 @@ MATH_LINE_RE = re.compile(
 FUNCTION_COLOR_NAMES = ("main", "derivative", "chain")
 
 
-def collect_function_spans(body: str, palette: dict[str, str] | None = None) -> list[ColorSpan]:
+def collect_function_spans(
+    body: str,
+    palette: dict[str, str] | None = None,
+    bare_functions: frozenset[str] | None = None,
+) -> list[ColorSpan]:
     """Color nested call names and recognize literal constants."""
     pal = palette or COLORS
-    semantic, _ = find_semantic_spans(body)
+    semantic, _ = find_semantic_spans(body, bare_functions or BARE_FUNCTIONS)
     spans: list[ColorSpan] = []
     for item in semantic:
         if item.kind == "function":
@@ -49,21 +54,38 @@ def color_latex_body(
     options: ColorMathOptions | None = None,
 ) -> str:
     """Insert scoped colors while preserving every original source character."""
-    if contains_color_wrapper(body):
-        return body
+    clean_body = uncolor_fragment(body) if contains_color_wrapper(body) else body
 
     pal = palette or COLORS
     opts = options or ColorMathOptions()
 
-    normalized = normalize_latex_braces(body)
+    normalized = normalize_latex_braces(clean_body) if opts.normalize_braces else clean_body
+
+    need_units = opts.color_units or opts.enable_taxonomy or opts.variable_data_flow
+    need_diffs = opts.color_differentials or opts.enable_taxonomy or opts.variable_data_flow
+    need_dims = opts.color_dimensionless or opts.enable_taxonomy or opts.variable_data_flow
+
+    unit_spans = find_unit_spans(normalized) if need_units else []
+    diff_spans = find_differential_spans(normalized) if need_diffs else []
+    dim_spans = find_dimensionless_spans(normalized) if need_dims else []
+
+    bare_functions = (
+        get_bare_functions(opts)
+        if (opts.enable_taxonomy or opts.variable_data_flow)
+        else frozenset()
+    )
 
-    unit_spans = find_unit_spans(normalized)
-    diff_spans = find_differential_spans(normalized)
-    dim_spans = find_dimensionless_spans(normalized)
+    scanner_spans = collect_scanner_spans(normalized)
+    protected = [*unit_spans, *diff_spans, *dim_spans]
+    if protected:
+        scanner_spans = [
+            s for s in scanner_spans
+            if not any(p.start <= s.start and s.end <= p.end for p in protected)
+        ]
 
     spans: list[ColorSpan] = [
-        *collect_function_spans(normalized, pal),
-        *collect_scanner_spans(normalized),
+        *collect_function_spans(normalized, pal, bare_functions),
+        *scanner_spans,
     ]
 
     if opts.color_units:
@@ -88,7 +110,7 @@ def color_latex_body(
         spans.extend(collect_taxonomy_spans(normalized, pal, unit_spans, diff_spans, dim_spans))
 
     if opts.variable_data_flow:
-        spans.extend(collect_variable_spans(normalized, None, unit_spans, diff_spans, dim_spans))
+        spans.extend(collect_variable_spans(normalized, None, unit_spans, diff_spans, dim_spans, bare_functions))
 
     return apply_color_spans(normalized, spans)
 

{python_color_math-0.2.0 → python_color_math-0.2.1}/color_math/converters/matrix.py

@@ -9,6 +9,7 @@ from ..parsers.latex_spans import OperandSpan, find_operand_spans, read_operand
 from ..parsers.scanner import collect_operator_spans, collect_structured_spans
 from ..utils.latex_helpers import contains_color_wrapper
 from ..utils.spans import ColorSpan, apply_color_spans
+from ..undo import uncolor_text
 from .semantic import first_equality, parse_math_block, relation_spans
 
 
@@ -79,6 +80,8 @@ def _operand_color_spans(
     spans: list[ColorSpan] = []
     semantic_index = 0
     for operand in operands:
+        if operand.kind in ("matrix", "environment"):
+            continue
         value = re.sub(r"\s+", "", operand.text(body))
         if NUMBER_RE.fullmatch(value):
             name = "orange"
@@ -102,11 +105,10 @@ def _operator_spans(body: str) -> list[ColorSpan]:
 
 def convert_matrix_block(source: str) -> str | None:
     """Color complete matrix/tensor operands without reconstructing LaTeX."""
-    block = parse_math_block(source)
+    clean_source = uncolor_text(source) if contains_color_wrapper(source) else source
+    block = parse_math_block(clean_source)
     if block is None or not _is_matrix_expression(block.body):
         return None
-    if contains_color_wrapper(block.body):
-        return source
 
     equality = first_equality(block.body)
     if equality is None:

{python_color_math-0.2.0 → python_color_math-0.2.1}/color_math/main.py

@@ -32,7 +32,7 @@ from .parsers.math_parser import describe_math_blocks
 from .self_test import run_self_test
 from .tutorial import run_tutorial
 
-VERSION = "0.2.0"
+VERSION = "0.2.1"
 SUPPORTED_EXTENSIONS = {".md", ".markdown", ".qmd", ".ipynb", ".tex", ".latex"}
 DEFAULT_EXCLUDES = {
     ".git",
@@ -297,6 +297,11 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Open the interactive graphical window with preview, colors, and settings.",
     )
+    interactive_group.add_argument(
+        "--mcp",
+        action="store_true",
+        help="Launch the Model Context Protocol (MCP) server over stdio for AI assistants.",
+    )
     interactive_group.add_argument(
         "--tutorial",
         action="store_true",
@@ -584,6 +589,16 @@ def _main_impl(argv: list[str] | None = None) -> int:
             options=options,
         )
 
+    # Launch Model Context Protocol (MCP) Server
+    if args.mcp:
+        try:
+            from .mcp_server import run_mcp_server
+        except ImportError as exc:
+            sys.stderr.write(f"Error starting Color Math MCP server:\n{exc}\n")
+            return 1
+        run_mcp_server(transport="stdio")
+        return 0
+
     # Generate shell autocompletion script
     if args.generate_completion:
         script = get_completion_script(args.generate_completion)

python_color_math-0.2.1/color_math/mcp.py

@@ -0,0 +1,42 @@
+"""Direct module entrypoint for running the Color Math MCP server: python -m color_math.mcp"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="color-math-mcp",
+        description="Run the Python Color Math Model Context Protocol (MCP) server.",
+    )
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse", "streamable-http"],
+        default="stdio",
+        help="Transport protocol (default: stdio)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port for SSE or HTTP transport (default: 8000)",
+    )
+    args = parser.parse_args()
+
+    try:
+        from .mcp_server import run_mcp_server
+    except ImportError as e:
+        print(f"Error starting Color Math MCP server:\n{e}", file=sys.stderr)
+        sys.exit(1)
+
+    extra_kwargs = {}
+    if args.transport in {"sse", "streamable-http"}:
+        extra_kwargs["port"] = args.port
+
+    run_mcp_server(transport=args.transport, **extra_kwargs)
+
+
+if __name__ == "__main__":
+    main()