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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.44
+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.

{istr_python-1.1.44 → 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.

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

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.44"
+__version__ = "1.1.45"
 import functools
 import itertools
 import types
@@ -492,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
@@ -560,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
@@ -584,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:
@@ -598,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
@@ -721,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)
@@ -877,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)
@@ -930,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):
@@ -970,6 +994,8 @@ class istr(str):
 
         return lines
 
+
+        
     def long_multiplication(self, number, as_str=False):
         class NumbersHolder:
             def __init__(self, number0, number1):
@@ -1157,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

{istr_python-1.1.44 → 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.44
+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.

{istr_python-1.1.44 → 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.44"
+version = "1.1.45"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = []

{istr_python-1.1.44 → 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