istr-python 1.1.16__tar.gz → 1.1.18__tar.gz

{istr_python-1.1.16 → istr_python-1.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.16
+Version: 1.1.18
 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
@@ -387,6 +387,15 @@ It is also possible to test for divisibility of an ordinary int:
 istr.is_divisible(18, 3) ==> True
 istr.is_divisible(19, 3) ==> False
 ```
+The method `divided_by` not only tests divisibility, but also returns the result of the division. If not possible, None will be returned.
+```
+istr(18).divided_by(3) ==> 6 (actually istr("6"))
+istr(18).divided_by(istr(3)) ==> 6
+istr(19).divided_by(3) ==> None
+istr(19).divided_by(istr(3)) ==> None
+istr.divided_by(18, 3) ==>  6
+istr.divided_by(19, 3) ==>  None
+```
 #### test for square
 
 It is possible to test whether the value is a perfect square (provided the istr can be interpreted as an int) with the `is_square` method, e.g.
@@ -693,17 +702,16 @@ Composing can also be done by prefixing a string with '=', like:
 ```
 xyz = istr("=xyz")
 print(f"{xyx=}")  # ==> will print xyz=396
-
+```
 Note that `str(istr("="))` is "=".
 
 Composing and assignment can be done by prefixing a string with ':=', like:
 
 ```
 if istr(":=xyz") > 300:
-	print(f"{xyx=}")  # ==> will print xyz=396
-	
-Note that `str(istr(":="))` is ":=" and does not assign the value to a variable.
+	print(f"{xyz=}")  # ==> will print xyz=396
 ```
+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.
 

{istr_python-1.1.16 → istr_python-1.1.18}/README.md

@@ -374,6 +374,15 @@ It is also possible to test for divisibility of an ordinary int:
 istr.is_divisible(18, 3) ==> True
 istr.is_divisible(19, 3) ==> False
 ```
+The method `divided_by` not only tests divisibility, but also returns the result of the division. If not possible, None will be returned.
+```
+istr(18).divided_by(3) ==> 6 (actually istr("6"))
+istr(18).divided_by(istr(3)) ==> 6
+istr(19).divided_by(3) ==> None
+istr(19).divided_by(istr(3)) ==> None
+istr.divided_by(18, 3) ==>  6
+istr.divided_by(19, 3) ==>  None
+```
 #### test for square
 
 It is possible to test whether the value is a perfect square (provided the istr can be interpreted as an int) with the `is_square` method, e.g.
@@ -680,17 +689,16 @@ Composing can also be done by prefixing a string with '=', like:
 ```
 xyz = istr("=xyz")
 print(f"{xyx=}")  # ==> will print xyz=396
-
+```
 Note that `str(istr("="))` is "=".
 
 Composing and assignment can be done by prefixing a string with ':=', like:
 
 ```
 if istr(":=xyz") > 300:
-	print(f"{xyx=}")  # ==> will print xyz=396
-	
-Note that `str(istr(":="))` is ":=" and does not assign the value to a variable.
+	print(f"{xyz=}")  # ==> will print xyz=396
 ```
+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.
 

{istr_python-1.1.16 → istr_python-1.1.18}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.16"
+__version__ = "1.1.18"
 import functools
 import itertools
 import types
@@ -193,7 +193,7 @@ class istr(str):
     Parameters
     ----------
     value : any
-        if str the value will to be interpreted as an int
+        if str, the value will to be interpreted as an int
             istr('8') ==> istr('8')
         if numeric, the value will be interpreted as an int
             istr(8) ==> istr('8')
@@ -296,12 +296,13 @@ class istr(str):
 
         self = super().__new__(cls, as_str)
         self._as_int = as_int
-        if repr_mode == "istr":
-            self._as_repr = f"{cls.__name__}({repr(as_str)})"
-        elif repr_mode == "int":
-            self._as_repr = "?" if as_int is self._nan else repr(as_int)
-        else:
-            self._as_repr = repr(as_str)
+        match repr_mode:
+            case "istr":
+                self._as_repr = f"{cls.__name__}({repr(as_str)})"
+            case "int":
+                self._as_repr = "?" if as_int is self._nan else repr(as_int)
+            case _:
+                self._as_repr = repr(as_str)
         self._this_base = base
         self._this_int_format = int_format
         self._this_repr_mode = repr_mode
@@ -397,38 +398,45 @@ class istr(str):
         return not istr.is_divisible_by(self, 2)
 
     def is_divisible_by(self, divisor):
-        return divisor!=0 and istr.interpret_as_int(self) % int(divisor) == 0
+        return istr.divided_by(self, divisor) is not None
+
+    def divided_by(self, divisor):
+        if divisor == 0:
+            return None
+        quotient, remainder = divmod(istr.interpret_as_int(self), int(divisor))
+        return istr(quotient) if remainder == 0 else None
 
     def is_square(self):
-        n = istr.interpret_as_int(self)
-        if n < 1000000:
-            return n in _squares_up_to_1_000_000()
-        return n == round(n ** (1 / 2)) ** 2
+        return istr.is_power_of(self, 2)
 
     def is_cube(self):
-        n = istr.interpret_as_int(self)
-        if n < 1000000:
-            return n in _cubes_up_to_1_000_000()
-        return n == round(n ** (1 / 3)) ** 3
+        return istr.is_power_of(self, 3)
 
     def is_power_of(self, exponent):
         n = istr.interpret_as_int(self)
-        if exponent < 1:
-            raise ValueError(f"exponent must be >=1; not {exponent}")
-        if not isinstance(exponent, int):
-            raise TypeError(f"exponent must be int; not {type(exponent)}")
+        match exponent:
+            case 2:
+                if n < 1000000:
+                    return n in _squares_up_to_1_000_000()
+            case 3:
+                if n < 1000000:
+                    return n in _cubes_up_to_1_000_000()
+            case 0:
+                return n == 1
+            case _ if exponent < 0:
+                raise ValueError(f"exponent must be >=1; not {exponent}")
+            case _ if not isinstance(exponent, int):
+                raise TypeError(f"exponent must be int; not {type(exponent)}")
         return n >= 0 and n == round(n ** (1 / exponent)) ** exponent
 
     def is_prime(self):
         n = istr.interpret_as_int(self)
-        if n < 2:
-            return False
-        if n == 2:
-            return True
-        if not n & 1:
-            return False
         if n < 1000000:
             return n in _primes_up_to_1_000_000()
+
+        if not n & 1:
+            return False
+
         for x in range(3, int(n**0.5) + 1, 2):
             if n % x == 0:
                 return False
@@ -441,35 +449,33 @@ class istr(str):
         """
         if ("primes", lb_or_ub, ub) in _cache:
             return _cache["primes", lb_or_ub, ub]
-        result = sorted(map(cls, _primes(lb_or_ub, ub)))
+        result = list(map(cls, _primes(lb_or_ub, ub)))
         if cache:
-            _cache["primes", lb_or_ub, ub]=result
-        return result 
+            _cache["primes", lb_or_ub, ub] = result
+        return result
 
     @classmethod
     def squares(cls, lb_or_ub, ub=None, cache=True):
         """
         returns all squares up to a given upperbound or between a given lowerbound and upperbound
         """
-        return istr.power_ofs(2,lb_or_ub, ub, cache=cache)
+        return istr.power_ofs(2, lb_or_ub, ub, cache=cache)
 
     @classmethod
     def cubes(cls, lb_or_ub, ub=None, cache=True):
-        return istr.power_ofs(3,lb_or_ub, ub, cache=cache)
+        return istr.power_ofs(3, lb_or_ub, ub, cache=cache)
 
     @classmethod
-    def power_ofs(cls, n,lb_or_ub, ub=None, cache=True):
+    def power_ofs(cls, n, lb_or_ub, ub=None, cache=True):
         """
         returns all power of n up to a given upperbound or between a given lowerbound and upperbound
         """
         if ("power_ofs", n, lb_or_ub, ub) in _cache:
             return _cache["power_ofs", n, lb_or_ub, ub]
-        result = sorted(map(cls, _power_ofs(n,lb_or_ub, ub)))
+        result = list(map(cls, _power_ofs(n, lb_or_ub, ub)))
         if cache:
-            _cache["power_ofs", n, lb_or_ub, ub]=result
-        return result         
-
-
+            _cache["power_ofs", n, lb_or_ub, ub] = result
+        return result
 
     def decompose(self, letters, namespace=None):
         """
@@ -796,52 +802,62 @@ def _map(func, *iterables, strict=False):
 
         yield func(*values)
 
-_cache={}
+
+_cache = {}
+
 
 def _primes(lb_or_ub, ub=None):
     lb, ub = (0, lb_or_ub) if ub is None else (lb_or_ub, ub)
+    if lb < 0:
+        lb = 0
     sieve = bytearray(b"\x01") * (ub + 1)
     sieve[0:2] = b"\x00\x00"
 
-    for i in range(2, int(ub**0.5)+1 ):
+    for i in range(2, int(ub**0.5) + 1):
         if sieve[i]:
             sieve[i * i : ub + 1 : i] = b"\x00" * (((ub - i * i) // i) + 1)
 
-    return {i for i, is_prime in enumerate(sieve) if is_prime and lb<=i<ub}
+    return [i for i, is_prime in enumerate(sieve) if is_prime and lb <= i < ub]
 
 
 @functools.lru_cache(maxsize=1)
 def _primes_up_to_1_000_000():
-    return _primes(1000000)
+    return set(_primes(1000000))
 
 
 @functools.lru_cache(maxsize=1)
 def _squares_up_to_1_000_000():
-    return _power_ofs(2,1000000)
+    return set(_power_ofs(2, 1000000))
+
 
 @functools.lru_cache(maxsize=1)
 def _cubes_up_to_1_000_000():
-    return _power_ofs(3,1000000)
+    return set(_power_ofs(3, 1000000))
 
 
 def _power_ofs(n, lb_or_ub, ub=None):
     lb, ub = (0, lb_or_ub) if ub is None else (lb_or_ub, ub)
-    result = set()
-    if n==0:
-        if lb<=1<ub:
-            result.add(1)
-    elif n==1:
-        result={*range(lb,ub)}
-    else:
-        i = int(lb ** (1 / n))
-        while (in_ := i**n) < ub:
-            if in_ >= lb:
-                result.add(in_)
-            i += 1
+    if lb < 0:
+        lb = 0
+    result = []
+    match n:
+        case 0:
+            if lb <= 1 < ub:
+                result.append(1)
+        case 1:
+            result = {*range(lb, ub)}
+        case _:
+            i = int(lb ** (1 / n))
+            while (i_n := i**n) < ub:
+                if i_n >= lb:
+                    result.append(i_n)
+                i += 1
     return result
 
+
 istr.type = type(istr(0))
 
+
 class istrModule(types.ModuleType):
     def __call__(self, *args, **kwargs):
         return istr(*args, **kwargs)

{istr_python-1.1.16 → istr_python-1.1.18}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.16
+Version: 1.1.18
 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
@@ -387,6 +387,15 @@ It is also possible to test for divisibility of an ordinary int:
 istr.is_divisible(18, 3) ==> True
 istr.is_divisible(19, 3) ==> False
 ```
+The method `divided_by` not only tests divisibility, but also returns the result of the division. If not possible, None will be returned.
+```
+istr(18).divided_by(3) ==> 6 (actually istr("6"))
+istr(18).divided_by(istr(3)) ==> 6
+istr(19).divided_by(3) ==> None
+istr(19).divided_by(istr(3)) ==> None
+istr.divided_by(18, 3) ==>  6
+istr.divided_by(19, 3) ==>  None
+```
 #### test for square
 
 It is possible to test whether the value is a perfect square (provided the istr can be interpreted as an int) with the `is_square` method, e.g.
@@ -693,17 +702,16 @@ Composing can also be done by prefixing a string with '=', like:
 ```
 xyz = istr("=xyz")
 print(f"{xyx=}")  # ==> will print xyz=396
-
+```
 Note that `str(istr("="))` is "=".
 
 Composing and assignment can be done by prefixing a string with ':=', like:
 
 ```
 if istr(":=xyz") > 300:
-	print(f"{xyx=}")  # ==> will print xyz=396
-	
-Note that `str(istr(":="))` is ":=" and does not assign the value to a variable.
+	print(f"{xyz=}")  # ==> will print xyz=396
 ```
+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.
 

{istr_python-1.1.16 → istr_python-1.1.18}/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.16"
+version = "1.1.18"
 readme = "README.md"
 requires-python = ">=3.8"
 dependencies = []

{istr_python-1.1.16 → istr_python-1.1.18}/tests/test_istr.py

@@ -343,6 +343,17 @@ def test_is_divisible_by():
     assert not istr.is_divisible_by(19, 3)
 
 
+def test_divided_by():
+    assert istr(18).divided_by(3).equals(istr(6))
+    assert istr(18).divided_by(istr(3)).equals(istr(6))
+    assert istr(19).divided_by(3) is None
+    assert istr(19).divided_by(istr(3)) is None
+    with pytest.raises(TypeError, match=re.escape(f"not interpretable as int")):
+        istr("a").divided_by(3)
+    assert istr.divided_by(18, 3).equals(istr(6))
+    assert istr.divided_by(19, 3) is None
+
+
 def test_is_square():
     assert not istr(-1).is_square()
     assert istr(0).is_square()
@@ -441,11 +452,16 @@ def test_cubes():
     assert istr.cubes(27, 50) == [istr("27")]
     assert id(istr.cubes(100)) == id(istr.cubes(100))  # test caching
 
+
 def test_power_ofs():
-    assert istr.power_ofs(3,1,50) == [istr("1"), istr("8"), istr("27")]
-    assert istr.power_ofs(5,1, 500) == [istr('1'), istr('32'), istr('243')]
-    assert id(istr.power_ofs(3,2000)) != id(istr.cubes(3,2000))  # test caching
-    assert id(istr.power_ofs(3,1000,cache=False)) != id(istr.cubes(3,1000,cache=False))  # test caching
+    assert istr.power_ofs(0, 1, 5) == [istr("1")]
+    assert istr.power_ofs(0, 1) == []
+    assert istr.power_ofs(1, -1, 5) == [istr("0"), istr("1"), istr("2"), istr("3"), istr("4")]
+    assert istr.power_ofs(1, 0) == []
+    assert istr.power_ofs(3, 1, 50) == [istr("1"), istr("8"), istr("27")]
+    assert istr.power_ofs(5, 1, 500) == [istr("1"), istr("32"), istr("243")]
+    assert id(istr.power_ofs(3, 2000)) != id(istr.cubes(3, 2000))  # test caching
+    assert id(istr.power_ofs(3, 1000, cache=False)) != id(istr.cubes(3, 1000, cache=False))  # test caching
 
 
 def test_join():