expression-py 0.1.0__py3-none-any.whl

expression/tokenizer.py

@@ -0,0 +1,171 @@
+# Copyright (C) 2026 Jakub T. Jankiewicz <https://jcu.bi/>
+#
+# This file is part of expression.py.
+#
+# expression.py is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# expression.py is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with expression.py. If not, see <https://www.gnu.org/licenses/>.
+
+import re
+import token
+import tokenize
+
+
+class ExpressionTokenizer:
+    """Custom tokenizer for the expression language, compatible with pegen's Parser."""
+
+    TOKEN_PATTERNS = [
+        ('WHITESPACE', r'[ \t]+'),
+        ('HEX', r'0x[0-9A-Fa-f]+'),
+        ('BIN', r'0b[01]+'),
+        ('FLOAT', r'(?:[0-9]+\.[0-9]*|\.[0-9]+)(?:e[+-]?[0-9]+)?|[0-9]+e[+-]?[0-9]+'),
+        ('INT', r'[0-9]+'),
+        ('DSTRING', r'"[^"\\]*(?:\\[\S\s][^"\\]*)*"'),
+        ('SSTRING', r"'[^'\\]*(?:\\[\S\s][^'\\]*)*'"),
+        ('REGEX', r'/(?:[^/\\]|\\.)+/[imsxUXJ]*'),
+        ('STRICT_EQ', r'==='),
+        ('STRICT_NE', r'!=='),
+        ('EQ', r'=='),
+        ('MATCH', r'=~'),
+        ('NE', r'!='),
+        ('NOT', r'!'),
+        ('ASSIGN', r'='),
+        ('AND', r'&&'),
+        ('OR', r'\|\|'),
+        ('POWER', r'\*\*'),
+        ('SPACESHIP', r'<=>'),
+        ('LSHIFT', r'<<'),
+        ('RSHIFT', r'>>'),
+        ('GE', r'>='),
+        ('LE', r'<='),
+        ('GT', r'>'),
+        ('LT', r'<'),
+        ('PLUS', r'\+'),
+        ('MINUS', r'-'),
+        ('TIMES', r'\*'),
+        ('DIV', r'/'),
+        ('MOD', r'%'),
+        ('AMP', r'&'),
+        ('PIPE', r'\|'),
+        ('QUESTION', r'\?'),
+        ('CARET', r'\^'),
+        ('LPAREN', r'\('),
+        ('RPAREN', r'\)'),
+        ('LBRACKET', r'\['),
+        ('RBRACKET', r'\]'),
+        ('LBRACE', r'\{'),
+        ('RBRACE', r'\}'),
+        ('COMMA', r','),
+        ('COLON', r':'),
+        ('SEMICOLON', r';'),
+        ('DOLLAR_NAME', r'\$[0-9A-Za-z_]+'),
+        ('NAME', r'[A-Za-z_][A-Za-z_0-9]*'),
+    ]
+
+    _compiled = re.compile('|'.join(f'(?P<{name}>{pattern})' for name, pattern in TOKEN_PATTERNS))
+
+    OP_TOKENS = {
+        'STRICT_EQ', 'STRICT_NE', 'EQ', 'MATCH', 'NE', 'NOT', 'ASSIGN',
+        'AND', 'OR', 'POWER', 'SPACESHIP', 'LSHIFT', 'RSHIFT', 'GE', 'LE', 'GT', 'LT',
+        'PLUS', 'MINUS', 'TIMES', 'DIV', 'MOD', 'AMP', 'PIPE', 'QUESTION', 'CARET',
+        'LPAREN', 'RPAREN', 'LBRACKET', 'RBRACKET', 'LBRACE', 'RBRACE',
+        'COMMA', 'COLON', 'SEMICOLON',
+    }
+
+    def __init__(self, text):
+        self._text = text
+        self._tokens = []
+        self._index = 0
+        self._tokenize(text)
+
+    REGEX_TOKEN_TYPE = 100
+
+    def _can_be_regex(self):
+        if not self._tokens:
+            return True
+        last = self._tokens[-1]
+        if last.type == token.NUMBER:
+            return False
+        if last.type == token.NAME:
+            return False
+        if last.type == token.STRING:
+            return False
+        if last.string in (')', ']'):
+            return False
+        return True
+
+    def _tokenize(self, text):
+        pos = 0
+        line = text
+        while pos < len(text):
+            m = self._compiled.match(text, pos)
+            if m is None:
+                raise SyntaxError(f"Unexpected character: {text[pos]!r} at position {pos}")
+            kind = m.lastgroup
+            value = m.group()
+            start = (1, pos)
+            end = (1, pos + len(value))
+            pos = m.end()
+            if kind == 'WHITESPACE':
+                continue
+            if kind == 'REGEX':
+                if self._can_be_regex():
+                    tok = tokenize.TokenInfo(self.REGEX_TOKEN_TYPE, value, start, end, line)
+                else:
+                    div_end = (1, start[1] + 1)
+                    tok = tokenize.TokenInfo(token.OP, '/', start, div_end, line)
+                    self._tokens.append(tok)
+                    pos = start[1] + 1
+                    continue
+            elif kind in ('HEX', 'BIN', 'FLOAT', 'INT'):
+                tok = tokenize.TokenInfo(token.NUMBER, value, start, end, line)
+            elif kind in ('DSTRING', 'SSTRING'):
+                tok = tokenize.TokenInfo(token.STRING, value, start, end, line)
+            elif kind in ('NAME', 'DOLLAR_NAME'):
+                tok = tokenize.TokenInfo(token.NAME, value, start, end, line)
+            elif kind in self.OP_TOKENS:
+                tok = tokenize.TokenInfo(token.OP, value, start, end, line)
+            else:
+                tok = tokenize.TokenInfo(token.OP, value, start, end, line)
+            self._tokens.append(tok)
+        self._tokens.append(
+            tokenize.TokenInfo(token.ENDMARKER, '', (1, pos), (1, pos), line)
+        )
+
+    def peek(self):
+        if self._index < len(self._tokens):
+            return self._tokens[self._index]
+        return self._tokens[-1]
+
+    def getnext(self):
+        tok = self.peek()
+        if self._index < len(self._tokens):
+            self._index += 1
+        return tok
+
+    def mark(self):
+        return self._index
+
+    def reset(self, index):
+        self._index = index
+
+    def diagnose(self):
+        if not self._tokens:
+            return tokenize.TokenInfo(token.ENDMARKER, '', (1, 0), (1, 0), '')
+        return self._tokens[min(self._index, len(self._tokens) - 1)]
+
+    def get_last_non_whitespace_token(self):
+        for i in range(self._index - 1, -1, -1):
+            tok = self._tokens[i]
+            if tok.type not in (token.ENDMARKER, token.NEWLINE, token.INDENT, token.DEDENT):
+                return tok
+        return self._tokens[0] if self._tokens else None

expression_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,350 @@
+Metadata-Version: 2.4
+Name: expression-py
+Version: 0.1.0
+Summary: Mathematical expression evaluation library with PEG parser
+Author-email: "Jakub T. Jankiewicz" <jcubic.jj@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/jcubic/expression.py
+Project-URL: Repository, https://github.com/jcubic/expression.py
+Project-URL: Issues, https://github.com/jcubic/expression.py/issues
+Keywords: expression,evaluator,parser,peg,math
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pegen>=0.3.0
+Dynamic: license-file
+
+# expression.py
+
+[![pip](https://img.shields.io/badge/pip-0.1.0-blue.svg)](https://pypi.org/project/expression-py/)
+[![CI](https://github.com/jcubic/expression.py/actions/workflows/ci.yml/badge.svg)](https://github.com/jcubic/expression.py/actions/workflows/ci.yml)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/expression-py?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/expression-py)
+[![expression.py GitHub repo](https://img.shields.io/badge/github-expression.py-orange?logo=github)](https://github.com/jcubic/expression.py)
+[![Coverage Status](https://coveralls.io/repos/github/jcubic/expression.py/badge.svg?branch=master)](https://coveralls.io/github/jcubic/expression.py?branch=master)
+[![LICENSE GPL-3.0](https://img.shields.io/badge/license-GPL--3.0-blue.svg)](https://github.com/jcubic/expression.py/blob/master/LICENSE)
+
+Mathematical expression evaluation library for Python, built with a PEG parser generated by
+[pegen](https://github.com/we-like-parsers/pegen). An alternative to
+[safeeval](https://pypi.org/project/safeeval/) that supports more Ruby operators like `=~` and array
+operators.
+
+This is a Python port of [jcubic/expression.php](https://github.com/jcubic/expression.php).
+
+## Installation
+
+```bash
+pip install expression-py
+```
+
+## Usage
+
+```python
+from expression import Expression
+
+expr = Expression()
+
+# Basic arithmetic
+expr.evaluate("2 + 3 * 4")       # 14
+expr.evaluate("(2 + 3) * 4")     # 20
+expr.evaluate("2 ** 10")         # 1024
+expr.evaluate("10 % 3")          # 1
+
+# Floating point
+expr.evaluate("0.1 + 0.2")       # 0.30000000000000004
+expr.evaluate("1.5e2")           # 150.0
+
+# Hex and binary literals
+expr.evaluate("0xFF")            # 255
+expr.evaluate("0b1010")          # 10
+
+# Bitshift operators
+expr.evaluate("100 >> 2")        # 25
+expr.evaluate("100 << 2")        # 400
+```
+
+### Variables
+
+```python
+expr = Expression()
+
+# Assignment
+expr.evaluate("x = 10")
+expr.evaluate("x + 2")           # 12
+
+# Pre-set variables
+expr.variables = {"width": 100, "height": 50}
+expr.evaluate("width * height")  # 5000
+```
+
+### Built-in Constants and Functions
+
+```python
+expr = Expression()
+
+# Constants
+expr.evaluate("pi")              # 3.141592653589793
+expr.evaluate("e")               # 2.718281828459045
+
+# Math functions
+expr.evaluate("sqrt(16)")        # 4.0
+expr.evaluate("sin(pi / 2)")     # 1.0
+expr.evaluate("abs(-42)")        # 42
+expr.evaluate("log(e)")          # 1.0
+```
+
+Available built-in functions: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `sqrt`, `abs`, `log`, `ln`.
+
+Aliases: `arcsin`/`arccos`/`arctan`/`arcsinh`/`arccosh`/`arctanh` map to their `a`-prefixed equivalents. `ln` is an alias for `log`.
+
+### Custom Functions
+
+```python
+expr = Expression()
+
+# Define functions in the expression language
+expr.evaluate("f(x, y) = x + y")
+expr.evaluate("f(10, 20)")       # 30
+
+expr.evaluate("square(x) = x * x")
+expr.evaluate("square(5)")       # 25
+
+# Register Python functions
+expr.functions["even"] = lambda x: x % 2 == 0
+expr.evaluate("even(4)")         # True
+
+# Access defined functions from Python
+expr.evaluate("add(a, b) = a + b")
+expr.functions["add"](3, 4)      # 7
+```
+
+### Implicit Multiplication
+
+```python
+expr = Expression()
+
+expr.evaluate("f(x) = 2x")
+expr.evaluate("f(5)")            # 10
+expr.evaluate("x = 3")
+expr.evaluate("2x")              # 6
+expr.evaluate("2(3 + 4)")        # 14
+```
+
+### Boolean and Comparison Operators
+
+```python
+expr = Expression()
+
+# Comparisons
+expr.evaluate("10 == 10")        # True
+expr.evaluate("10 != 20")        # True
+expr.evaluate("10 > 5")          # True
+expr.evaluate("10 <= 10")        # True
+
+# Strict equality (type-aware)
+expr.evaluate("2 === 2")         # True
+expr.evaluate("'2' !== 2")       # True
+
+# Boolean operators
+expr.evaluate("10 > 5 && 20 > 10")  # True
+expr.evaluate("10 > 50 || 20 > 10") # True
+expr.evaluate("!0")                  # True
+
+# Keywords
+expr.evaluate("true == true")    # True
+expr.evaluate("null == null")    # True
+```
+
+### Strings
+
+```python
+expr = Expression()
+
+# String literals (single or double quotes)
+expr.evaluate('"hello" + " " + "world"')  # "hello world"
+expr.evaluate("'foo' == 'foo'")            # True
+
+# Ruby-style string operators
+expr.evaluate('"ab" * 3')                  # "ababab"  (repeat)
+expr.evaluate('"a" << "b"')                # "ab"      (append; mutates a variable)
+expr.evaluate('"a" <=> "b"')               # -1        (lexicographic compare)
+```
+
+### Regular Expressions
+
+```python
+expr = Expression()
+
+# Match operator
+expr.evaluate('"foobar" =~ /([fo]+)/i')  # True
+expr.evaluate("$1")                       # "Foo" (capture group)
+
+expr.evaluate('"hello" =~ /([0-9]+)/')   # False
+```
+
+### JSON Literals
+
+```python
+expr = Expression()
+
+# Objects and arrays
+expr.evaluate('{"name": "Alice"}')              # {"name": "Alice"}
+expr.evaluate('[10, 20, 30]')                    # [10, 20, 30]
+
+# Property access
+expr.evaluate('{"foo": "bar"}["foo"]')           # "bar"
+expr.evaluate('[10, 20][0]')                     # 10
+
+# Comparison
+expr.evaluate('{"a": 1} == {"a": 1}')           # True
+expr.evaluate('[1, 2] != [3, 4]')                # True
+```
+
+### Array Operators
+
+Ruby-inspired operators for concise list manipulation. When one operand is an
+array and the other is a scalar, the scalar is coerced to a single-element array.
+
+```python
+expr = Expression()
+
+# Intersection (&) — common elements, deduped, left order preserved
+expr.evaluate("[1, 1, 2, 3] & [3, 4]")     # [3]
+
+# Union (|) — combined elements, deduped
+expr.evaluate("[1, 2] | [2, 3]")           # [1, 2, 3]
+
+# Difference (-) — left elements not in right
+expr.evaluate("[1, 2, 2, 3] - [2]")        # [1, 3]
+
+# Concatenation (+) — keeps duplicates
+expr.evaluate("[1, 2] + [2, 3]")           # [1, 2, 2, 3]
+
+# Append (<<) — mutates the left operand when it is a variable
+expr.evaluate("[1, 2] << 3")               # [1, 2, 3]
+
+# Multiplication (*) — repeat with an integer
+expr.evaluate("[1, 2] * 3")                # [1, 2, 1, 2, 1, 2]
+# Join (*) — with a string separator
+expr.evaluate('["a", "b"] * "-"')          # "a-b"
+
+# Deep equality (==) and spaceship (<=>)
+expr.evaluate("[1, 2] == [1, 2]")          # True
+expr.evaluate("[1, 2] <=> [1, 3]")         # -1
+
+# Membership (in) — array element, or substring of a string
+expr.evaluate("2 in [1, 2, 3]")            # True
+expr.evaluate('"py" in "python"')          # True
+
+# Scalar coercion
+expr.evaluate("[1, 2, 3] & 2")             # [2]
+expr.evaluate("1 + [2, 3]")                # [1, 2, 3]
+```
+
+When neither operand is an array, these operators fall back to scalar
+semantics: `&` and `|` are bitwise AND/OR, `<<`/`>>` are bitshifts, `<=>`
+compares numbers or strings, and `+`/`-`/`*` are arithmetic.
+
+```python
+expr.evaluate("6 & 3")                      # 2  (bitwise AND)
+expr.evaluate("6 | 1")                      # 7  (bitwise OR)
+expr.evaluate("5 <=> 3")                    # 1
+```
+
+Empty arrays are falsy (unlike JavaScript), so they work directly in boolean
+contexts:
+
+```python
+expr.evaluate("!![]")                       # False
+expr.evaluate('[] || "default"')            # "default"
+expr.evaluate("[] ? 'yes' : 'no'")          # "no"
+
+# Validator pattern: true only when at least one skill matches
+expr.variables = {"skills": ["Python", "AI"]}
+bool(expr.evaluate('skills & ["AI", "ML"]'))   # True
+```
+
+### Conditional (Ternary) Operator
+
+```python
+expr = Expression()
+
+expr.evaluate("1 > 0 ? 'yes' : 'no'")       # "yes"
+expr.evaluate("[] ? 'yes' : 'no'")          # "no"
+```
+
+### Error Handling
+
+```python
+expr = Expression()
+
+# Errors raise exceptions by default
+try:
+    expr.evaluate("10 / 0")
+except ZeroDivisionError:
+    print("Division by zero!")
+
+# Suppress errors (returns None on error)
+expr.suppress_errors = True
+expr.evaluate("unknown_var")     # None
+print(expr.last_error)           # error message
+```
+
+### Semicolons
+
+Trailing semicolons are optional and ignored:
+
+```python
+expr.evaluate("10 + 10;")        # 20
+```
+
+## Operator Precedence (lowest to highest)
+
+| Precedence | Operators |
+|-----------|-----------|
+| 0 | `? :` (ternary) |
+| 1 | `\|\|` |
+| 2 | `&&` |
+| 3 | `==`, `!=`, `===`, `!==`, `=~`, `<=>`, `>`, `<`, `>=`, `<=`, `in` |
+| 4 | `<<`, `>>` |
+| 5 | `+`, `-`, `\|` |
+| 6 | `*`, `/`, `%`, `&`, `[]`, implicit multiplication |
+| 7 | `!`, unary `-`, unary `+` |
+| 8 | `**`, `^` |
+
+Operators `&` (intersection), `\|` (union), `-` (difference), `+`
+(concatenation), `<<` (append), `*` (repeat/join), `==` (deep equality), `<=>`
+(spaceship), and `in` (membership) are type-dispatched: they apply array
+semantics when either operand is an array, otherwise scalar semantics.
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Regenerate parser from grammar
+python -m pegen expression/grammar.peg -o expression/parser.py
+```
+
+## License
+
+Copyright (c) 2026 [Jakub T. Jankiewicz](https://jakub.jankiewicz.org/)
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU
+General Public License as published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+See [LICENSE](https://github.com/jcubic/expression.py/blob/master/LICENSE) for the full text.

expression_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+expression/__init__.py,sha256=WsgYZ6L0lcV_4xlZFPeFcJR4QkvzfiQCY9_GPT_IBEQ,12147
+expression/grammar.peg,sha256=aQ6Xttkp5ZYvOdoPLDIo5HsQ5DjUiLpvaXiQGwasQQM,6254
+expression/helpers.py,sha256=KJgoiJganC3u_0l-F4YgFJ3yuFAd9OzwjLbvlg6ObhY,4681
+expression/parser.py,sha256=rXeAC8498WMBEaXE7su8V8o4rIN7BF1RmpktwPLpVJg,26024
+expression/tokenizer.py,sha256=pb3HAzk7Qvd4ue7hA4QQu5SeCON3Ma7tVJpZeNK5XzU,5893
+expression_py-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+expression_py-0.1.0.dist-info/METADATA,sha256=DOQXXwRCJgAKtUlo3bwf9LJavBN3OAU05xgj7xhEtgI,10527
+expression_py-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+expression_py-0.1.0.dist-info/top_level.txt,sha256=C_mXdwowx0RYeeMT6UIE9x297SZHlvVgtCIjaf24L8k,11
+expression_py-0.1.0.dist-info/RECORD,,

expression_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+