istr-python 1.1.43__tar.gz → 1.1.44__tar.gz

{istr_python-1.1.43 → istr_python-1.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.43
+Version: 1.1.44
 Summary: istr - strings you can count on
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/istr
@@ -1041,6 +1041,41 @@ Note that `str(istr(":="))` is ":=" and does not assign any value.
 
 Usually, composing and decomposing uses the globals namespace, but this can be overridden with the namespace parameter. See the test suite for details.
 
+#### Evaluating expressions with one letter variables
+The `istr.eval` method is essentially the same as `istr.compose`, but (safely) evaluates the result.
+E.g.
+
+```
+a = 5
+b = 2
+print(istr.eval('aab + ba')
+```
+will print `577`
+
+The operators +, -, * and / are supported.
+Comparisons (==, <=, <, >, >= are also supported. In that case, the result is also istr-ed, so istr('0') for False and istr('1') for True. E.g.
+
+```
+a = 5
+b = 2
+print(istr.eval('a > b')
+```
+will print 1 (meaning True)
+
+Note that leading zeroes are accepted. So, `istr.eval('03 + 7')` is `10`.
+Instead of ==, = can be used. So, `istr.eval('12 = 5 + 7')` is `1` (meaning True)
+
+##### Alternative method
+
+If istr is called with a string starting with a `?`, the string without the leading `?` will be evaluated using the new `istr.eval` method. So, the above examples read:
+```
+a = 5
+b = 2
+print(istr("?aab + ba':")
+print(istr("?a > b")
+```
+with output `577` and `1` (meaning True)
+
 #### Subclassing istr
 
 When a class is derived from istr, all methods will return that newly derived class. 

{istr_python-1.1.43 → istr_python-1.1.44}/README.md

@@ -1028,6 +1028,41 @@ Note that `str(istr(":="))` is ":=" and does not assign any value.
 
 Usually, composing and decomposing uses the globals namespace, but this can be overridden with the namespace parameter. See the test suite for details.
 
+#### Evaluating expressions with one letter variables
+The `istr.eval` method is essentially the same as `istr.compose`, but (safely) evaluates the result.
+E.g.
+
+```
+a = 5
+b = 2
+print(istr.eval('aab + ba')
+```
+will print `577`
+
+The operators +, -, * and / are supported.
+Comparisons (==, <=, <, >, >= are also supported. In that case, the result is also istr-ed, so istr('0') for False and istr('1') for True. E.g.
+
+```
+a = 5
+b = 2
+print(istr.eval('a > b')
+```
+will print 1 (meaning True)
+
+Note that leading zeroes are accepted. So, `istr.eval('03 + 7')` is `10`.
+Instead of ==, = can be used. So, `istr.eval('12 = 5 + 7')` is `1` (meaning True)
+
+##### Alternative method
+
+If istr is called with a string starting with a `?`, the string without the leading `?` will be evaluated using the new `istr.eval` method. So, the above examples read:
+```
+a = 5
+b = 2
+print(istr("?aab + ba':")
+print(istr("?a > b")
+```
+with output `577` and `1` (meaning True)
+
 #### Subclassing istr
 
 When a class is derived from istr, all methods will return that newly derived class. 

{istr_python-1.1.43 → istr_python-1.1.44}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.43"
+__version__ = "1.1.44"
 import functools
 import itertools
 import types
@@ -17,6 +17,8 @@ import copy
 import bisect
 import collections
 import numbers
+import re
+import ast
 
 """
 Note: the changelog is in changelog.md
@@ -282,15 +284,18 @@ class istr(str):
                     return map(lambda v: cls(v, base=base, int_format=int_format, repr_mode=repr_mode, namespace=get_namespace(namespace)), value)
                 return type(value)(map(lambda v: cls(v, base=base, int_format=int_format, repr_mode=repr_mode, namespace=get_namespace(namespace)), value))
 
-        if isinstance(value, str) and (any(value.startswith(s) and value != s for s in ("=", ":="))):
-            if value[0] == "=":
-                value = str(cls.compose(value[1:], namespace=get_namespace(namespace)))
-            else:  # it's :=
-                var_name = value[2:]
-                if not var_name.isidentifier():
-                    raise ValueError(f"{var_name!r} is not a valid identifier")
-                value = str(cls.compose(var_name, namespace=get_namespace(namespace)))
-                get_namespace(namespace)[var_name] = cls(value)
+        if isinstance(value, str) and (any(value.startswith(s) and value != s for s in ("=", ":=",'?'))):
+            match value[0]:
+                case '?':
+                    value = str(cls.eval(value[1:], namespace=get_namespace(namespace)))
+                case '=':
+                    value = str(cls.compose(value[1:], namespace=get_namespace(namespace)))
+                case ':':                    
+                    var_name = value[2:]
+                    if not var_name.isidentifier():
+                        raise ValueError(f"{var_name!r} is not a valid identifier")
+                    value = str(cls.compose(var_name, namespace=get_namespace(namespace)))
+                    get_namespace(namespace)[var_name] = cls(value)
         as_int = cls._to_int(value, base)
         if as_int is cls._nan or isinstance(value, str):
             as_str = value
@@ -674,7 +679,20 @@ class istr(str):
                 result.append(str(namespace[letter]))
             else:
                 result.append(letter)
-        return cls("".join(result))
+
+        result_str = "".join(result)
+        return cls(result_str)
+
+    @classmethod
+    def eval(cls, letters, namespace=None):
+        """
+        evaluates an istr from individual letter variables
+        """
+        expr = cls.compose(letters, namespace=namespace)
+        expr = re.sub(r"\b0+(\d+)\b", r"\1", expr)  # delete leading zeroes
+        expr=re.sub(r'(?<![<>=!])=(?!=)', '==', expr) # support =        
+        result = safe_eval(expr)
+        return cls(result)
 
     def __or__(self, other):
         if isinstance(other, str):
@@ -1330,6 +1348,54 @@ def real_caller_frame():
     return frame
 
 
+OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.Pow: operator.pow}
+
+COMPARE_OPS = {
+    ast.Eq: operator.eq,  # ==
+    ast.NotEq: operator.ne,  # !=
+    ast.Lt: operator.lt,  # <
+    ast.LtE: operator.le,  # <=
+    ast.Gt: operator.gt,  # >
+    ast.GtE: operator.ge,  # >=
+}
+
+
+def safe_eval(expr):
+    def evaluate(node):
+        if isinstance(node, ast.Constant) and isinstance(node.value, (int, float, str, bool)):
+            return node.value
+
+        if isinstance(node, ast.BinOp) and type(node.op) in OPS:
+            return OPS[type(node.op)](evaluate(node.left), evaluate(node.right))
+
+        if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+            value = evaluate(node.operand)
+            return value if isinstance(node.op, ast.UAdd) else -value
+
+        if isinstance(node, ast.Compare):
+            left = evaluate(node.left)
+
+            # Supports chained comparisons, e.g. 1 < 2 < 3
+            for op, comparator in zip(node.ops, node.comparators):
+                op_func = COMPARE_OPS.get(type(op))
+                if op_func is None:
+                    raise ValueError("Unsupported comparison")
+
+                right = evaluate(comparator)
+
+                if not op_func(left, right):
+                    return False
+
+                left = right
+
+            return True
+
+        raise ValueError("Unsupported expression")
+
+    tree = ast.parse(expr, mode="eval")
+    return evaluate(tree.body)
+
+
 istr.type = type(istr(0))
 
 

{istr_python-1.1.43 → istr_python-1.1.44}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.43
+Version: 1.1.44
 Summary: istr - strings you can count on
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/istr
@@ -1041,6 +1041,41 @@ Note that `str(istr(":="))` is ":=" and does not assign any value.
 
 Usually, composing and decomposing uses the globals namespace, but this can be overridden with the namespace parameter. See the test suite for details.
 
+#### Evaluating expressions with one letter variables
+The `istr.eval` method is essentially the same as `istr.compose`, but (safely) evaluates the result.
+E.g.
+
+```
+a = 5
+b = 2
+print(istr.eval('aab + ba')
+```
+will print `577`
+
+The operators +, -, * and / are supported.
+Comparisons (==, <=, <, >, >= are also supported. In that case, the result is also istr-ed, so istr('0') for False and istr('1') for True. E.g.
+
+```
+a = 5
+b = 2
+print(istr.eval('a > b')
+```
+will print 1 (meaning True)
+
+Note that leading zeroes are accepted. So, `istr.eval('03 + 7')` is `10`.
+Instead of ==, = can be used. So, `istr.eval('12 = 5 + 7')` is `1` (meaning True)
+
+##### Alternative method
+
+If istr is called with a string starting with a `?`, the string without the leading `?` will be evaluated using the new `istr.eval` method. So, the above examples read:
+```
+a = 5
+b = 2
+print(istr("?aab + ba':")
+print(istr("?a > b")
+```
+with output `577` and `1` (meaning True)
+
 #### Subclassing istr
 
 When a class is derived from istr, all methods will return that newly derived class. 

{istr_python-1.1.43 → istr_python-1.1.44}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
     { name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com" },
 ]
 description = "istr - strings you can count on"
-version = "1.1.43"
+version = "1.1.44"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = []