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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.43
+Version: 1.1.45
 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
@@ -370,14 +370,20 @@ a, b, c = istr(*range(3)) ==> a=istr('0') , b=istr('1'), c=istr('2')
   ```
 #### Alternative way of range specification
 
-Instead of `istr(range(..))` it is possible to use `istr,range(..)` instead, like
+Instead of `istr(range(..))` it is possible to use `istr.range(..)` instead, like
 
 `list(istr.range(3,6))` ==> `[istr('3'), istr('4'), istr('5')]`
 
-In contrast to the builtin `range`, `istr.range` supports a non keyword parameter `length`:
+In contrast to the builtin `range`, `istr.range` supports a keyword parameter `length`:
 
 `list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
 
+On top of this, `istr.range` support a keyword parameter `distinct`, to return a generator that yields only numbers with distinct numbers:
+
+`list(istr.range(98,104,distinct=True))` is `[istr('98'), istr('102'), istr('103')]`
+
+For `istr.range(length=..., distict=True)` the generation is optimized (not just checking each possible value).
+
 #### square root, cubic root and nth root
 The methods `sqrt`, `cbrt`, `nth_root`provide the square root, cubic root and nth root of an istr. If there is no integer root, the fallback value (default `istr('0')` will be returned.
 ```
@@ -547,15 +553,15 @@ istr.divisors(18, False) ==> [istr('1'), istr('18'), istr('2'), istr('9'), istr(
 
 #### test whether all characters are distinct
 
-With the `all_distinct` method, it is possible to test whether all characters are distinct (i.e. no character appears more than once).
+With the `is_distinct` method, it is possible to test whether all characters are distinct (i.e. no character appears more than once).
 
 ```
-istr('01234').all_distict() ==> True
-istr('012340').all_distict() ==> False
+istr('01234').is_distict() ==> True
+istr('012340').is_distict() ==> False
 n98 = istr(98)
 n100 = n98 + 2
-istr(n98).all_distinct() ==> True
-istr(n100).all_distinct() ==> False
+istr(n98).is_distinct() ==> True
+istr(n100).is_distinct() ==> False
 ```
 #### test if characters are consecutive
 
@@ -824,8 +830,17 @@ Alternatively, it is possible to get a list of all squares, cubes, power_ofs or
 
 `istr.squares (length=2)` returns a list of all squares of length 2, so between 10 and 99.
 
+If the keyword `distinct` is True, all values that are not distinct, will be excluded, like:
+
+`list(istr.primes(list(istr.primes(100,132,distinct=True))` is `[istr('103'), istr('107'), istr('109'), istr('127')]`, thus leaving out 101, 113 and 131
+
 Unless `cache=False` is specified, the query result is cached.
 
+#### filter distinct_only 
+
+With `istr.distinct_only` any iterable can skip values that are not distinct:
+`list(istr.distinct_only([10, 11, 100, 123, 'abc', 'aaa']))` is `[istr('10'), istr('123'), istr('abc')]`
+
 #### Safe indexing (getitem)
 
 The `istr.getitem` method is essentially, a safe version of indexing an istr.
@@ -1041,6 +1056,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.45}/README.md

@@ -357,14 +357,20 @@ a, b, c = istr(*range(3)) ==> a=istr('0') , b=istr('1'), c=istr('2')
   ```
 #### Alternative way of range specification
 
-Instead of `istr(range(..))` it is possible to use `istr,range(..)` instead, like
+Instead of `istr(range(..))` it is possible to use `istr.range(..)` instead, like
 
 `list(istr.range(3,6))` ==> `[istr('3'), istr('4'), istr('5')]`
 
-In contrast to the builtin `range`, `istr.range` supports a non keyword parameter `length`:
+In contrast to the builtin `range`, `istr.range` supports a keyword parameter `length`:
 
 `list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
 
+On top of this, `istr.range` support a keyword parameter `distinct`, to return a generator that yields only numbers with distinct numbers:
+
+`list(istr.range(98,104,distinct=True))` is `[istr('98'), istr('102'), istr('103')]`
+
+For `istr.range(length=..., distict=True)` the generation is optimized (not just checking each possible value).
+
 #### square root, cubic root and nth root
 The methods `sqrt`, `cbrt`, `nth_root`provide the square root, cubic root and nth root of an istr. If there is no integer root, the fallback value (default `istr('0')` will be returned.
 ```
@@ -534,15 +540,15 @@ istr.divisors(18, False) ==> [istr('1'), istr('18'), istr('2'), istr('9'), istr(
 
 #### test whether all characters are distinct
 
-With the `all_distinct` method, it is possible to test whether all characters are distinct (i.e. no character appears more than once).
+With the `is_distinct` method, it is possible to test whether all characters are distinct (i.e. no character appears more than once).
 
 ```
-istr('01234').all_distict() ==> True
-istr('012340').all_distict() ==> False
+istr('01234').is_distict() ==> True
+istr('012340').is_distict() ==> False
 n98 = istr(98)
 n100 = n98 + 2
-istr(n98).all_distinct() ==> True
-istr(n100).all_distinct() ==> False
+istr(n98).is_distinct() ==> True
+istr(n100).is_distinct() ==> False
 ```
 #### test if characters are consecutive
 
@@ -811,8 +817,17 @@ Alternatively, it is possible to get a list of all squares, cubes, power_ofs or
 
 `istr.squares (length=2)` returns a list of all squares of length 2, so between 10 and 99.
 
+If the keyword `distinct` is True, all values that are not distinct, will be excluded, like:
+
+`list(istr.primes(list(istr.primes(100,132,distinct=True))` is `[istr('103'), istr('107'), istr('109'), istr('127')]`, thus leaving out 101, 113 and 131
+
 Unless `cache=False` is specified, the query result is cached.
 
+#### filter distinct_only 
+
+With `istr.distinct_only` any iterable can skip values that are not distinct:
+`list(istr.distinct_only([10, 11, 100, 123, 'abc', 'aaa']))` is `[istr('10'), istr('123'), istr('abc')]`
+
 #### Safe indexing (getitem)
 
 The `istr.getitem` method is essentially, a safe version of indexing an istr.
@@ -1028,6 +1043,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.45}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.43"
+__version__ = "1.1.45"
 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
@@ -487,21 +492,25 @@ class istr(str):
         return True
 
     @classmethod
-    def primes(cls, start=None, stop=None, /, length=None, cache=True):
+    def primes(cls, start=None, stop=None, /, length=None, distinct=False, cache=True):
         """
         returns all primes up to a given upperbound or between a given lowerbound and upperbound
         alternatively, the length can be given
         """
         start, stop, step = process_start_stop_step_length(start, stop, 1, length)
-        if (cls, "primes", start, stop) in _cache:
-            return _cache[cls, "primes", start, stop]
+        if (cls, "primes", start, stop,distinct) in _cache:
+            return _cache[cls, "primes", start, stop,distinct]
 
         if stop <= 1_000_000:
             result = in_range(cls._primes_up_to_1_000_000(), start, stop)
         else:
             result = cls._primes(start, stop)
+        if distinct:
+            result=list(filter(cls.is_distinct,result))
+       
         if cache:
-            _cache[cls, "primes", start, stop] = result
+            _cache[cls, "primes", start, stop,distinct] = result
+
         return result
 
     @classmethod
@@ -555,23 +564,23 @@ class istr(str):
         return n == round(n ** (1 / exponent)) ** exponent
 
     @classmethod
-    def squares(cls, start=None, stop=None, /, length=None, cache=True):
+    def squares(cls, start=None, stop=None, /, length=None, distinct=False, cache=True):
         """
         returns all squares up to a given stop or between a given start and stop
         alternatively, the length can be given
         """
-        return cls.power_ofs(2, start, stop, length=length, cache=cache)
+        return cls.power_ofs(2, start, stop, length=length, distinct=distinct, cache=cache)
 
     @classmethod
-    def cubes(cls, start=None, stop=None, /, length=None, cache=True):
+    def cubes(cls, start=None, stop=None, /, length=None, distinct=False,cache=True):
         """
         returns all cubes up to a given stop or between a given start and stop
         alternatively, the length can be given
         """
-        return cls.power_ofs(3, start, stop, length=length, cache=cache)
+        return cls.power_ofs(3, start, stop, length=length, distinct=distinct,cache=cache)
 
     @classmethod
-    def power_ofs(cls, exponent, start=None, stop=None, /, length=None, cache=True):
+    def power_ofs(cls, exponent, start=None, stop=None, /, length=None, distinct=None, cache=True):
         """
         returns all power of n up to a given stop or between a given start and stop
         alternatively, the length can be given
@@ -579,8 +588,8 @@ class istr(str):
         start, stop, step = process_start_stop_step_length(start, stop, 1, length)
         exponent = check_integer(exponent, "exponent")
 
-        if (cls, "power_ofs", exponent, start, stop) in _cache:
-            return _cache[cls, "power_ofs", exponent, start, stop]
+        if (cls, "power_ofs", exponent, start, stop,distinct) in _cache:
+            return _cache[cls, "power_ofs", exponent, start, stop,distinct]
         match exponent:
             case 0:
                 if start <= 1 < stop:
@@ -593,8 +602,10 @@ class istr(str):
                 result = in_range(cls._power_ofs_up_to_1_000_000(exponent), start, stop)
             case _:
                 result = cls._power_ofs(exponent, start, stop)
+        if distinct:
+            result=list(filter(cls.is_distinct,result))
         if cache:
-            _cache[cls, "power_ofs", exponent, start, stop] = result
+            _cache[cls, "power_ofs", exponent, start, stop, distinct] = result
         return result
 
     @classmethod
@@ -674,7 +685,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):
@@ -703,8 +727,12 @@ class istr(str):
     def __getitem__(self, key):
         return self.__class__(super().__getitem__(key))
 
-    def all_distinct(self):
-        return len(self) == len(set(self))
+    def is_distinct(self): 
+        s = istr.interpret_as_str(self)
+        return len(s) == len(set(s))
+        
+    all_distinct=is_distinct
+    
 
     def is_consecutive(self):
         s = istr.interpret_as_str(self)
@@ -859,6 +887,7 @@ class istr(str):
     def enumerate(cls, iterable, start=0):
         for i, value in enumerate(iterable, int(start)):
             yield cls(i), value
+            
 
     @staticmethod
     @functools.lru_cache(maxsize=1)
@@ -912,13 +941,26 @@ class istr(str):
                         return istr._long_sqrt(self.number)
                     case "line_lengths":
                         return [*map(len, istr._long_sqrt(self.number))]
+                    case "indents":
+                        lines = self.output
+                        result = []
+                        for line in lines.splitlines():
+                            if '-' not in line:
+                                for i,c in enumerate(line[2:]):
+                                    if c != ' ':
+                                        break
+                                else:
+                                    i=0
+                                result.append(i)
+                        return result
+
                     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]}")
+                        result.append(f"\\/{lines[1]}")
 
                         last_len = len(lines[2])
                         for i, line in enumerate(lines):
@@ -952,6 +994,8 @@ class istr(str):
 
         return lines
 
+
+        
     def long_multiplication(self, number, as_str=False):
         class NumbersHolder:
             def __init__(self, number0, number1):
@@ -1139,7 +1183,18 @@ class istr(str):
             self.saved_cls._base = self.saved_base
 
     @classmethod
-    def range(cls, start=None, stop=None, step=1, /, length=None, base=None, int_format=None, repr_mode=None):
+    def _range_distinct(cls,length):
+        for c0 in range(1,10):
+            for crest in itertools.permutations(itertools.chain(range(0,c0),range(c0+1,10)),length-1):
+                yield cls(c0)|cls.join(cls(crest))
+        
+    @classmethod
+    def range(cls, start=None, stop=None, step=1, /, length=None, distinct=False, base=None, int_format=None, repr_mode=None):
+        if distinct:
+            if length is None:
+                return filter(cls.is_distinct,_range(cls,start,stop,step,length,base=base, int_format=int_format, repr_mode=repr_mode))
+            else:
+                return cls._range_distinct(length)
         return _range(cls, start, stop, step, length, base=base, int_format=int_format, repr_mode=repr_mode)
 
     @classmethod
@@ -1330,6 +1385,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.45}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.43
+Version: 1.1.45
 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
@@ -370,14 +370,20 @@ a, b, c = istr(*range(3)) ==> a=istr('0') , b=istr('1'), c=istr('2')
   ```
 #### Alternative way of range specification
 
-Instead of `istr(range(..))` it is possible to use `istr,range(..)` instead, like
+Instead of `istr(range(..))` it is possible to use `istr.range(..)` instead, like
 
 `list(istr.range(3,6))` ==> `[istr('3'), istr('4'), istr('5')]`
 
-In contrast to the builtin `range`, `istr.range` supports a non keyword parameter `length`:
+In contrast to the builtin `range`, `istr.range` supports a keyword parameter `length`:
 
 `list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
 
+On top of this, `istr.range` support a keyword parameter `distinct`, to return a generator that yields only numbers with distinct numbers:
+
+`list(istr.range(98,104,distinct=True))` is `[istr('98'), istr('102'), istr('103')]`
+
+For `istr.range(length=..., distict=True)` the generation is optimized (not just checking each possible value).
+
 #### square root, cubic root and nth root
 The methods `sqrt`, `cbrt`, `nth_root`provide the square root, cubic root and nth root of an istr. If there is no integer root, the fallback value (default `istr('0')` will be returned.
 ```
@@ -547,15 +553,15 @@ istr.divisors(18, False) ==> [istr('1'), istr('18'), istr('2'), istr('9'), istr(
 
 #### test whether all characters are distinct
 
-With the `all_distinct` method, it is possible to test whether all characters are distinct (i.e. no character appears more than once).
+With the `is_distinct` method, it is possible to test whether all characters are distinct (i.e. no character appears more than once).
 
 ```
-istr('01234').all_distict() ==> True
-istr('012340').all_distict() ==> False
+istr('01234').is_distict() ==> True
+istr('012340').is_distict() ==> False
 n98 = istr(98)
 n100 = n98 + 2
-istr(n98).all_distinct() ==> True
-istr(n100).all_distinct() ==> False
+istr(n98).is_distinct() ==> True
+istr(n100).is_distinct() ==> False
 ```
 #### test if characters are consecutive
 
@@ -824,8 +830,17 @@ Alternatively, it is possible to get a list of all squares, cubes, power_ofs or
 
 `istr.squares (length=2)` returns a list of all squares of length 2, so between 10 and 99.
 
+If the keyword `distinct` is True, all values that are not distinct, will be excluded, like:
+
+`list(istr.primes(list(istr.primes(100,132,distinct=True))` is `[istr('103'), istr('107'), istr('109'), istr('127')]`, thus leaving out 101, 113 and 131
+
 Unless `cache=False` is specified, the query result is cached.
 
+#### filter distinct_only 
+
+With `istr.distinct_only` any iterable can skip values that are not distinct:
+`list(istr.distinct_only([10, 11, 100, 123, 'abc', 'aaa']))` is `[istr('10'), istr('123'), istr('abc')]`
+
 #### Safe indexing (getitem)
 
 The `istr.getitem` method is essentially, a safe version of indexing an istr.
@@ -1041,6 +1056,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.45}/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.45"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = []

{istr_python-1.1.43 → istr_python-1.1.45}/tests/test_istr.py

@@ -3,6 +3,8 @@ import itertools
 import os
 import sys
 import re
+import time
+from collections.abc import Iterator
 
 if __name__ == "__main__":  # to make the tests run without the pytest cli
     import os, sys  # three lines to use the local package and chdir
@@ -196,7 +198,30 @@ def test_range():
     with pytest.raises(ValueError, match=re.escape("both bound(s) and length specified")):
         istr.range(10, length=2)
 
-
+    assert list(map(int,istr.range(98,124,distinct=True)))==[98, 102, 103, 104, 105, 106, 107, 108, 109, 120, 123]
+    assert sorted(map(int,set(istr.range(length=2))-set(istr.range(length=2,distinct=True))))==[11, 22, 33, 44, 55, 66, 77, 88, 99]
+    
+    assert type(istr.range(12)).__name__=='_range'
+    assert isinstance(istr.range(12,distinct=True),Iterator)      
+    assert type(istr.range(length=2)).__name__=='_range'    
+    assert isinstance(istr.range(length=2,distinct=True),Iterator)
+    
+    t0=time.perf_counter()
+    result0=istr.range(length=4,distinct=True)
+    duration0=time.perf_counter()-t0
+    t0=time.perf_counter()
+    result1=istr.range(1000,10000,distinct=True)
+    duration1=time.perf_counter()-t0    
+    assert list(result0)==list(result1)
+    assert duration1>duration0*2
+    
+    
+def test_various_distinct():
+    assert sorted(set(istr.primes(80,140))-set(istr.primes(80,140,distinct=True)))==istr([101, 113, 131])
+    assert sorted(set(istr.squares(150))-set(istr.squares(150,distinct=True)))==istr([100, 121,144])
+    assert sorted(set(istr.cubes(10000))-set(istr.cubes(10000,distinct=True)))==istr([343, 1000, 1331,2744,3375,8000])    
+    assert sorted(set(istr.power_ofs(4,50000))-set(istr.power_ofs(4,50000,distinct=True)))==istr([6561,10000,14641])    
+    
 def test_misc():
     assert istr("") == ""
     assert istr("") != 0
@@ -1128,8 +1153,26 @@ def test_decompose():
         istr(12).decompose("xyz")
     with pytest.raises(ValueError):
         istr(123).decompose("xy1")
+        
+def test_eval():
+    global a,b,c
+    a = 3
+    b = istr('4')
+    c=istr(7)
+    assert istr.eval('a + b')==7
+    assert istr.eval('a + b = c')
+    assert istr.eval('a + b > 6')
+    assert not istr.eval('a + b < 6')
+    with pytest.raises(ValueError):
+        assert istr.eval('d')
 
-
+    assert istr('?a + b')==7
+    assert istr('?a + b = c')
+    assert istr('?a + b > 6')
+    assert not istr('?a + b < 6')
+    with pytest.raises(ValueError):
+        assert istr('?d')    
+    
 def test_ceil():
     assert istr(1000).ceil() == 1000
     assert istr(1000).ceil(1) == 1000