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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.42
+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
@@ -852,16 +852,24 @@ istr.getitem('1234',5, None) ==> None
 Note that this method has the advantage that it can accept an istr as index, in contrast to normal indexing.
 
 #### long square root
-The method `long_sqrt` gives a list of  the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
-  E.g. `istr.long_sqrt(123 ** 2)` results in
+The method `long_sqrt` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
+ E.g. `istr.long_sqrt(123 ** 2).lines` results in
 
 `[istr('123'), istr('15129'), istr('1'), istr('51'), istr('44'), istr('729'), istr('729'), istr('0')]`
 
 Note the final `istr('0')` is included to support also long square roots that are not perfect.
 
-The method `long_sqrt`has an optional parameter `as_str`, that can be used to get a nice string representation of the long square root lines.
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E.g. `istr.long_sqrt(123 ** 2).line_lengths` results in
+
+`[3, 5, 1, 2, 2, 3, 3, 1]`
 
-E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
+`output` can be used to get a nice string representation of the long square root lines.
+
+E.g. `print(istr.long_sqrt(123 ** 2).output)` will print
 ```
   1 2 3
   -----
@@ -879,18 +887,26 @@ E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
 
 #### long multiplication
 
-The method `long_multiplication` gives a list of all lines to do a long multiplition.
+The method `long_multiplication` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long multiplication.
+
+E.g. `print(istr.long_multiplication(1234,567).lines` will print 
 
-E.g. `print(istr.long_multiplication(1234,567)` will print 
- 
   `[istr('1234'), istr('567'), istr('8638'), istr('7404'), istr('6170'), istr('699678')]`
-  
-The method has an optional parameter `as_str`, that can be used t0 get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
+
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E. g. `print(istr.long_multiplication(1234,567).line_lengths` results in
+
+`[4, 3, 4, 4, 4, 6]`
+
+`output` can be used to get a nice string representation of the long multiplication lines.
+
+E.g. `print(istr.long_multiplication(1234, 567).output)` will print
 
 ```
-  1234
+ 1234
    567
 ------ x
   8638
@@ -902,15 +918,23 @@ E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
 
 #### long division
 
-The method `long_division` gives a list of all lines to do a long division (note that the divisor and dividend count as separate lines).
+The method `long_division` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
 
-E.g. `print(istr.long_division(1395, 45)` will print 
+`lines` is a list of the lines of a long division.
 
-[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]
-  
-The method has an optional parameter `as_str`, that can be used to get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_division(1395, 45, as_str=True)` will print 
+E.g. `print(istr.long_division(1395, 45).lines` will print 
+
+`[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]`
+
+Note the final `istr('0')` is included to support also long divisions roots that are not perfect.
+
+E.g. `print(istr.long_division(1395, 45).line_lengths` will print 
+
+`[2, 2, 4, 3, 2, 2, 1]`
+
+`output` can be used to get a nice string representation of the long divsion lines.
+
+E.g. `print(istr.long_division(1395, 45).output` will print 
 
 ```
        31
@@ -922,8 +946,8 @@ E.g. `print(istr.long_division(1395, 45, as_str=True)` will print
        45
        --
         0
-```  
-  
+```
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.
@@ -1017,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.42 → istr_python-1.1.44}/README.md

@@ -839,16 +839,24 @@ istr.getitem('1234',5, None) ==> None
 Note that this method has the advantage that it can accept an istr as index, in contrast to normal indexing.
 
 #### long square root
-The method `long_sqrt` gives a list of  the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
-  E.g. `istr.long_sqrt(123 ** 2)` results in
+The method `long_sqrt` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
+ E.g. `istr.long_sqrt(123 ** 2).lines` results in
 
 `[istr('123'), istr('15129'), istr('1'), istr('51'), istr('44'), istr('729'), istr('729'), istr('0')]`
 
 Note the final `istr('0')` is included to support also long square roots that are not perfect.
 
-The method `long_sqrt`has an optional parameter `as_str`, that can be used to get a nice string representation of the long square root lines.
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E.g. `istr.long_sqrt(123 ** 2).line_lengths` results in
+
+`[3, 5, 1, 2, 2, 3, 3, 1]`
 
-E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
+`output` can be used to get a nice string representation of the long square root lines.
+
+E.g. `print(istr.long_sqrt(123 ** 2).output)` will print
 ```
   1 2 3
   -----
@@ -866,18 +874,26 @@ E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
 
 #### long multiplication
 
-The method `long_multiplication` gives a list of all lines to do a long multiplition.
+The method `long_multiplication` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long multiplication.
+
+E.g. `print(istr.long_multiplication(1234,567).lines` will print 
 
-E.g. `print(istr.long_multiplication(1234,567)` will print 
- 
   `[istr('1234'), istr('567'), istr('8638'), istr('7404'), istr('6170'), istr('699678')]`
-  
-The method has an optional parameter `as_str`, that can be used t0 get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
+
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E. g. `print(istr.long_multiplication(1234,567).line_lengths` results in
+
+`[4, 3, 4, 4, 4, 6]`
+
+`output` can be used to get a nice string representation of the long multiplication lines.
+
+E.g. `print(istr.long_multiplication(1234, 567).output)` will print
 
 ```
-  1234
+ 1234
    567
 ------ x
   8638
@@ -889,15 +905,23 @@ E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
 
 #### long division
 
-The method `long_division` gives a list of all lines to do a long division (note that the divisor and dividend count as separate lines).
+The method `long_division` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
 
-E.g. `print(istr.long_division(1395, 45)` will print 
+`lines` is a list of the lines of a long division.
 
-[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]
-  
-The method has an optional parameter `as_str`, that can be used to get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_division(1395, 45, as_str=True)` will print 
+E.g. `print(istr.long_division(1395, 45).lines` will print 
+
+`[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]`
+
+Note the final `istr('0')` is included to support also long divisions roots that are not perfect.
+
+E.g. `print(istr.long_division(1395, 45).line_lengths` will print 
+
+`[2, 2, 4, 3, 2, 2, 1]`
+
+`output` can be used to get a nice string representation of the long divsion lines.
+
+E.g. `print(istr.long_division(1395, 45).output` will print 
 
 ```
        31
@@ -909,8 +933,8 @@ E.g. `print(istr.long_division(1395, 45, as_str=True)` will print
        45
        --
         0
-```  
-  
+```
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.
@@ -1004,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.42 → istr_python-1.1.44}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.42"
+__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):
@@ -727,14 +745,14 @@ class istr(str):
         return self[::-1]
 
     def ceil(self, divisible_by=1):
-        if divisible_by != int(divisible_by) or divisible_by<1:
+        if divisible_by != int(divisible_by) or divisible_by < 1:
             raise ValueError(f"divisible_by has to be an integer value >=1 , not {divisible_by}")
         n = istr.interpret_as_float(self)
         return istr((math.ceil(n / divisible_by)) * divisible_by)
 
     def floor(self, divisible_by=1):
-        if divisible_by != int(divisible_by) or divisible_by<1:
-            raise ValueError(f"divisible_by has to be an integer value >=1 , not {divisible_by}")             
+        if divisible_by != int(divisible_by) or divisible_by < 1:
+            raise ValueError(f"divisible_by has to be an integer value >=1 , not {divisible_by}")
         n = istr.interpret_as_float(self)
         return istr((math.floor(n / divisible_by)) * divisible_by)
 
@@ -764,13 +782,13 @@ class istr(str):
 
         return str(self)
 
-    def interpret_as_istr(self): 
+    def interpret_as_istr(self):
         # ignore leading zeroes
         if isinstance(self, collections.abc.Iterable) and not isinstance(self, str):
-            return istr.join(self)*1
+            return istr.join(self) * 1
+
+        return istr(self) * 1
 
-        return istr(self)*1
-        
     def _str_method(self, name, *args, **kwargs):
         return self.__class__(getattr(super(), name)(*args, **kwargs))
 
@@ -860,22 +878,15 @@ class istr(str):
         for i, value in enumerate(iterable, int(start)):
             yield cls(i), value
 
-    def long_sqrt(self, as_str=False):
-        """
-        this function does long squre root and returns all the lines to be written.
-        (modified from a ChatGPT code suggestion)
-        returns root, number and the lines below the number, all istr-ed
-        if as_str is True, a formatted output will be returned
-        """
-
-        number = istr.interpret_as_istr(self)
-
+    @staticmethod
+    @functools.lru_cache(maxsize=1)
+    def _long_sqrt(number):
         lines = []
-        if len(number)%2==1:            
-            pairs=istr.chain(number[0],istr.batched(number[1:],2,join=True))
-        else:       
-            pairs=istr.batched(number,2,join=True)
-            
+        if len(number) % 2 == 1:
+            pairs = istr.chain(number[0], istr.batched(number[1:], 2, join=True))
+        else:
+            pairs = istr.batched(number, 2, join=True)
+
         root = istr(0)
         remainder = 0
 
@@ -899,118 +910,180 @@ class istr(str):
 
         lines.append(remainder)
         lines = [root] + [number] + lines[1:]
-        if as_str:
-            result = []
-            extra = len(number)%2==0
-            result.append(f"  {extra*' '}{' '.join(lines[0])}")
-            result.append(f"  {len(lines[1])*'-'}")
-            result.append(f"\/{lines[1]}")
-
-            last_len=len(lines[2])
-            for i, line in enumerate(lines):
-
-                if i >= 2:
-                    if i == len(lines) - 1:
-                        n = i - 2 + extra
-                    else:
-                        n = i + extra
+        return lines
 
-                    if i % 2 == 0:
-                        result.append(f" {line:>{n}}")
-                        result.append(f" {last_len*'-':>{n}}")
-                    else:
-                        result.append(f" {line:>{n+1}}")
-                        last_len=len(line)
-            return "\n".join(result)
-        else:
-            return lines
-            
-    def long_multiplication(self, number,as_str=False):
-        number0 = istr.interpret_as_istr(self)   
-        number1=istr.interpret_as_istr(number)
-        lines=[number0,number1]
+    def long_sqrt(self):
+        """
+        this function does long squre root and returns all the lines to be written.
+        (modified from a ChatGPT code suggestion)
+        returns root, number and the lines below the number, all istr-ed
+        if as_str is True, a formatted output will be returned
+        """
+
+        class NumberHolder:
+            def __init__(self, number):
+                self.number = number
+
+            def __getattr__(self, attr):
+                match attr:
+                    case "lines":
+                        return istr._long_sqrt(self.number)
+                    case "line_lengths":
+                        return [*map(len, istr._long_sqrt(self.number))]
+                    case "output":
+                        lines = istr._long_sqrt(self.number)
+                        result = []
+                        extra = len(number) % 2 == 0
+                        result.append(f"  {extra*' '}{' '.join(lines[0])}")
+                        result.append(f"  {len(lines[1])*'-'}")
+                        result.append(f"\/{lines[1]}")
+
+                        last_len = len(lines[2])
+                        for i, line in enumerate(lines):
+                            if i >= 2:
+                                if i == len(lines) - 1:
+                                    n = i - 2 + extra
+                                else:
+                                    n = i + extra
+
+                                if i % 2 == 0:
+                                    result.append(f" {line:>{n}}")
+                                    result.append(f" {last_len*'-':>{n}}")
+                                else:
+                                    result.append(f" {line:>{n+1}}")
+                                    last_len = len(line)
+                        return "\n".join(result)
+                    case _:
+                        raise AttributeError()
+
+        number = istr.interpret_as_istr(self)
+
+        return NumberHolder(number)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=1)
+    def _long_multiplication(number0, number1):
+        lines = [number0, number1]
         for i in number1.reversed():
-            lines.append(number0*i)
-        lines.append(number0*number1)
-        if as_str:
-            result=[]
-            n=len(lines[-1])
-            result.append(f'{lines[0]:>{n}}')
-            result.append(f'{lines[1]:>{n}}')      
-            result.append(f"{n*'-'} x")    
-            for i,line in enumerate(lines[2:-1]):
-                result.append(f"{line:>{n-i}}")
-            result.append(f"{n*'-'}")             
-            result.append(lines[-1])
-            return '\n'.join(result)
-        else:
-            return lines
-        
-    def long_division(self, divisor, as_str=False):
-        dividend = istr.interpret_as_istr(self)
-        divisor = istr.interpret_as_istr(divisor)
-    
+            lines.append(number0 * i)
+        lines.append(number0 * number1)
+
+        return lines
+
+    def long_multiplication(self, number, as_str=False):
+        class NumbersHolder:
+            def __init__(self, number0, number1):
+                self.number0 = number0
+                self.number1 = number1
+
+            def __getattr__(self, attr):
+                match attr:
+                    case "lines":
+                        return istr._long_multiplication(self.number0, self.number1)
+                    case "line_lengths":
+                        return [*map(len, istr._long_multiplication(self.number0, self.number1))]
+                    case "output":
+                        lines = istr._long_multiplication(self.number0, self.number1)
+                        result = []
+
+                        n = len(lines[-1])
+                        result.append(f"{lines[0]:>{n}}")
+                        result.append(f"{lines[1]:>{n}}")
+                        result.append(f"{n*'-'} x")
+                        for i, line in enumerate(lines[2:-1]):
+                            result.append(f"{line:>{n-i}}")
+                        result.append(f"{n*'-'}")
+                        result.append(lines[-1])
+                        return "\n".join(result)
+                    case _:
+                        raise AttributeError()
+
+        number0 = istr.interpret_as_istr(self)
+        number1 = istr.interpret_as_istr(number)
+        return NumbersHolder(number0, number1)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=1)
+    def _long_division(dividend, divisor, as_str=False):
         if dividend < 0:
             raise ValueError("dividend must be non-negative.")
-    
+
         if divisor <= 0:
             raise ValueError("divisor must be positive.")
-    
+
         dividend_start = len(divisor) + 3
         total_width = dividend_start + len(dividend)
-    
+
         quotient_characters = [" "] * len(dividend)
-    
+
         remainder = 0
         division_started = False
-        lines=[]
-    
+        lines = []
+
         for digit_index, digit_character in enumerate(dividend):
             current = remainder * 10 + digit_character
             quotient_digit = current // divisor
-    
+
             if quotient_digit != 0 or division_started:
                 division_started = True
-    
+
             if digit_index == len(dividend) - 1:
                 division_started = True
-    
+
             if not division_started:
                 remainder = current
                 continue
-    
+
             quotient_characters[digit_index] = quotient_digit
-    
+
             product = quotient_digit * divisor
             remainder = current - product
-    
+
             if as_str:
                 end_column = dividend_start + digit_index
                 current_start = end_column - len(current) + 1
-                product_start = end_column - len(product) + 1   
+                product_start = end_column - len(product) + 1
                 bar_start = min(current_start, product_start)
                 bar_length = end_column - bar_start + 1
                 lines.append(" " * current_start | current)
                 lines.append(" " * product_start | product)
                 lines.append(" " * bar_start + "-" * bar_length)
-        
+
             else:
                 lines.append(current)
                 lines.append(product)
-    
+
         quotient = istr.join(quotient_characters).rstrip()
         if as_str:
             remainder_start = total_width - len(remainder)
             lines.append(" " * remainder_start | remainder)
-            lines=[" " * dividend_start | quotient," " * dividend_start + "-" * len(dividend),f"{divisor} ) {dividend}",*lines[1:]]
+            lines = [" " * dividend_start | quotient, " " * dividend_start + "-" * len(dividend), f"{divisor} ) {dividend}", *lines[1:]]
             return "\n".join(lines)
-    
+
         else:
             lines.append(remainder)
-            lines=[istr(quotient),divisor,dividend,*lines[1:]]
-            return lines        
-            
-    
+            lines = [istr(quotient), divisor, dividend, *lines[1:]]
+            return lines
+
+    def long_division(self, divisor):
+        class NumbersHolder:
+            def __init__(self, dividend, divisor):
+                self.dividend = dividend
+                self.divisor = divisor
+
+            def __getattr__(self, attr):
+                match attr:
+                    case "lines":
+                        return istr._long_division(self.dividend, self.divisor)
+                    case "line_lengths":
+                        return [*map(len, istr._long_division(self.dividend, self.divisor))]
+                    case "output":
+                        return istr._long_division(self.dividend, self.divisor, as_str=True)
+
+        dividend = istr.interpret_as_istr(self)
+        divisor = istr.interpret_as_istr(divisor)
+        return NumbersHolder(dividend, divisor)
+
     def this_base(self):
         return self._this_base
 
@@ -1275,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.42 → 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.42
+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
@@ -852,16 +852,24 @@ istr.getitem('1234',5, None) ==> None
 Note that this method has the advantage that it can accept an istr as index, in contrast to normal indexing.
 
 #### long square root
-The method `long_sqrt` gives a list of  the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
-  E.g. `istr.long_sqrt(123 ** 2)` results in
+The method `long_sqrt` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
+ E.g. `istr.long_sqrt(123 ** 2).lines` results in
 
 `[istr('123'), istr('15129'), istr('1'), istr('51'), istr('44'), istr('729'), istr('729'), istr('0')]`
 
 Note the final `istr('0')` is included to support also long square roots that are not perfect.
 
-The method `long_sqrt`has an optional parameter `as_str`, that can be used to get a nice string representation of the long square root lines.
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E.g. `istr.long_sqrt(123 ** 2).line_lengths` results in
+
+`[3, 5, 1, 2, 2, 3, 3, 1]`
 
-E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
+`output` can be used to get a nice string representation of the long square root lines.
+
+E.g. `print(istr.long_sqrt(123 ** 2).output)` will print
 ```
   1 2 3
   -----
@@ -879,18 +887,26 @@ E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
 
 #### long multiplication
 
-The method `long_multiplication` gives a list of all lines to do a long multiplition.
+The method `long_multiplication` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long multiplication.
+
+E.g. `print(istr.long_multiplication(1234,567).lines` will print 
 
-E.g. `print(istr.long_multiplication(1234,567)` will print 
- 
   `[istr('1234'), istr('567'), istr('8638'), istr('7404'), istr('6170'), istr('699678')]`
-  
-The method has an optional parameter `as_str`, that can be used t0 get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
+
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E. g. `print(istr.long_multiplication(1234,567).line_lengths` results in
+
+`[4, 3, 4, 4, 4, 6]`
+
+`output` can be used to get a nice string representation of the long multiplication lines.
+
+E.g. `print(istr.long_multiplication(1234, 567).output)` will print
 
 ```
-  1234
+ 1234
    567
 ------ x
   8638
@@ -902,15 +918,23 @@ E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
 
 #### long division
 
-The method `long_division` gives a list of all lines to do a long division (note that the divisor and dividend count as separate lines).
+The method `long_division` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
 
-E.g. `print(istr.long_division(1395, 45)` will print 
+`lines` is a list of the lines of a long division.
 
-[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]
-  
-The method has an optional parameter `as_str`, that can be used to get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_division(1395, 45, as_str=True)` will print 
+E.g. `print(istr.long_division(1395, 45).lines` will print 
+
+`[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]`
+
+Note the final `istr('0')` is included to support also long divisions roots that are not perfect.
+
+E.g. `print(istr.long_division(1395, 45).line_lengths` will print 
+
+`[2, 2, 4, 3, 2, 2, 1]`
+
+`output` can be used to get a nice string representation of the long divsion lines.
+
+E.g. `print(istr.long_division(1395, 45).output` will print 
 
 ```
        31
@@ -922,8 +946,8 @@ E.g. `print(istr.long_division(1395, 45, as_str=True)` will print
        45
        --
         0
-```  
-  
+```
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.
@@ -1017,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.42 → 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.42"
+version = "1.1.44"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = []

{istr_python-1.1.42 → istr_python-1.1.44}/tests/test_istr.py

@@ -1227,7 +1227,7 @@ def test_compose():
 
 
 def test_long_sqrt():
-    assert istr.long_sqrt(1234**2) == [
+    assert istr.long_sqrt(1234**2).lines == [
         istr("1234"),
         istr("1522756"),
         istr("1"),
@@ -1239,7 +1239,7 @@ def test_long_sqrt():
         istr("9856"),
         istr("0"),
     ]
-    assert istr.long_sqrt(1234**2 + 1) == [
+    assert istr.long_sqrt(1234**2 + 1).lines == [
         istr("1234"),
         istr("1522757"),
         istr("1"),
@@ -1251,8 +1251,8 @@ def test_long_sqrt():
         istr("9856"),
         istr("1"),
     ]
-    lines = istr.long_sqrt(1234**2 + 1)
-    assert istr(1234**2).long_sqrt() == [
+
+    assert istr(1234**2).long_sqrt().lines == [
         istr("1234"),
         istr("1522756"),
         istr("1"),
@@ -1264,11 +1264,12 @@ def test_long_sqrt():
         istr("9856"),
         istr("0"),
     ]
-    assert istr.long_sqrt(34**2) == [istr("34"), istr("1156"), istr("9"), istr("256"), istr("256"), istr("0")]
-    assert istr.long_sqrt("001156") == [istr("34"), istr("1156"), istr("9"), istr("256"), istr("256"), istr("0")]
-
+    assert istr.long_sqrt(34**2).lines == [istr("34"), istr("1156"), istr("9"), istr("256"), istr("256"), istr("0")]
+    assert istr.long_sqrt("001156").lines == [istr("34"), istr("1156"), istr("9"), istr("256"), istr("256"), istr("0")]
+    assert istr.long_sqrt(34**2).line_lengths == [2, 4, 1, 3, 3, 1]
+    assert istr.long_sqrt("001156").line_lengths == [2, 4, 1, 3, 3, 1]
     assert (
-        istr.long_sqrt(34**2, as_str=True)
+        istr.long_sqrt(34**2).output
         == """\
    3 4
   ----
@@ -1283,12 +1284,12 @@ def test_long_sqrt():
 
 
 def test_long_multiplication():
-    assert istr.long_multiplication(1234, 567) == [istr("1234"), istr("567"), istr("8638"), istr("7404"), istr("6170"), istr("699678")]
-    assert istr(1234).long_multiplication(567) == [istr("1234"), istr("567"), istr("8638"), istr("7404"), istr("6170"), istr("699678")]
-    assert istr("01234").long_multiplication("0567") == [istr("1234"), istr("567"), istr("8638"), istr("7404"), istr("6170"), istr("699678")]
+    assert istr.long_multiplication(1234, 567).lines == [istr("1234"), istr("567"), istr("8638"), istr("7404"), istr("6170"), istr("699678")]
+    assert istr(1234).long_multiplication(567).lines == [istr("1234"), istr("567"), istr("8638"), istr("7404"), istr("6170"), istr("699678")]
+    assert istr("01234").long_multiplication("0567").lines == [istr("1234"), istr("567"), istr("8638"), istr("7404"), istr("6170"), istr("699678")]
 
     assert (
-        istr.long_multiplication(1234, 567, as_str=True)
+        istr.long_multiplication(1234, 567).output
         == """\
   1234
    567
@@ -1302,12 +1303,12 @@ def test_long_multiplication():
 
 
 def test_long_division():
-    assert istr.long_division(1395, 45) == [istr("31"), istr("45"), istr("1395"), istr("135"), istr("45"), istr("45"), istr("0")]
-    assert istr(1395).long_division(45) == [istr("31"), istr("45"), istr("1395"), istr("135"), istr("45"), istr("45"), istr("0")]
-    assert istr.long_division(istr("01395"), istr("045")) == [istr("31"), istr("45"), istr("1395"), istr("135"), istr("45"), istr("45"), istr("0")]
-
+    assert istr.long_division(1395, 45).lines == [istr("31"), istr("45"), istr("1395"), istr("135"), istr("45"), istr("45"), istr("0")]    
+    assert istr(1395).long_division(45).lines == [istr("31"), istr("45"), istr("1395"), istr("135"), istr("45"), istr("45"), istr("0")]
+    assert istr.long_division(istr("01395"), istr("045")).lines == [istr("31"), istr("45"), istr("1395"), istr("135"), istr("45"), istr("45"), istr("0")]
+    assert istr.long_division(1395, 45).line_lengths == [2, 2, 4, 3, 2, 2, 1] 
     assert (
-        istr.long_division(1395, 45, as_str=True)
+        istr.long_division(1395, 45).output
         == """\
        31
      ----