math2tex 1.0.0__py3-none-any.whl

math2tex/__init__.py

@@ -0,0 +1,84 @@
+"""
+math2tex — A professional plaintext-to-LaTeX mathematical expression engine.
+
+Converts informal math notation into high-quality, publication-ready LaTeX.
+Designed for use with the LaTeX ``physics`` package.
+
+Public API
+----------
+.. autofunction:: math2tex
+.. autofunction:: math2tex_multiline
+.. autofunction:: parse_macro_def
+"""
+
+from typing import List, Optional
+
+from .config import Config
+from .lexer import ParseError, _preprocess, tokenize
+from .parser import Parser
+from .formatter import LatexFormatter
+from .macros import parse_macro_def, Macro, substitute
+
+__all__ = [
+    'math2tex',
+    'math2tex_multiline',
+    'parse_macro_def',
+    'Config',
+    'ParseError',
+    'Macro',
+]
+
+
+def math2tex(expression: str,
+             macro_env: Optional[dict] = None) -> str:
+    try:
+        if macro_env is None:
+            macro_env = {}
+
+        # Expand zero-argument macros before lexing
+        macro = macro_env.get(expression.strip())
+        if macro is not None and not macro.args:
+            formatter = LatexFormatter({})
+            return formatter.format(macro.body, is_root=True)
+
+        preprocessed, text_map = _preprocess(expression)
+        tokens = tokenize(preprocessed)
+        parser = Parser(tokens, text_map=text_map, macro_env=macro_env)
+        ast = parser.parse()
+        formatter = LatexFormatter(text_map)
+        return formatter.format(ast, is_root=True)
+
+    except Exception as e:
+        return f'% Parse Error: {e}'
+
+
+def math2tex_multiline(expressions: List[str],
+                       env: str = None,
+                       macro_env: Optional[dict] = None) -> str:
+    if env is None:
+        env = Config.DEFAULT_ENV
+    if macro_env is None:
+        macro_env = {}
+
+    align_mode = (env == 'align*')
+
+    formatted_lines: List[str] = []
+    for expr in expressions:
+        if not expr.strip():
+            continue
+        try:
+            preprocessed, text_map = _preprocess(expr)
+            tokens = tokenize(preprocessed)
+            parser = Parser(tokens, text_map=text_map, macro_env=macro_env)
+            ast = parser.parse()
+            formatter = LatexFormatter(text_map, align_mode=align_mode)
+            formatted = formatter.format(ast, is_root=True)
+            formatted_lines.append(formatted)
+        except Exception as e:
+            formatted_lines.append(f'% Parse Error: {e}')
+
+    if env == 'none':
+        return '\n'.join(formatted_lines)
+
+    content = ' \\\\\n'.join(formatted_lines)
+    return f'\\begin{{{env}}}\n{content}\n\\end{{{env}}}'

math2tex/ast_nodes.py

@@ -0,0 +1,205 @@
+"""
+math2tex.ast_nodes — Abstract Syntax Tree node definitions
+
+Every AST node is a frozen dataclass carrying a `precedence` property
+used by the formatter to decide where to insert parentheses.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from .config import Prec, _REL_OPS, _ADD_OPS, _MULT_OPS
+
+# =============================================================================
+# Base class
+# =============================================================================
+
+class Node:
+    @property
+    def precedence(self) -> int:
+        return Prec.ATOM
+
+# =============================================================================
+# Atoms
+# =============================================================================
+
+@dataclass(frozen=True)
+class Num(Node):
+    val: str
+
+@dataclass(frozen=True)
+class Var(Node):
+    name: str
+
+@dataclass(frozen=True)
+class TextLiteral(Node):
+    val: str
+
+@dataclass(frozen=True)
+class Group(Node):
+    expr: Node
+
+# =============================================================================
+# Binary / Unary Operations
+# =============================================================================
+
+@dataclass(frozen=True)
+class BinOp(Node):
+    op: str
+    left: Node
+    right: Node
+
+    @property
+    def precedence(self) -> int:
+        if self.op in _REL_OPS:
+            return Prec.REL
+        if self.op == 'choose':
+            return Prec.CHOOSE
+        if self.op in _ADD_OPS:
+            return Prec.ADD
+        if self.op in _MULT_OPS:
+            return Prec.MULT
+        return Prec.LOWEST
+
+@dataclass(frozen=True)
+class UnOp(Node):
+    op: str
+    expr: Node
+
+    @property
+    def precedence(self) -> int:
+        return Prec.UNARY
+
+# =============================================================================
+# Fraction / Power / Subscript
+# =============================================================================
+
+@dataclass(frozen=True)
+class Fraction(Node):
+    num: Node
+    den: Node
+
+@dataclass(frozen=True)
+class Power(Node):
+    base: Node
+    exp: Node
+
+    @property
+    def precedence(self) -> int:
+        return Prec.POW
+
+@dataclass(frozen=True)
+class Subscript(Node):
+    base: Node
+    sub: Node
+
+    @property
+    def precedence(self) -> int:
+        return Prec.POW
+
+# =============================================================================
+# Functions
+# =============================================================================
+
+@dataclass(frozen=True)
+class Func(Node):
+    name: str
+    args: list
+    sub: Optional[Node] = None
+    power: Optional[Node] = None
+    primes: int = 0
+    call_args: Optional[list] = None
+
+# =============================================================================
+# Postfix Operators
+# =============================================================================
+
+@dataclass(frozen=True)
+class Factorial(Node):
+    expr: Node
+
+    @property
+    def precedence(self) -> int:
+        return Prec.POSTFIX
+
+
+@dataclass(frozen=True)
+class Prime(Node):
+    expr: Node
+    order: int
+
+    @property
+    def precedence(self) -> int:
+        return Prec.POSTFIX
+
+# =============================================================================
+# Calculus
+# =============================================================================
+
+@dataclass(frozen=True)
+class Derivative(Node):
+    expr: Node
+    var: str
+    order: Optional[Node]
+    is_partial: bool
+    var2: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class Integral(Node):
+    expr: Node
+    lower: Optional[Node]
+    upper: Optional[Node]
+    kind: str
+
+@dataclass(frozen=True)
+class BigOp(Node):
+    """BigOp class representing bigop."""
+    op_name: str   # 'sum', 'prod', 'lim', etc.
+    lower: Optional[Node]
+    upper: Optional[Node]
+    expr: Node
+
+# =============================================================================
+# Delimiters & Structures
+# =============================================================================
+
+@dataclass(frozen=True)
+class Abs(Node):
+    expr: Node
+
+
+@dataclass(frozen=True)
+class Norm(Node):
+    expr: Node
+
+
+@dataclass(frozen=True)
+class InnerProduct(Node):
+    left: Node
+    right: Node
+
+
+@dataclass(frozen=True)
+class SetBuilder(Node):
+    expr: Node
+    condition: Node
+
+
+@dataclass(frozen=True)
+class MatrixNode(Node):
+    rows: list
+    kind: str = 'pmatrix'
+
+
+@dataclass(frozen=True)
+class IntervalNode(Node):
+    left_delim: str
+    left_expr: Node
+    right_expr: Node
+    right_delim: str
+
+
+@dataclass(frozen=True)
+class PiecewiseNode(Node):
+    conditions: list

math2tex/cli.py

@@ -0,0 +1,60 @@
+"""
+math2tex.cli — Interactive command-line interface.
+
+Provides an interactive REPL for converting plaintext math to LaTeX,
+with support for multi-line input and macro definitions.
+"""
+
+import sys
+
+from . import math2tex, math2tex_multiline, parse_macro_def
+from .config import Config
+
+
+def main() -> None:
+    """Run the interactive conversion loop."""
+    print(f"\nInteractive math2tex converter.")
+    print(f"Type '{Config.MULTI_LINE_END_KEYWORD}' on a new line "
+          f"to process multi-line input.")
+    print(f"Type 'quit' or 'exit' to terminate.\n")
+
+    while True:
+        lines = []
+        while True:
+            try:
+                line = input("> " if not lines else "... ").strip()
+            except EOFError:
+                sys.exit(0)
+
+            if not lines and line.lower() in {'quit', 'exit'}:
+                sys.exit(0)
+
+            if line.upper() == Config.MULTI_LINE_END_KEYWORD:
+                break
+
+            if line:
+                lines.append(line)
+
+        if not lines:
+            continue
+
+        if len(lines) == 1:
+            res = math2tex(lines[0])
+            print(f"$${res}$$")
+        else:
+            env_prompt = input(
+                f"Multiple lines detected. Output in (1) gather* "
+                f"or (2) align* environment? "
+                f"[Default: {Config.DEFAULT_ENV}]: "
+            ).strip()
+            if env_prompt == '1' or env_prompt.lower() == 'gather*':
+                env = 'gather*'
+            elif env_prompt == '2' or env_prompt.lower() == 'align*':
+                env = 'align*'
+            else:
+                env = Config.DEFAULT_ENV
+
+            result = math2tex_multiline(lines, env)
+            print(f"{result}")
+
+main()

math2tex/config.py

@@ -0,0 +1,213 @@
+"""
+math2tex.config — Constants, maps, and global configuration.
+
+All token dictionaries, operator sets, and structural configuration
+values are centralised here to provide a single source of truth across
+all compiler modules.
+"""
+
+# =============================================================================
+# Global Configuration
+# =============================================================================
+
+class Config:
+    DEFAULT_ENV = 'gather*'
+    AUTO_ALIGN_EQUALS = True
+    ADD_DX_TO_INTEGRALS = True
+    MULTI_LINE_END_KEYWORD = 'DONE'
+
+# =============================================================================
+# Unicode Translation Map
+# =============================================================================
+
+UNICODE_MAP = {
+    'α': 'alpha', 'β': 'beta', 'γ': 'gamma', 'δ': 'delta', 'ε': 'epsilon',
+    'varepsilon': 'varepsilon',
+    'ζ': 'zeta', 'η': 'eta', 'θ': 'theta', 'ι': 'iota', 'κ': 'kappa',
+    'λ': 'lambda', 'μ': 'mu', 'ν': 'nu', 'ξ': 'xi', 'π': 'pi',
+    'ρ': 'rho', 'σ': 'sigma', 'τ': 'tau', 'υ': 'upsilon', 'φ': 'phi',
+    'χ': 'chi', 'ψ': 'psi', 'ω': 'omega',
+    'Γ': 'Gamma', 'Δ': 'Delta', 'Θ': 'Theta', 'Λ': 'Lambda',
+    'Ξ': 'Xi', 'Π': 'Pi', 'Σ': 'Sigma', 'Υ': 'Upsilon',
+    'Φ': 'Phi', 'Ψ': 'Psi', 'Ω': 'Omega',
+    '∫': 'integral', '∬': 'iint', '∭': 'iiint', '∮': 'oint', '∯': 'oiint',
+    '∇': 'nabla', '∂': 'partial', '∞': 'oo',
+    '≈': 'approx', '≡': 'equiv', '∝': 'propto',
+    '≠': '!=',
+    '≤': '<=', '≥': '>=', '∈': 'in', '∉': 'notin', '⊂': 'subset',
+    '⊃': 'supset', '⊆': 'subseteq', '⊇': 'supseteq',
+    '∅': 'emptyset',
+    '∪': 'cup', '∩': 'cap', '×': 'times', '±': 'pm', '∓': 'mp',
+    '→': '->', '⇒': 'implies', '⇔': 'iff', '↦': 'mapsto',
+}
+
+# =============================================================================
+# Function & Operator Vocabularies
+# =============================================================================
+
+SPLITTABLE_FUNCS = tuple(sorted([
+    'sin', 'cos', 'tan', 'cot', 'sec', 'csc',
+    'arcsin', 'arccos', 'arctan', 'arccot', 'arcsec', 'arccsc',
+    'sinh', 'cosh', 'tanh', 'coth',
+    'ln', 'log', 'exp', 'det', 'dim', 'ker', 'deg', 'arg', 'gcd',
+    'min', 'max',
+], key=lambda x: (-len(x), x)))
+
+MATRIX_FUNCS = {
+    'pmat': 'pmatrix', 'bmat': 'bmatrix', 'vmat': 'vmatrix',
+    'Vmat': 'Vmatrix', 'Bmat': 'Bmatrix',
+}
+
+GREEK_LETTERS = {
+    'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'varepsilon', 'zeta',
+    'eta', 'theta', 'vartheta', 'iota', 'kappa', 'lambda', 'mu', 'nu',
+    'xi', 'pi', 'varpi', 'rho', 'varrho', 'sigma', 'varsigma', 'tau',
+    'upsilon', 'phi', 'varphi', 'chi', 'psi', 'omega',
+    'Gamma', 'Delta', 'Theta', 'Lambda', 'Xi', 'Pi', 'Sigma', 'Upsilon',
+    'Phi', 'Psi', 'Omega',
+}
+
+SPECIAL_CONSTANTS = {
+    'oo': r'\infty', 'infinity': r'\infty', 'infty': r'\infty', 'inf': r'\infty',
+    'Re': r'\Re', 'Im': r'\Im',
+    'nabla': r'\nabla', 'grad': r'\grad', 'curl': r'\curl',
+    'laplacian': r'\laplacian',
+    'hbar': r'\hbar', 'ell': r'\ell', 'aleph': r'\aleph',
+    'emptyset': r'\emptyset', 'varnothing': r'\varnothing',
+    'imath': r'\imath', 'jmath': r'\jmath',
+    'forall': r'\forall', 'exists': r'\exists', 'nexists': r'\nexists',
+    'therefore': r'\therefore', 'because': r'\because',
+    'cdots': r'\cdots', 'ldots': r'\ldots', 'vdots': r'\vdots',
+    'ddots': r'\ddots',
+    'QED': r'\blacksquare', 'qed': r'\blacksquare',
+}
+
+# =============================================================================
+# Operator Vocabularies (word-form)
+# =============================================================================
+
+# Word-form relational operators (parsed at relational precedence level)
+WORD_RELATIONS = {
+    'in': r'\in', 'notin': r'\notin', 'ni': r'\ni',
+    'subset': r'\subset', 'supset': r'\supset',
+    'subseteq': r'\subseteq', 'supseteq': r'\supseteq',
+    'approx': r'\approx', 'equiv': r'\equiv',
+    'propto': r'\propto', 'sim': r'\sim', 'cong': r'\cong',
+    'perp': r'\perp', 'neq': r'\neq', 'ne': r'\neq',
+    'implies': r'\implies', 'iff': r'\iff', 'mapsto': r'\mapsto',
+}
+
+# Word-form multiplicative operators
+WORD_MULT_OPS = {
+    'times': r'\times', 'cross': r'\times',
+    'cdot': r'\cdot',
+    'cup': r'\cup', 'cap': r'\cap',
+    'union': r'\cup', 'intersect': r'\cap',
+    'setminus': r'\setminus',
+    'oplus': r'\oplus', 'otimes': r'\otimes',
+    'wedge': r'\wedge', 'vee': r'\vee',
+}
+
+# Word-form additive operators
+WORD_ADD_OPS = {
+    'pm': r'\pm', 'mp': r'\mp',
+}
+
+# =============================================================================
+# Function Classification Sets
+# =============================================================================
+
+BUILTIN_LATEX_FUNCS = {
+    'sin', 'cos', 'tan', 'cot', 'sec', 'csc',
+    'arcsin', 'arccos', 'arctan', 'arccot', 'arcsec', 'arccsc',
+    'sinh', 'cosh', 'tanh', 'coth',
+    'ln', 'log', 'exp', 'min', 'max',
+    'det', 'dim', 'ker', 'deg', 'arg', 'gcd',
+    'Re', 'Im',
+}
+
+ACCENT_FUNCTIONS = {
+    'hat': 'hat', 'bar': 'bar', 'vec': 'vec', 'tilde': 'tilde',
+    'dot': 'dot', 'ddot': 'ddot', 'dddot': 'dddot',
+    'overline': 'overline', 'underline': 'underline',
+    'widehat': 'widehat', 'widetilde': 'widetilde',
+    'check': 'check', 'breve': 'breve', 'acute': 'acute',
+    'grave': 'grave', 'mathring': 'mathring',
+    'overbrace': 'overbrace', 'underbrace': 'underbrace',
+}
+
+FONT_FUNCTIONS = {
+    'mathbf': 'mathbf', 'mathrm': 'mathrm', 'mathit': 'mathit',
+    'mathcal': 'mathcal', 'mathbb': 'mathbb', 'mathfrak': 'mathfrak',
+    'mathscr': 'mathscr', 'boldsymbol': 'boldsymbol', 'bm': 'bm',
+    'operatorname': 'operatorname',
+}
+
+BIG_OPS = {
+    'sum', 'prod', 'lim', 'inf', 'sup', 'limsup', 'liminf',
+    'integral', 'integrate', 'int', 'iint', 'iiint', 'oint', 'oiint',
+}
+
+SPECIAL_FUNC_NAMES = (
+    {'sqrt', 'root', 'floor', 'ceil', 'exp', 'abs', 'norm',
+     'text', 'binom', 'boxed', 'cancel'}
+    | set(ACCENT_FUNCTIONS) | set(FONT_FUNCTIONS)
+)
+
+ALL_FUNC_NAMES = BUILTIN_LATEX_FUNCS | SPECIAL_FUNC_NAMES
+
+IMPLICIT_MULT_STOP = (
+    {'if', 'otherwise', 'else', 'choose', 'from', 'to', 'of', 'as'}
+    | set(WORD_RELATIONS) | set(WORD_MULT_OPS) | set(WORD_ADD_OPS)
+)
+
+# =============================================================================
+# Precedence Levels
+# =============================================================================
+
+class Prec:
+    """Precedence levels for parsing and formatting."""
+    LOWEST  = 0
+    REL     = 1   # =, <, >, <=, >=, ->, in, implies, etc.
+    CHOOSE  = 2   # choose (binomial)
+    ADD     = 3   # +, -, pm, mp
+    MULT    = 4   # *, /, implicit multiplication, times, cdot
+    UNARY   = 6   # -x, +x, neg
+    POW     = 5   # ^, _
+    POSTFIX = 7   # !, '
+    ATOM    = 8   # numbers, vars, fractions, grouped
+
+
+# Operator category sets for BinOp precedence
+_REL_OPS = (
+    {':', '=', '<', '>', '<=', '>=', '==', '->', '!=', '~='}
+    | set(WORD_RELATIONS)
+)
+_ADD_OPS = {'+', '-', '+-', '-+'} | set(WORD_ADD_OPS)
+_MULT_OPS = {'*', ' '} | set(WORD_MULT_OPS)
+
+# =============================================================================
+# Parser Limits
+# =============================================================================
+
+MAX_DEPTH = 200
+
+# =============================================================================
+# Utility Functions
+# =============================================================================
+
+def levenshtein_distance(s1: str, s2: str) -> int:
+    if len(s1) < len(s2):
+        return levenshtein_distance(s2, s1)
+    if len(s2) == 0:
+        return len(s1)
+    previous_row = range(len(s2) + 1)
+    for i, c1 in enumerate(s1):
+        current_row = [i + 1]
+        for j, c2 in enumerate(s2):
+            insertions = previous_row[j + 1] + 1
+            deletions = current_row[j] + 1
+            substitutions = previous_row[j] + (c1 != c2)
+            current_row.append(min(insertions, deletions, substitutions))
+        previous_row = current_row
+    return previous_row[-1]