pymu-eval 0.0.1__py3-none-any.whl

pymu_eval/__init__.py

@@ -0,0 +1,75 @@
+"""
+pymu-eval (pymu_eval): Python implementation of the muParser mathematical expression parser
+with native support for scalars, NumPy ndarrays, xarray DataArrays, and xarray Datasets.
+"""
+
+from .bytecode import ParserByteCode, SToken
+from .definitions import (
+    CmdCode,
+    DEFAULT_OPRT,
+    ECmdCode,
+    EErrorCodes,
+    EOprtAssociativity,
+    EOprtPrecedence,
+    EParserVersionInfo,
+    ESynCodes,
+    ETypeCode,
+    ErrorCode,
+    MaxLenExpression,
+    MaxLenIdentifier,
+    MaxNestingDepth,
+    OprtAssociativity,
+    OprtPrecedence,
+    PUBLIC_ENUMS,
+    ParserVersion,
+    ParserVersionDate,
+    TypeCode,
+)
+from .errors import ERROR_MESSAGES, ParserError
+from .math_impl import MathImpl, ParserIntMathImpl
+from .parser import Parser, ParserBase, ParserInt, eval_expr, evaluate
+from .token_reader import ParserCallback, ParserToken, ParserTokenReader, Variable, VariableRef
+
+# Export enum members at package level for C++-style compatibility
+for _enum_cls in PUBLIC_ENUMS:
+    globals().update(_enum_cls.__members__)
+
+__version__ = "2.3.6"
+
+__all__ = [
+    "Parser",
+    "ParserBase",
+    "ParserInt",
+    "ParserError",
+    "ParserByteCode",
+    "SToken",
+    "ParserCallback",
+    "ParserToken",
+    "ParserTokenReader",
+    "Variable",
+    "VariableRef",
+    "MathImpl",
+    "ParserIntMathImpl",
+    "eval_expr",
+    "evaluate",
+    "ECmdCode",
+    "CmdCode",
+    "ETypeCode",
+    "TypeCode",
+    "EParserVersionInfo",
+    "EOprtAssociativity",
+    "OprtAssociativity",
+    "EOprtPrecedence",
+    "OprtPrecedence",
+    "ESynCodes",
+    "EErrorCodes",
+    "ErrorCode",
+    "ERROR_MESSAGES",
+    "DEFAULT_OPRT",
+    "MaxLenExpression",
+    "MaxLenIdentifier",
+    "MaxNestingDepth",
+    "ParserVersion",
+    "ParserVersionDate",
+    "__version__",
+]

pymu_eval/bytecode.py

@@ -0,0 +1,383 @@
+"""
+Bytecode representation and optimizer for pymu-eval.
+Mirrors muParserBytecode.h and muParserBytecode.cpp.
+"""
+
+from __future__ import annotations
+
+# pylint: disable=invalid-name
+
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+from .definitions import ECmdCode, EErrorCodes
+from .errors import ParserError
+from .math_impl import MathImpl, is_array_like
+from .token_reader import ParserCallback, VariableRef
+
+
+@dataclass
+class SToken:  # pylint: disable=too-many-instance-attributes
+    """
+    Single bytecode instruction in the RPN stream.
+    Mirrors mu::SToken.
+    """
+
+    Cmd: ECmdCode = ECmdCode.cmUNKNOWN
+    # Value / Variable fields
+    ptr: Optional[VariableRef] = None
+    data: Any = 0.0
+    data2: Any = 0.0
+    # Operator / Jump fields
+    offset: int = 0
+    # Function fields
+    argc: int = 0
+    idx: int = 0
+    cb: Optional[ParserCallback] = None
+
+    def copy(self) -> SToken:
+        """Return a shallow copy of this bytecode instruction."""
+        return SToken(
+            Cmd=self.Cmd,
+            ptr=self.ptr,
+            data=self.data,
+            data2=self.data2,
+            offset=self.offset,
+            argc=self.argc,
+            idx=self.idx,
+            cb=self.cb,
+        )
+
+
+_FOLD_OP_MAP: dict[ECmdCode, Callable[[Any, Any], Any]] = {
+    ECmdCode.cmLAND: MathImpl.LAND,
+    ECmdCode.cmLOR: MathImpl.LOR,
+    ECmdCode.cmLT: MathImpl.LT,
+    ECmdCode.cmGT: MathImpl.GT,
+    ECmdCode.cmLE: MathImpl.LE,
+    ECmdCode.cmGE: MathImpl.GE,
+    ECmdCode.cmNEQ: MathImpl.NEQ,
+    ECmdCode.cmEQ: MathImpl.EQ,
+    ECmdCode.cmADD: lambda a, b: a + b,
+    ECmdCode.cmSUB: lambda a, b: a - b,
+    ECmdCode.cmMUL: lambda a, b: a * b,
+    ECmdCode.cmPOW: MathImpl.Pow,
+}
+
+_POW_CMD_MAP: dict[int, ECmdCode] = {
+    1: ECmdCode.cmVAR,
+    2: ECmdCode.cmVARPOW2,
+    3: ECmdCode.cmVARPOW3,
+    4: ECmdCode.cmVARPOW4,
+}
+
+
+class ParserByteCode:
+    """
+    Bytecode storage and constant/polynomial optimizer.
+    Mirrors mu::ParserByteCode.
+    """
+
+    def __init__(self) -> None:
+        self._stack_pos: int = 0
+        self._max_stack_size: int = 0
+        self._rpn: list[SToken] = []
+        self._enable_optimizer: bool = True
+        self._string_buffer: list[str] = []
+        self._expr: str = ""
+
+    def copy(self) -> ParserByteCode:
+        """Create a deep copy of this bytecode sequence."""
+        bc = ParserByteCode()
+        # pylint: disable=protected-access
+        bc._stack_pos = self._stack_pos
+        bc._max_stack_size = self._max_stack_size
+        bc._rpn = [t.copy() for t in self._rpn]
+        bc._enable_optimizer = self._enable_optimizer
+        bc._string_buffer = list(self._string_buffer)
+        bc._expr = self._expr
+        return bc
+
+    def is_optimizer_enabled(self) -> bool:
+        """Return True if constant folding / algebraic optimization is enabled."""
+        return self._enable_optimizer
+
+    def enable_optimizer(self, stat: bool = True) -> None:
+        """Enable or disable bytecode optimization."""
+        self._enable_optimizer = stat
+
+    def add_var(self, var_ref: VariableRef) -> None:
+        """Emit a variable load instruction."""
+        self._stack_pos += 1
+        self._max_stack_size = max(self._max_stack_size, self._stack_pos)
+        self._rpn.append(
+            SToken(
+                Cmd=ECmdCode.cmVAR,
+                ptr=var_ref,
+                data=1.0,
+                data2=0.0,
+            )
+        )
+
+    def add_val(self, val: Any) -> None:
+        """Emit a constant value load instruction."""
+        self._stack_pos += 1
+        self._max_stack_size = max(self._max_stack_size, self._stack_pos)
+        self._rpn.append(
+            SToken(
+                Cmd=ECmdCode.cmVAL,
+                ptr=None,
+                data=0.0,
+                data2=val,
+            )
+        )
+
+    def _constant_folding(self, oprt: ECmdCode) -> bool:
+        sz = len(self._rpn)
+        x = self._rpn[sz - 2].data2
+        y = self._rpn[sz - 1].data2
+
+        if oprt in _FOLD_OP_MAP:
+            self._rpn[sz - 2].data2 = _FOLD_OP_MAP[oprt](x, y)
+            self._rpn.pop()
+            return True
+
+        if oprt == ECmdCode.cmDIV:
+            # Leave division by zero to runtime evaluation so it produces inf or nan
+            if not is_array_like(y) and y == 0:
+                return False
+            self._rpn[sz - 2].data2 = MathImpl.Div(x, y)
+            self._rpn.pop()
+            return True
+
+        return False
+
+    def _opt_pow(self, tok_prev: SToken, tok_last: SToken) -> bool:
+        if tok_prev.Cmd != ECmdCode.cmVAR or tok_last.Cmd != ECmdCode.cmVAL:
+            return False
+        exp_val = tok_last.data2
+        if is_array_like(exp_val):
+            return False
+        if exp_val == 0 and (tok_prev.ptr is None or not is_array_like(tok_prev.ptr.get())):
+            tok_prev.Cmd = ECmdCode.cmVAL
+            tok_prev.ptr = None
+            tok_prev.data = 0.0
+            tok_prev.data2 = 1.0
+            self._rpn.pop()
+            return True
+        if exp_val in (1, 2, 3, 4):
+            tok_prev.Cmd = _POW_CMD_MAP[int(exp_val)]
+            self._rpn.pop()
+            return True
+        return False
+
+    def _opt_add_sub(self, oprt: ECmdCode, tok_prev: SToken, tok_last: SToken) -> bool:
+        var_cmds = (ECmdCode.cmVAR, ECmdCode.cmVARMUL)
+        cond = (
+            (tok_last.Cmd in var_cmds and tok_prev.Cmd == ECmdCode.cmVAL)
+            or (tok_last.Cmd == ECmdCode.cmVAL and tok_prev.Cmd in var_cmds)
+            or (
+                tok_last.Cmd in var_cmds
+                and tok_prev.Cmd in var_cmds
+                and tok_prev.ptr is tok_last.ptr
+            )
+        )
+        if not cond:
+            return False
+        sign = -1.0 if oprt == ECmdCode.cmSUB else 1.0
+        tok_prev.Cmd = ECmdCode.cmVARMUL
+        tok_prev.ptr = tok_prev.ptr if tok_prev.ptr is not None else tok_last.ptr
+        tok_prev.data2 = tok_prev.data2 + sign * tok_last.data2
+        tok_prev.data = tok_prev.data + sign * tok_last.data
+        self._rpn.pop()
+        return True
+
+    def _opt_mul(self, tok_prev: SToken, tok_last: SToken) -> bool:
+        if (tok_last.Cmd == ECmdCode.cmVAR and tok_prev.Cmd == ECmdCode.cmVAL) or (
+            tok_last.Cmd == ECmdCode.cmVAL and tok_prev.Cmd == ECmdCode.cmVAR
+        ):
+            tok_prev.Cmd = ECmdCode.cmVARMUL
+            tok_prev.ptr = tok_prev.ptr if tok_prev.ptr is not None else tok_last.ptr
+            tok_prev.data = tok_prev.data2 + tok_last.data2
+            tok_prev.data2 = 0.0
+            self._rpn.pop()
+            return True
+
+        if (tok_last.Cmd == ECmdCode.cmVAL and tok_prev.Cmd == ECmdCode.cmVARMUL) or (
+            tok_last.Cmd == ECmdCode.cmVARMUL and tok_prev.Cmd == ECmdCode.cmVAL
+        ):
+            tok_prev.Cmd = ECmdCode.cmVARMUL
+            tok_prev.ptr = tok_prev.ptr if tok_prev.ptr is not None else tok_last.ptr
+            if tok_last.Cmd == ECmdCode.cmVAL:
+                tok_prev.data = tok_prev.data * tok_last.data2
+                tok_prev.data2 = tok_prev.data2 * tok_last.data2
+            else:
+                tok_prev.data = tok_last.data * tok_prev.data2
+                tok_prev.data2 = tok_last.data2 * tok_prev.data2
+            self._rpn.pop()
+            return True
+
+        if (
+            tok_last.Cmd == ECmdCode.cmVAR
+            and tok_prev.Cmd == ECmdCode.cmVAR
+            and tok_last.ptr is tok_prev.ptr
+        ):
+            tok_prev.Cmd = ECmdCode.cmVARPOW2
+            self._rpn.pop()
+            return True
+
+        return False
+
+    def _opt_div(self, tok_prev: SToken, tok_last: SToken) -> bool:
+        if (
+            tok_last.Cmd == ECmdCode.cmVAL
+            and tok_prev.Cmd == ECmdCode.cmVARMUL
+            and not is_array_like(tok_last.data2)
+            and tok_last.data2 != 0
+        ):
+            tok_prev.data = tok_prev.data / tok_last.data2
+            tok_prev.data2 = tok_prev.data2 / tok_last.data2
+            self._rpn.pop()
+            return True
+        return False
+
+    def add_op(self, oprt: ECmdCode) -> None:
+        """Emit a binary operator instruction, applying constant/linear folding if enabled."""
+        optimized = False
+        sz = len(self._rpn)
+
+        if self._enable_optimizer and sz >= 2:
+            tok_prev = self._rpn[sz - 2]
+            tok_last = self._rpn[sz - 1]
+            if tok_prev.Cmd == ECmdCode.cmVAL and tok_last.Cmd == ECmdCode.cmVAL:
+                optimized = self._constant_folding(oprt)
+            elif oprt == ECmdCode.cmPOW:
+                optimized = self._opt_pow(tok_prev, tok_last)
+            elif oprt in (ECmdCode.cmSUB, ECmdCode.cmADD):
+                optimized = self._opt_add_sub(oprt, tok_prev, tok_last)
+            elif oprt == ECmdCode.cmMUL:
+                optimized = self._opt_mul(tok_prev, tok_last)
+            elif oprt == ECmdCode.cmDIV:
+                optimized = self._opt_div(tok_prev, tok_last)
+
+        if not optimized:
+            self._stack_pos -= 1
+            self._rpn.append(SToken(Cmd=oprt))
+
+    def add_if_else(self, oprt: ECmdCode) -> None:
+        """Emit a conditional jump marker (cmIF, cmELSE, or cmENDIF)."""
+        self._rpn.append(SToken(Cmd=oprt))
+
+    def add_assign_op(self, var_ref: VariableRef) -> None:
+        """Emit a variable assignment instruction."""
+        self._stack_pos -= 1
+        self._rpn.append(SToken(Cmd=ECmdCode.cmASSIGN, ptr=var_ref))
+
+    def add_fun(self, cb: ParserCallback, argc: int, is_optimizable: bool) -> None:
+        """Emit a function call instruction, folding constant arguments when possible."""
+        sz = len(self._rpn)
+        optimize = False
+
+        if is_optimizable and self._enable_optimizer and argc > 0:
+            if cb.func is MathImpl.UnaryPlus:
+                return
+
+            if sz >= argc and all(
+                self._rpn[sz - i - 1].Cmd == ECmdCode.cmVAL for i in range(argc)
+            ):
+                optimize = True
+
+        if optimize:
+            args = [self._rpn[sz - argc + i].data2 for i in range(argc)]
+            val = cb.call_fun(*args)
+            del self._rpn[sz - argc :]
+            self._rpn.append(SToken(Cmd=ECmdCode.cmVAL, ptr=None, data=0.0, data2=val))
+        else:
+            self._rpn.append(SToken(Cmd=ECmdCode.cmFUNC, argc=argc, cb=cb))
+
+        self._stack_pos = self._stack_pos - abs(argc) + 1
+        self._max_stack_size = max(self._max_stack_size, self._stack_pos)
+
+    def add_bulk_fun(self, cb: ParserCallback, argc: int) -> None:
+        """Emit a bulk-mode function call instruction."""
+        self._stack_pos = self._stack_pos - argc + 1
+        self._max_stack_size = max(self._max_stack_size, self._stack_pos)
+        self._rpn.append(SToken(Cmd=ECmdCode.cmFUNC_BULK, argc=argc, cb=cb))
+
+    def add_str_fun(self, cb: ParserCallback, argc: int, idx: int) -> None:
+        """Emit a string-accepting function call instruction."""
+        self._stack_pos = self._stack_pos - argc + 1
+        self._max_stack_size = max(self._max_stack_size, self._stack_pos)
+        self._rpn.append(SToken(Cmd=ECmdCode.cmFUNC_STR, argc=argc, idx=idx, cb=cb))
+
+    def add_mult_str_fun(self, cb: ParserCallback, argc: int, idx: int) -> None:
+        """Emit a variadic string-accepting function call instruction."""
+        self._stack_pos = self._stack_pos - argc + 1
+        self._max_stack_size = max(self._max_stack_size, self._stack_pos)
+        self._rpn.append(SToken(Cmd=ECmdCode.cmFUNC_STR, argc=-argc, idx=idx, cb=cb))
+
+    def finalize(self) -> None:
+        """Append cmEND and compute jump offsets for all if-else-endif blocks."""
+        self._rpn.append(SToken(Cmd=ECmdCode.cmEND))
+
+        st_if: list[int] = []
+        st_else: list[int] = []
+        for i, tok in enumerate(self._rpn):
+            if tok.Cmd == ECmdCode.cmIF:
+                st_if.append(i)
+            elif tok.Cmd == ECmdCode.cmELSE:
+                st_else.append(i)
+                if not st_if:
+                    raise ParserError(EErrorCodes.ecINTERNAL_ERROR)
+                idx = st_if.pop()
+                self._rpn[idx].offset = i - idx
+            elif tok.Cmd == ECmdCode.cmENDIF:
+                if not st_else:
+                    raise ParserError(EErrorCodes.ecINTERNAL_ERROR)
+                idx = st_else.pop()
+                self._rpn[idx].offset = i - idx
+
+    def store_environment(self, expr: str, string_buf: list[str]) -> None:
+        """Save the compiled expression string and string literal buffer."""
+        self._expr = expr
+        self._string_buffer = list(string_buf)
+
+    def restore_environment(self) -> tuple[str, list[str]]:
+        """Return the stored expression string and string literal buffer."""
+        return self._expr, list(self._string_buffer)
+
+    def get_base(self) -> list[SToken]:
+        """Return the underlying list of RPN bytecode tokens."""
+        return self._rpn
+
+    def get_max_stack_size(self) -> int:
+        """Return the maximum evaluation stack depth required."""
+        return self._max_stack_size + 1
+
+    def get_size(self) -> int:
+        """Return the number of tokens in the RPN stream."""
+        return len(self._rpn)
+
+    def clear(self) -> None:
+        """Reset the bytecode stream and stack counters."""
+        self._rpn.clear()
+        self._stack_pos = 0
+        self._max_stack_size = 0
+
+    # C++ style aliases
+    EnableOptimizer = enable_optimizer
+    AddVar = add_var
+    AddVal = add_val
+    AddOp = add_op
+    AddIfElse = add_if_else
+    AddAssignOp = add_assign_op
+    AddFun = add_fun
+    AddBulkFun = add_bulk_fun
+    AddStrFun = add_str_fun
+    AddMultStrFun = add_mult_str_fun
+    Finalize = finalize
+    StoreEnvironment = store_environment
+    RestoreEnvironment = restore_environment
+    GetBase = get_base
+    GetMaxStackSize = get_max_stack_size
+    GetSize = get_size

pymu_eval/definitions.py

@@ -0,0 +1,227 @@
+"""
+Standard definitions, enums, and constants for pymu-eval.
+Mirrors muParserDef.h and muParserTokenReader.h from the C++ muParser library.
+"""
+
+# pylint: disable=invalid-name
+
+from enum import IntEnum, IntFlag
+
+MaxLenExpression: int = 20000
+MaxLenIdentifier: int = 100
+MaxNestingDepth: int = 1000
+
+ParserVersion: str = "2.3.6 (Development)"
+ParserVersionDate: str = "20261110"
+
+DEFAULT_OPRT: tuple[str, ...] = (
+    "<=",
+    ">=",
+    "!=",
+    "==",
+    "<",
+    ">",
+    "+",
+    "-",
+    "*",
+    "/",
+    "^",
+    "&&",
+    "||",
+    "=",
+    "(",
+    ")",
+    "?",
+    ":",
+)
+
+BINARY_OPRT_CODES: frozenset[int] = frozenset(range(14))  # cmLE (0) .. cmASSIGN (13)
+CMP_OPRT_CODES: frozenset[int] = frozenset(range(6))      # cmLE (0) .. cmGT (5)
+ARITH_OPRT_CODES: frozenset[int] = frozenset(range(6, 11))  # cmADD (6) .. cmPOW (10)
+
+
+class ECmdCode(IntEnum):
+    """Bytecode and token command codes (matches mu::ECmdCode)."""
+
+    cmLE = 0            # Operator item: less or equal
+    cmGE = 1            # Operator item: greater or equal
+    cmNEQ = 2           # Operator item: not equal
+    cmEQ = 3            # Operator item: equals
+    cmLT = 4            # Operator item: less than
+    cmGT = 5            # Operator item: greater than
+    cmADD = 6           # Operator item: add
+    cmSUB = 7           # Operator item: subtract
+    cmMUL = 8           # Operator item: multiply
+    cmDIV = 9           # Operator item: division
+    cmPOW = 10          # Operator item: y to the power of ...
+    cmLAND = 11         # Operator item: logical and
+    cmLOR = 12          # Operator item: logical or
+    cmASSIGN = 13       # Operator item: assignment operator
+    cmBO = 14           # Operator item: opening bracket
+    cmBC = 15           # Operator item: closing bracket
+    cmIF = 16           # For use in the ternary if-then-else operator
+    cmELSE = 17         # For use in the ternary if-then-else operator
+    cmENDIF = 18        # For use in the ternary if-then-else operator
+    cmARG_SEP = 19      # Function argument separator
+    cmVAR = 20          # Variable item
+    cmVAL = 21          # Value item
+
+    # For optimization purposes
+    cmVARPOW2 = 22
+    cmVARPOW3 = 23
+    cmVARPOW4 = 24
+    cmVARMUL = 25
+
+    # Operators and functions
+    cmFUNC = 26         # Code for a generic function item
+    cmFUNC_STR = 27     # Code for a function with a string parameter
+    cmFUNC_BULK = 28    # Special callbacks for Bulk mode
+    cmSTRING = 29       # Code for a string token
+    cmOPRT_BIN = 30     # User defined binary operator
+    cmOPRT_POSTFIX = 31 # Code for postfix operators
+    cmOPRT_INFIX = 32   # Code for infix operators
+    cmEND = 33          # End of formula
+    cmUNKNOWN = 34      # Uninitialized item
+
+
+class ETypeCode(IntEnum):
+    """Types internally used by the parser (matches mu::ETypeCode)."""
+
+    tpSTR = 0   # String type
+    tpDBL = 1   # Floating point / numeric / array variables
+    tpVOID = 2  # Undefined type
+
+
+class EParserVersionInfo(IntEnum):
+    """Version info formatting flags."""
+
+    pviBRIEF = 0
+    pviFULL = 1
+
+
+class EOprtAssociativity(IntEnum):
+    """Parser operator associativity values (matches mu::EOprtAssociativity)."""
+
+    oaLEFT = 0
+    oaRIGHT = 1
+    oaNONE = 2
+
+
+class EOprtPrecedence(IntEnum):
+    """Parser operator precedence values (matches mu::EOprtPrecedence)."""
+
+    prLOR = 1       # logic or
+    prLAND = 2      # logic and
+    prBOR = 3       # bitwise or
+    prBAND = 4      # bitwise and
+    prCMP = 5       # comparison operators
+    prADD_SUB = 6   # addition / subtraction
+    prMUL_DIV = 7   # multiplication / division
+    prPOW = 8       # power operator priority (highest)
+
+    # infix / postfix operators
+    prINFIX = 7     # Signs have a higher priority than ADD_SUB, but lower than power operator
+    prPOSTFIX = 7   # Postfix operator priority
+
+
+class ESynCodes(IntFlag):
+    """Syntax flags controlling allowed next tokens during lexing."""
+
+    noNONE = 0
+    noBO = 1 << 0        # to avoid i.e. "cos(7)("
+    noBC = 1 << 1        # to avoid i.e. "sin)" or "()"
+    noVAL = 1 << 2       # to avoid i.e. "tan 2" or "sin(8)3.14"
+    noVAR = 1 << 3       # to avoid i.e. "sin a" or "sin(8)a"
+    noARG_SEP = 1 << 4   # to avoid i.e. ",," or "+," ...
+    noFUN = 1 << 5       # to avoid i.e. "sqrt cos" or "(1)sin"
+    noOPT = 1 << 6       # to avoid i.e. "(+)"
+    noPOSTOP = 1 << 7    # to avoid i.e. "(5!!)" "sin!"
+    noINFIXOP = 1 << 8   # to avoid i.e. "++4" "!!4"
+    noEND = 1 << 9       # to avoid unexpected end of formula
+    noSTR = 1 << 10      # to block numeric arguments on string functions
+    noASSIGN = 1 << 11   # to block assignment to constant i.e. "4=7"
+    noIF = 1 << 12
+    noELSE = 1 << 13
+    sfSTART_OF_LINE = noOPT | noBC | noPOSTOP | noASSIGN | noIF | noELSE | noARG_SEP
+    noANY = (1 << 14) - 1
+
+
+class EErrorCodes(IntEnum):
+    """Error codes (matches mu::EErrorCodes)."""
+
+    # Formula syntax errors
+    ecUNEXPECTED_OPERATOR = 0
+    ecUNASSIGNABLE_TOKEN = 1
+    ecUNEXPECTED_EOF = 2
+    ecUNEXPECTED_ARG_SEP = 3
+    ecUNEXPECTED_ARG = 4
+    ecUNEXPECTED_VAL = 5
+    ecUNEXPECTED_VAR = 6
+    ecUNEXPECTED_PARENS = 7
+    ecUNEXPECTED_STR = 8
+    ecSTRING_EXPECTED = 9
+    ecVAL_EXPECTED = 10
+    ecMISSING_PARENS = 11
+    ecUNEXPECTED_FUN = 12
+    ecUNTERMINATED_STRING = 13
+    ecTOO_MANY_PARAMS = 14
+    ecTOO_FEW_PARAMS = 15
+    ecOPRT_TYPE_CONFLICT = 16
+    ecSTR_RESULT = 17
+
+    # Invalid Parser input Parameters
+    ecINVALID_NAME = 18
+    ecINVALID_BINOP_IDENT = 19
+    ecINVALID_INFIX_IDENT = 20
+    ecINVALID_POSTFIX_IDENT = 21
+
+    ecBUILTIN_OVERLOAD = 22
+    ecINVALID_FUN_PTR = 23
+    ecINVALID_VAR_PTR = 24
+    ecEMPTY_EXPRESSION = 25
+    ecNAME_CONFLICT = 26
+    ecOPT_PRI = 27
+
+    ecDOMAIN_ERROR = 28
+    ecDIV_BY_ZERO = 29
+    ecGENERIC = 30
+    ecLOCALE = 31
+
+    ecUNEXPECTED_CONDITIONAL = 32
+    ecMISSING_ELSE_CLAUSE = 33
+    ecMISPLACED_COLON = 34
+
+    ecUNREASONABLE_NUMBER_OF_COMPUTATIONS = 35
+    ecIDENTIFIER_TOO_LONG = 36
+    ecEXPRESSION_TOO_LONG = 37
+    ecINVALID_CHARACTERS_FOUND = 38
+
+    # Internal errors
+    ecINTERNAL_ERROR = 39
+    ecBYTECODE_IMPORT_EXPORT_DISABLED = 40
+    ecUNARY_PLUS_IN_FRONT_OF_FUNCTION = 41
+    ecNESTING_LIMIT = 42
+
+    ecCOUNT = 43
+    ecUNDEFINED = -1
+
+
+# Convenient aliases
+CmdCode = ECmdCode
+TypeCode = ETypeCode
+OprtAssociativity = EOprtAssociativity
+OprtPrecedence = EOprtPrecedence
+ErrorCode = EErrorCodes
+
+PUBLIC_ENUMS = (
+    ECmdCode,
+    ETypeCode,
+    EParserVersionInfo,
+    EOprtAssociativity,
+    EOprtPrecedence,
+    EErrorCodes,
+)
+
+# Export individual enum members at module level for C++ style access
+for _enum_cls in PUBLIC_ENUMS:
+    globals().update(_enum_cls.__members__)