istr-python 1.1.7__tar.gz → 1.1.8.post0__tar.gz

{istr_python-1.1.7 → istr_python-1.1.8.post0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.7
+Version: 1.1.8.post0
 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
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/salabim/istr
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 
  <img src="https://www.salabim.org/istr/istr_logo.png" width=500>
@@ -556,6 +556,25 @@ list(istr.concat(istr.permutations(range(3),2))) ==>
     [istr('01'), istr('02'), istr('10'), istr('12'), istr('20'), istr('21')] 
 ```
 
+#### prod to get product of an iterable
+
+The method `prod` can be used to return the product of an iterable (including an istr), like `math.prod`, but as istr. 
+Thus, `istr.prod(range(1,5))` is `istr(24)`
+And `istr("123", start=4)` is also `istr(24)`.
+
+It is also possible to apply `prod` on an istr:
+`istr(1234).prod()` is `istr(24)`
+`istr("123").prod(start=4)` is `istr(24)`
+
+#### sumprod to get the sum of products of iterables
+
+The class method `istr.sumprod()`, is equivalent to `math.sumprod()`, but applies  istr to both iterables.
+Note that this method is available even in Python < 3.12 .
+Thus, `istr.sumprod("12", (3,4))` is `istr(11)`
+In contrast with `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter (True by default)
+Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
+raises a ValueError. 
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.

{istr_python-1.1.7 → istr_python-1.1.8.post0}/README.md

@@ -543,6 +543,25 @@ list(istr.concat(istr.permutations(range(3),2))) ==>
     [istr('01'), istr('02'), istr('10'), istr('12'), istr('20'), istr('21')] 
 ```
 
+#### prod to get product of an iterable
+
+The method `prod` can be used to return the product of an iterable (including an istr), like `math.prod`, but as istr. 
+Thus, `istr.prod(range(1,5))` is `istr(24)`
+And `istr("123", start=4)` is also `istr(24)`.
+
+It is also possible to apply `prod` on an istr:
+`istr(1234).prod()` is `istr(24)`
+`istr("123").prod(start=4)` is `istr(24)`
+
+#### sumprod to get the sum of products of iterables
+
+The class method `istr.sumprod()`, is equivalent to `math.sumprod()`, but applies  istr to both iterables.
+Note that this method is available even in Python < 3.12 .
+Thus, `istr.sumprod("12", (3,4))` is `istr(11)`
+In contrast with `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter (True by default)
+Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
+raises a ValueError. 
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.

{istr_python-1.1.7 → istr_python-1.1.8.post0}/istr/istr.py

@@ -5,12 +5,14 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.7"
+__version__ = "1.1.8"
 import functools
 import itertools
 import types
 import sys
 import inspect
+import math
+import operator
 
 """
 Note: the changelog is now in changelog.md
@@ -230,7 +232,7 @@ class istr(str):
                 return int(value, cls._base)
             else:
                 return int(value)
-        except:
+        except Exception:
             return cls._nan
 
     def __new__(cls, *value):
@@ -251,8 +253,8 @@ class istr(str):
                 return map(functools.partial(cls), value)
             return type(value)(map(functools.partial(cls), value))
 
-        if isinstance(value, str) and value.startswith('='):
-            value=str(cls.compose(value[1:],inspect.currentframe().f_back.f_back.f_globals))   
+        if isinstance(value, str) and value.startswith("="):
+            value = str(cls.compose(value[1:], inspect.currentframe().f_back.f_back.f_globals))
         as_int = cls._to_int(value)
         if isinstance(value, str):
             as_str = value
@@ -349,10 +351,10 @@ class istr(str):
         return int(self._as_int)
 
     def is_even(self):
-        return istr.is_divisible_by(self,2)
+        return istr.is_divisible_by(self, 2)
 
     def is_odd(self):
-        return not istr.is_divisible_by(self,2)
+        return not istr.is_divisible_by(self, 2)
 
     def is_divisible_by(self, divisor):
         return istr.interpret_as_int(self) % int(divisor) == 0
@@ -489,6 +491,17 @@ class istr(str):
     def concat(cls, iterable):
         return map(lambda x: istr("").join(x), istr(iterable))
 
+
+    def prod(self, *, start=1):
+        return math.prod(self, start=istr(start))
+
+
+    @classmethod
+    def sumprod(cls, p, q, /, strict=True):
+        if "sumprod" in math.__dict__ and strict:
+            return istr(math.sumprod(p, q))
+        return sum(_map(operator.__mul__, cls(p), cls(q), strict=strict))
+
     @classmethod
     def enumerate(cls, iterable, start=0):
         for i, value in enumerate(iterable, start):
@@ -519,7 +532,7 @@ class istr(str):
         def __new__(cls, cls_repr_mode, mode=None):
             if mode is None:
                 return cls_repr_mode._repr_mode
-            if mode == int:
+            if mode is int:
                 mode = "int"
             if mode in ("istr", "str", "int"):  # _istr is used only for TypeErrors
                 return super().__new__(cls)
@@ -628,6 +641,41 @@ class istr(str):
         return result
 
 
+def _map(func, *iterables, strict=False):
+    """
+    like map, but with a strict parameter (also for Python < 3.14)
+    """
+    if sys.version_info >= (3, 14):
+        yield from map(func, *iterables, strict=strict)
+        return 
+    
+    if not strict:
+        yield from map(func, *iterables)
+        return
+
+    iterators = [iter(it) for it in iterables]
+
+    while True:
+        values = []
+        exhausted = []
+        for it in iterators:
+            try:
+                v = next(it)
+                values.append(v)
+                exhausted.append(False)
+            except StopIteration:
+                values.append(None)
+                exhausted.append(True)
+
+        if all(exhausted):
+            return
+
+        if any(exhausted) and not all(exhausted):
+            raise ValueError("map_strict: iterables have different lengths")
+
+        yield func(*values)
+
+
 istr.type = type(istr(0))
 
 

{istr_python-1.1.7 → istr_python-1.1.8.post0}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.7
+Version: 1.1.8.post0
 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
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/salabim/istr
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 
  <img src="https://www.salabim.org/istr/istr_logo.png" width=500>
@@ -556,6 +556,25 @@ list(istr.concat(istr.permutations(range(3),2))) ==>
     [istr('01'), istr('02'), istr('10'), istr('12'), istr('20'), istr('21')] 
 ```
 
+#### prod to get product of an iterable
+
+The method `prod` can be used to return the product of an iterable (including an istr), like `math.prod`, but as istr. 
+Thus, `istr.prod(range(1,5))` is `istr(24)`
+And `istr("123", start=4)` is also `istr(24)`.
+
+It is also possible to apply `prod` on an istr:
+`istr(1234).prod()` is `istr(24)`
+`istr("123").prod(start=4)` is `istr(24)`
+
+#### sumprod to get the sum of products of iterables
+
+The class method `istr.sumprod()`, is equivalent to `math.sumprod()`, but applies  istr to both iterables.
+Note that this method is available even in Python < 3.12 .
+Thus, `istr.sumprod("12", (3,4))` is `istr(11)`
+In contrast with `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter (True by default)
+Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
+raises a ValueError. 
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.

{istr_python-1.1.7 → istr_python-1.1.8.post0}/pyproject.toml

@@ -10,9 +10,9 @@ authors = [
     { name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com" },
 ]
 description = "istr - strings you can count on"
-version = "1.1.7"
+version = "1.1.8.post0"
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 dependencies = []
 classifiers = [
     "Development Status :: 5 - Production/Stable",

{istr_python-1.1.7 → istr_python-1.1.8.post0}/tests/test_istr.py

@@ -313,7 +313,8 @@ def test_even_odd():
     assert istr.is_even(12345678)
     assert istr.is_odd(11111111)
 
-def test_is_divisible():
+
+def test_is_divisible_by():
     assert istr(18).is_divisible_by(3)
     assert istr(18).is_divisible_by(istr(3))
     assert not istr(19).is_divisible_by(3)
@@ -323,6 +324,7 @@ def test_is_divisible():
     assert istr.is_divisible_by(18, 3)
     assert not istr.is_divisible_by(19, 3)
 
+
 def test_is_square():
     assert not istr(-1).is_square()
     assert istr(0).is_square()
@@ -339,6 +341,7 @@ def test_is_square():
     assert istr.is_square(4)
     assert istr.is_square(16)
 
+
 def test_is_cube():
     assert not istr(-1).is_cube()
     assert istr(0).is_cube()
@@ -366,16 +369,17 @@ def test_is_power_of():
     assert not istr(99).is_power_of(3)
     with pytest.raises(TypeError, match=re.escape(f"not interpretable as int")):
         istr("a").is_power_of(3)
-    assert istr.is_power_of(0,3)
-    assert istr.is_power_of(1,3)
-    assert not istr.is_power_of(2,3)
-    assert istr.is_power_of(8,3)
-    assert istr.is_power_of(27,3)
+    assert istr.is_power_of(0, 3)
+    assert istr.is_power_of(1, 3)
+    assert not istr.is_power_of(2, 3)
+    assert istr.is_power_of(8, 3)
+    assert istr.is_power_of(27, 3)
     with pytest.raises(TypeError):
         istr(1).is_power_of(3.1)
     with pytest.raises(ValueError):
         istr(1).is_power_of(-1)
- 
+
+
 def test_is_prime():
     assert not istr(0).is_prime()
     assert not istr(1).is_prime()
@@ -553,12 +557,13 @@ def test_unpacking():
     assert x.equals(istr(1))
     assert y.equals(istr(2))
     assert z.equals(istr(3))
-    del x,y,z
+    del x, y, z
 
     x, y, z = a
     assert x.equals(istr(1))
     assert y.equals(istr(2))
-    assert z=="3"
+    assert z == "3"
+
 
 def test_repr_mode():
     hundred = istr(100)
@@ -649,9 +654,6 @@ def test_base():
         assert a * a == 225
 
 
-
-
-
 def test_digits():
     assert istr.digits().equals(istr("0123456789"))
     assert istr.digits("").equals(istr("0123456789"))
@@ -703,13 +705,16 @@ def test_itertools():
     assert list(istr.dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1])) == [istr("6"), istr("4"), istr("1")]
     assert list(istr.filterfalse(lambda x: x % 2, range(10))) == [istr("0"), istr("2"), istr("4"), istr("6"), istr("8")]
     assert list(istr.islice("123456", 2)) == [istr("1"), istr("2")]
-    assert list(istr.pairwise("1234")) == [(istr("1"), istr("2")), (istr("2"), istr("3")), (istr("3"), istr("4"))]
     assert list(istr.permutations(range(5), 3)) == list(istr(itertools.permutations(range(5), 3)))
     assert list(istr.product(range(5), range(4))) == list(istr(itertools.product(range(5), range(4))))
     assert list100(istr.repeat(10)) == list100(istr(itertools.repeat(10)))
     assert list(istr.starmap(pow, [(2, 5), (3, 2), (10, 3)])) == [istr("32"), istr("9"), istr("1000")]
     assert list(istr.takewhile(lambda x: x < 5, [1, 4, 6, 3, 8])) == [istr("1"), istr("4")]
     assert list(istr.zip_longest("123", "56", fillvalue="0")) == [(istr("1"), istr("5")), (istr("2"), istr("6")), (istr("3"), istr("0"))]
+    if sys.version_info >= (3, 10):
+        assert list(istr.pairwise("1234")) == [(istr("1"), istr("2")), (istr("2"), istr("3")), (istr("3"), istr("4"))]
+    if sys.version_info >= (3, 12):
+        assert list(istr.batched("12345", n=2)) == [(istr("1"), istr("2")), (istr("3"), istr("4")), (istr("5"),)]
 
 
 def test_all_distinct():
@@ -718,6 +723,25 @@ def test_all_distinct():
     assert istr("").all_distinct()
 
 
+def test_prod():
+    assert istr.prod(range(1, 5)).equals(istr(24))
+    assert istr.prod((1, 2, 3), start=4).equals(istr(24))
+    assert istr("1234").prod().equals(istr(24))
+    assert istr("123").prod(start=4).equals(istr(24))
+
+
+def test_sumprod():
+    assert istr.sumprod((1, 2), (3, 4)).equals(istr(11))
+    assert istr.sumprod(istr("12"), (3, 4)).equals(istr(11))
+    assert istr.sumprod(istr("12"), "34").equals(istr(11))
+    assert istr.sumprod(istr("12"), "34", strict=False).equals(istr(11))
+    assert istr.sumprod(istr("12"), "345", strict=False).equals(istr(11))
+    with pytest.raises(ValueError):
+        istr.sumprod((1, 2), (3, 4, 5))
+    with pytest.raises(ValueError):
+        istr.sumprod((1, 2), (3, 4, 5), strict=True)
+
+
 def test_subclassing():
     class jstr(istr.type): ...
 
@@ -750,8 +774,6 @@ def test_decompose():
         istr(12).decompose("xyz")
     with pytest.raises(ValueError):
         istr(123).decompose("xy1")
-        
-
 
 
 def test_compose():