istr-python 1.1.32.post0__tar.gz → 1.1.33__tar.gz

{istr_python-1.1.32.post0 → istr_python-1.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.32.post0
+Version: 1.1.33
 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
@@ -367,7 +367,18 @@ to unpack multiple values, e.g.
 a, b, c = istr(5, 6, 7) ==> a=istr('5') , b=istr('6'), c=istr('7') 
 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
+
+`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`:
+
+`list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
+
 #### test for even/odd
+
 It is possible to test for even/odd (provided the istr can be interpreted as an int) with the `is_even` and `is_odd` method, e.g.
 
 ```
@@ -754,13 +765,17 @@ In contrast to `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter
 Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
 raises a ValueError. 
 
-#### get all squares, cubes, power ofs or primes in a given range
+#### get all squares, cubes, power ofs or primes in a given range or with a given length
 
 The class methods `istr.squares`, `istr.cubes`, `istr.power_ofs` and `istr.primes` can be used to get a list of all squares, cubes, power_ofs or primes up to a given upperbound (non inclusive) or between a given lower bound and upper bound (non inclusive), like:
 
 `istr.squares (100)` returns a list of all squares <100
 `istr.squares(50, 100)` returns a list of all squares in the range [50, 100)
 
+Alternatively, it is possible to get a list of all squares, cubes, power_ofs or primes with a given length, like:
+
+`istr.squares (length=2)` returns a list of all squares of length 2, so between 10 and 99.
+
 Unless `cache=False` is specified, the query result is cached.
 
 #### generate istr with digits

{istr_python-1.1.32.post0 → istr_python-1.1.33}/README.md

@@ -354,7 +354,18 @@ to unpack multiple values, e.g.
 a, b, c = istr(5, 6, 7) ==> a=istr('5') , b=istr('6'), c=istr('7') 
 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
+
+`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`:
+
+`list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
+
 #### test for even/odd
+
 It is possible to test for even/odd (provided the istr can be interpreted as an int) with the `is_even` and `is_odd` method, e.g.
 
 ```
@@ -741,13 +752,17 @@ In contrast to `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter
 Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
 raises a ValueError. 
 
-#### get all squares, cubes, power ofs or primes in a given range
+#### get all squares, cubes, power ofs or primes in a given range or with a given length
 
 The class methods `istr.squares`, `istr.cubes`, `istr.power_ofs` and `istr.primes` can be used to get a list of all squares, cubes, power_ofs or primes up to a given upperbound (non inclusive) or between a given lower bound and upper bound (non inclusive), like:
 
 `istr.squares (100)` returns a list of all squares <100
 `istr.squares(50, 100)` returns a list of all squares in the range [50, 100)
 
+Alternatively, it is possible to get a list of all squares, cubes, power_ofs or primes with a given length, like:
+
+`istr.squares (length=2)` returns a list of all squares of length 2, so between 10 and 99.
+
 Unless `cache=False` is specified, the query result is cached.
 
 #### generate istr with digits

{istr_python-1.1.32.post0 → istr_python-1.1.33}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.32"
+__version__ = "1.1.33"
 import functools
 import itertools
 import types
@@ -16,6 +16,7 @@ import operator
 import copy
 import bisect
 import collections
+import numbers
 
 """
 Note: the changelog is in changelog.md
@@ -33,12 +34,10 @@ class _range:
     based on https://codereview.stackexchange.com/questions/229073/pure-python-range-implementation
     """
 
-    def __init__(self, cls, start, stop=None, step=1, base=None, int_format=None, repr_mode=None):
-        if stop is None:
-            start, stop = 0, start
-        self.start, self.stop, self.step = (int(obj) for obj in (start, stop, step))
-        if step == 0:
-            raise ValueError("range() arg 3 must not be zero")
+    def __init__(self, cls, start, stop, step, length, base, int_format, repr_mode):
+        self.start, self.stop, self.step = process_start_stop_step_length(start, stop, step, length)
+        if self.step == 0:
+            raise ValueError(f"step must not be zero, not {self.step}")
         if self.step < 0:
             step_sign = -1
         else:
@@ -232,8 +231,8 @@ class istr(str):
     _nan = object()
     _digits_cache = {}
 
-    @staticmethod
-    def _to_base(number, base):
+    @classmethod
+    def _to_base(cls, number, base):
         if number < 0:
             raise ValueError(f"negative numbers are not allowed for base {base}")
         result = ""
@@ -298,7 +297,7 @@ class istr(str):
                 if base == 10:
                     as_str = str(as_int)
                 else:
-                    as_str = istr._to_base(as_int, base)
+                    as_str = cls._to_base(as_int, base)
             else:
                 as_str = f"{as_int:{int_format}}"
 
@@ -447,24 +446,21 @@ class istr(str):
         return True
 
     @classmethod
-    def primes(cls, lb_or_ub, ub=None, cache=True):
-        lb, ub = (0, lb_or_ub) if ub is None else (lb_or_ub, ub)
-        if lb < 0:
-            lb = 0
-        lb = int(lb)
-        ub = int(ub)
+    def primes(cls, start=None, stop=None, /, length=None, cache=True):
         """
         returns all primes up to a given upperbound or between a given lowerbound and upperbound
+        alternatively, the length can be given
         """
-        if (cls, "primes", lb, ub) in _cache:
-            return _cache[cls, "primes", lb, ub]
+        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 ub <= 1_000_000:
-            result = in_range(cls._primes_up_to_1_000_000(), lb, ub)
+        if stop <= 1_000_000:
+            result = in_range(cls._primes_up_to_1_000_000(), start, stop)
         else:
-            result = cls._primes(lb, ub)
+            result = cls._primes(start, stop)
         if cache:
-            _cache[cls, "primes", lb, ub] = result
+            _cache[cls, "primes", start, stop] = result
         return result
 
     @classmethod
@@ -496,8 +492,7 @@ class istr(str):
 
     def is_power_of(self, exponent):
         n = istr.interpret_as_int(self)
-        if isinstance(exponent, istr):
-            exponent = int(exponent)
+        exponent = check_integer(exponent, "exponent")
         if n < 0:
             if exponent % 2 == 0:
                 return False
@@ -510,8 +505,6 @@ class istr(str):
                 return True
             case x if x < 0:
                 raise ValueError(f"exponent must be >=0; not {exponent}")
-            case _ if not isinstance(exponent, int):
-                raise TypeError(f"exponent must be int; not {type(exponent)}")
             case _ if n < 1_000_000:
                 return n in istr._power_ofs_up_to_1_000_000_as_set(exponent)
             case _:
@@ -519,41 +512,46 @@ class istr(str):
         return n == round(n ** (1 / exponent)) ** exponent
 
     @classmethod
-    def squares(cls, lb_or_ub, ub=None, cache=True):
+    def squares(cls, start=None, stop=None, /, length=None, cache=True):
         """
-        returns all squares up to a given upperbound or between a given lowerbound and upperbound
+        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, lb_or_ub, ub, cache=cache)
+        return cls.power_ofs(2, start, stop, length=length, cache=cache)
 
     @classmethod
-    def cubes(cls, lb_or_ub, ub=None, cache=True):
-        return cls.power_ofs(3, lb_or_ub, ub, cache=cache)
+    def cubes(cls, start=None, stop=None, /, length=None, 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)
 
     @classmethod
-    def power_ofs(cls, exponent, lb_or_ub, ub=None, cache=True):
+    def power_ofs(cls, exponent, start=None, stop=None, /, length=None, cache=True):
         """
-        returns all power of n up to a given upperbound or between a given lowerbound and upperbound
+        returns all power of n up to a given stop or between a given start and stop
+        alternatively, the length can be given
         """
-        lb, ub = (0, lb_or_ub) if ub is None else (lb_or_ub, ub)
-        lb = int(lb)
-        ub = int(ub)
+        start, stop, step = process_start_stop_step_length(start, stop, 1, length)
+        exponent = check_integer(exponent, "exponent")
 
-        if (cls, "power_ofs", exponent, lb, ub) in _cache:
-            return _cache[cls, "power_ofs", exponent, lb, ub]
+        if (cls, "power_ofs", exponent, start, stop) in _cache:
+            return _cache[cls, "power_ofs", exponent, start, stop]
         match exponent:
             case 0:
-                if lb <= 1 < ub:
+                if start <= 1 < stop:
                     result = [istr(1)]
                 else:
                     result = []
             case 1:
-                result = cls(list(range(lb, ub)))
-            case x if (x % 2 == 0 or lb >= 0) and ub <= 1_000_000:
-                result = in_range(cls._power_ofs_up_to_1_000_000(exponent), lb, ub)
+                result = cls(list(range(start, stop)))
+            case x if (x % 2 == 0 or start >= 0) and stop <= 1_000_000:
+                result = in_range(cls._power_ofs_up_to_1_000_000(exponent), start, stop)
             case _:
-                result = cls._power_ofs(exponent, lb, ub)
+                result = cls._power_ofs(exponent, start, stop)
         if cache:
-            _cache[cls, "power_ofs", exponent, lb, ub] = result
+            _cache[cls, "power_ofs", exponent, start, stop] = result
         return result
 
     @classmethod
@@ -728,27 +726,26 @@ class istr(str):
         "removesuffix replace rjust rpartition rsplit rstrip split strip swapcase title translate upper zfill"
     ).split():
         locals()[name] = functools.partialmethod(_str_method, name)
-        
+
     @classmethod
-    def zip(cls, *iterables, strict=False,join=False):
+    def zip(cls, *iterables, strict=False, join=False):
         if join:
-            return cls.concat(map(cls, zip(*iterables, strict=strict)))
+            return cls.concat(cls(zip(*iterables, strict=strict)))
         else:
-            return map(cls, zip(*iterables, strict=strict))
-        
+            return cls(zip(*iterables, strict=strict))
+
     @classmethod
-    def batched(cls,iterable, n, *, strict=False,join=False):
-        print("*** batched internal")
+    def batched(cls, iterable, n, *, strict=False, join=False):  # will be overridden if in itertools and not Python 3.12
         if n < 1:
-            raise ValueError('n must be at least one')
+            raise ValueError("n must be at least one")
         iterator = iter(iterable)
         while batch := tuple(itertools.islice(iterator, n)):
             if strict and len(batch) != n:
-                raise ValueError('batched(): incomplete batch')
+                raise ValueError("istr.batched(): incomplete batch")
             if join:
-                yield cls.join(istr(batch))
+                yield cls.join(cls(batch))
             else:
-                yield istr(batch)
+                yield cls(batch)
 
     @classmethod
     def _itertools_method(cls, name, *args, **kwargs):
@@ -764,9 +761,9 @@ class istr(str):
             match name:
                 case "groupby" | "tee":
                     locals()[name] = getattr(itertools, name)
-                case "permutations" | "combinations" | "combinations_with_replacement" | "product"|"batched"|"pairwise"|"zip_longest":
-                    if name=="batched" and sys.version_info[:2] == (3, 12):
-                        continue # version 3.12 does not support the strict parameter, so, we don't use the itertools method
+                case "permutations" | "combinations" | "combinations_with_replacement" | "product" | "batched" | "pairwise" | "zip_longest":
+                    if name == "batched" and sys.version_info[:2] == (3, 12):
+                        continue  # version 3.12 does not support the strict parameter, so, we don't use the itertools method
                     locals()[name] = functools.partialmethod(_itertools_join_method, name)
                 case _:
                     locals()[name] = functools.partialmethod(_itertools_method, name)
@@ -786,12 +783,12 @@ class istr(str):
         if iterable is None:
             return istr("").join(self)
         if not isinstance(self, str):
-            raise TypeError(f"{self!r} should be str, not {type(self)}")
+            raise TypeError(f"{self!r} should be istr, str or iterable, not {type(self)}")
         return istr(self).join(iterable)
 
     @classmethod
     def concat(cls, iterable):
-        return map(cls.join, cls(iterable))        
+        return map(cls.join, cls(iterable))
 
     def prod(self, *, start=1):
         return math.prod(self, start=istr(start))
@@ -831,8 +828,7 @@ class istr(str):
 
             cls._int_format = int_format
 
-        def __enter__(self):
-            ...
+        def __enter__(self): ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._int_format = self.saved_int_format
@@ -853,8 +849,7 @@ class istr(str):
             self.saved_cls = cls
             cls._repr_mode = mode
 
-        def __enter__(self):
-            ...
+        def __enter__(self): ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._repr_mode = self.saved_repr_mode
@@ -873,15 +868,14 @@ class istr(str):
             self.saved_cls = cls
             cls._base = base
 
-        def __enter__(self):
-            ...
+        def __enter__(self): ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._base = self.saved_base
 
     @classmethod
-    def range(cls, start, stop=None, step=1, base=None, int_format=None, repr_mode=None):
-        return _range(cls, start, stop, step, base=base, int_format=int_format, repr_mode=repr_mode)
+    def range(cls, start=None, stop=None, step=1, /, length=None, base=None, int_format=None, repr_mode=None):
+        return _range(cls, start, stop, step, length, base=base, int_format=int_format, repr_mode=repr_mode)
 
     @classmethod
     def digits(cls, *args):
@@ -991,7 +985,7 @@ def _map(func, *iterables, strict=False):
 _cache = {}
 
 
-def in_range(lst, lb, ub):
+def in_range(lst, start, stop):
     """
     this function will give all values of lst in the range [lb, ub)
 
@@ -1000,28 +994,60 @@ def in_range(lst, lb, ub):
     lst : list
         must be sorted!
 
-    lb : int (or istr)
+    start : int (or istr)
         lowerbound
 
-    ub : int (or istr)
+    stop : int (or istr)
         non inclusive upperbound
 
     Returns
     -------
-    list of all items in [lb, ub)
+    list of all items in [start, stop)
 
     Note
     ----
     Equivalent to
-    [item for item in lst if lb <= item < ub], but more efficient.
+    [item for item in lst if start <= item < stop], but more efficient.
     """
-    lb = int(lb)
-    ub = int(ub)
-    left = bisect.bisect_left(lst, lb)
-    right = bisect.bisect_left(lst, ub)
+    start = int(start)
+    stop = int(stop)
+    left = bisect.bisect_left(lst, start)
+    right = bisect.bisect_left(lst, stop)
     return lst[left:right]
 
 
+def check_integer(value, value_description):
+
+    if not isinstance(value, numbers.Number):
+        try:
+            return int(value)
+        except TypeError:
+            raise ValueError(f"{value_description} should be an integer, not {value}")
+
+    if value != int(value):
+        raise ValueError(f"{value_description} should be an integer, not {value}")
+    return int(value)
+
+
+def process_start_stop_step_length(start, stop, step, length):
+    if start is None and length is None:
+        raise ValueError("no bound(s) or length specified")
+    if length is not None:
+        if start is not None:
+            raise ValueError("both bound(s) and length specified")
+        length = check_integer(length, "length")
+        if length < 1:
+            raise ValueError(f"length must be >=1, not {length}")
+        start = 10 ** (length - 1)
+        stop = start * 10
+    else:
+        start, stop = (0, start) if stop is None else (start, stop)
+    start = check_integer(start, "start")
+    stop = check_integer(stop, "upperbound")
+    step = check_integer(step, "step")
+    return start, stop, step
+
+
 def get_namespace(namespace):
     if namespace is None:
         frame = real_caller_frame()
@@ -1056,4 +1082,3 @@ class istrModule(types.ModuleType):
 
 if __name__ != "__main__":
     sys.modules["istr"].__class__ = istrModule
-

{istr_python-1.1.32.post0 → istr_python-1.1.33}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.32.post0
+Version: 1.1.33
 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
@@ -367,7 +367,18 @@ to unpack multiple values, e.g.
 a, b, c = istr(5, 6, 7) ==> a=istr('5') , b=istr('6'), c=istr('7') 
 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
+
+`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`:
+
+`list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
+
 #### test for even/odd
+
 It is possible to test for even/odd (provided the istr can be interpreted as an int) with the `is_even` and `is_odd` method, e.g.
 
 ```
@@ -754,13 +765,17 @@ In contrast to `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter
 Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
 raises a ValueError. 
 
-#### get all squares, cubes, power ofs or primes in a given range
+#### get all squares, cubes, power ofs or primes in a given range or with a given length
 
 The class methods `istr.squares`, `istr.cubes`, `istr.power_ofs` and `istr.primes` can be used to get a list of all squares, cubes, power_ofs or primes up to a given upperbound (non inclusive) or between a given lower bound and upper bound (non inclusive), like:
 
 `istr.squares (100)` returns a list of all squares <100
 `istr.squares(50, 100)` returns a list of all squares in the range [50, 100)
 
+Alternatively, it is possible to get a list of all squares, cubes, power_ofs or primes with a given length, like:
+
+`istr.squares (length=2)` returns a list of all squares of length 2, so between 10 and 99.
+
 Unless `cache=False` is specified, the query result is cached.
 
 #### generate istr with digits

{istr_python-1.1.32.post0 → istr_python-1.1.33}/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.32.post0"
+version = "1.1.33"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = []

{istr_python-1.1.32.post0 → istr_python-1.1.33}/tests/test_istr.py

@@ -190,6 +190,12 @@ def test_range():
 
     assert str(list(istr.range(5, base=2, repr_mode="str"))) == "['0', '1', '10', '11', '100']"
 
+    assert list(istr.range(length=2)) == list(istr.range(10, 100))
+    with pytest.raises(ValueError, match=re.escape("length must be >=1, not 0")):
+        istr.range(length=0)
+    with pytest.raises(ValueError, match=re.escape("both bound(s) and length specified")):
+        istr.range(10, length=2)
+
 
 def test_misc():
     assert istr("") == ""
@@ -468,7 +474,7 @@ def test_is_power_of():
     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):
+    with pytest.raises(ValueError):
         istr(1).is_power_of(3.1)
     with pytest.raises(ValueError):
         istr(1).is_power_of(-1)
@@ -502,18 +508,33 @@ def test_primes():
     assert istr.primes(17) == [istr("2"), istr("3"), istr("5"), istr("7"), istr("11"), istr("13")]
     assert istr.primes(40, 50) == [istr("41"), istr("43"), istr("47")]
     assert id(istr.primes(100)) == id(istr.primes(100))  # test caching
+    assert istr.primes(length=2) == istr.primes(10, 100)
+    with pytest.raises(ValueError, match=re.escape("both bound(s) and length specified")):
+        istr.primes(12, length=2)
+    with pytest.raises(ValueError, match=re.escape("no bound(s) or length specified")):
+        istr.primes()
 
 
 def test_squares():
     assert istr.squares(50) == [istr("0"), istr("1"), istr("4"), istr("9"), istr("16"), istr("25"), istr("36"), istr("49")]
-    assert istr.squares(40, 50) == [istr("49")]
+    assert istr.squares(-27, 27) == [istr("0"), istr("1"), istr("4"), istr("9"), istr("16"), istr("25")]
     assert id(istr.squares(100)) == id(istr.squares(100))  # test caching
+    assert istr.squares(length=2) == istr.squares(10, 100)
+    with pytest.raises(ValueError, match=re.escape("both bound(s) and length specified")):
+        istr.squares(12, length=2)
+    with pytest.raises(ValueError, match=re.escape("no bound(s) or length specified")):
+        istr.squares()
 
 
 def test_cubes():
     assert istr.cubes(50) == [istr("0"), istr("1"), istr("8"), istr("27")]
-    assert istr.cubes(27, 50) == [istr("27")]
+    assert istr.cubes(-27, 27) == [istr("-27"), istr("-8"), istr("-1"), istr("0"), istr("1"), istr("8")]
     assert id(istr.cubes(100)) == id(istr.cubes(100))  # test caching
+    assert istr.cubes(length=2) == istr.cubes(10, 100)
+    with pytest.raises(ValueError, match=re.escape("both bound(s) and length specified")):
+        istr.cubes(12, length=2)
+    with pytest.raises(ValueError, match=re.escape("no bound(s) or length specified")):
+        istr.cubes()
 
 
 def test_power_ofs():
@@ -881,15 +902,17 @@ def test_digits_cache():
         assert id(d) == id(istr.digits())
     assert int(d) == 4886718345
 
+
 def test_zip():
-    assert list(istr.zip("12","34"))==[(istr("1"), istr("3")),(istr("2"), istr("4"))]
-    assert list(istr.zip("12","345"))==[(istr("1"), istr("3")),(istr("2"), istr("4"))]
-    assert list(istr.zip("12","34", join=True))==[istr("13"),istr("24")]
-    assert list(istr.zip("12","345", join=True))==[istr("13"),istr("24")]
+    assert list(istr.zip("12", "34")) == [(istr("1"), istr("3")), (istr("2"), istr("4"))]
+    assert list(istr.zip("12", "345")) == [(istr("1"), istr("3")), (istr("2"), istr("4"))]
+    assert list(istr.zip("12", "34", join=True)) == [istr("13"), istr("24")]
+    assert list(istr.zip("12", "345", join=True)) == [istr("13"), istr("24")]
     with pytest.raises(ValueError):
-        list(istr.zip("12","345",strict=True))
+        list(istr.zip("12", "345", strict=True))
     with pytest.raises(ValueError):
-        list(istr.zip("12","345",join=True,strict=True))
+        list(istr.zip("12", "345", join=True, strict=True))
+
 
 def test_itertools():
     def list100(it):
@@ -899,9 +922,11 @@ def test_itertools():
     assert list(istr.accumulate((1, 3, 4))) == [istr("1"), istr("4"), istr("8")]
     assert list(istr.chain(range(2), range(2, 5))) == [istr("0"), istr("1"), istr("2"), istr("3"), istr("4")]
     assert list(istr.combinations(range(5), r=3)) == list(istr(itertools.combinations(range(5), r=3)))
-    assert list(istr.combinations(range(5), r=3,join=True)) == list(map(istr.join,istr(itertools.combinations(range(5), r=3))) )   
+    assert list(istr.combinations(range(5), r=3, join=True)) == list(map(istr.join, istr(itertools.combinations(range(5), r=3))))
     assert list(istr.combinations_with_replacement(range(5), r=3)) == list(istr(itertools.combinations_with_replacement(range(5), r=3)))
-    assert list(istr.combinations_with_replacement(range(5), r=3,join=True)) == list(map(istr.join,istr(itertools.combinations_with_replacement(range(5), r=3))))
+    assert list(istr.combinations_with_replacement(range(5), r=3, join=True)) == list(
+        map(istr.join, istr(itertools.combinations_with_replacement(range(5), r=3)))
+    )
     assert list(istr.compress("123456", [1, 0, 1, 0, 1, 1])) == [istr("1"), istr("3"), istr("5"), istr("6")]
     assert list100(istr.count()) == list100(istr(itertools.count()))
     assert list100(istr.cycle(range(10))) == list100(istr(itertools.cycle(range(10))))
@@ -909,21 +934,22 @@ def test_itertools():
     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.permutations(range(5), 3)) == list(istr(itertools.permutations(range(5), 3)))
-    assert list(istr.permutations(range(5), 3, join=True)) == list(map(istr.join,istr(itertools.permutations(range(5), 3))))
+    assert list(istr.permutations(range(5), 3, join=True)) == list(map(istr.join, istr(itertools.permutations(range(5), 3))))
     assert list(istr.product(range(5), range(4))) == list(istr(itertools.product(range(5), range(4))))
-    assert list(istr.product(range(5), range(4),join=True)) == list(map(istr.join,istr(itertools.product(range(5), range(4)))) )   
+    assert list(istr.product(range(5), range(4), join=True)) == list(map(istr.join, 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"))]
-    assert list(istr.zip_longest("123", "56", fillvalue="0",join=True)) == [istr("15"),istr("26"), istr("30")]
+    assert list(istr.zip_longest("123", "56", fillvalue="0", join=True)) == [istr("15"), istr("26"), istr("30")]
     assert list(istr.pairwise("1234")) == [(istr("1"), istr("2")), (istr("2"), istr("3")), (istr("3"), istr("4"))]
-    assert list(istr.pairwise("1234",join=True)) == [istr("12"), istr("23"), istr("34")]
+    assert list(istr.pairwise("1234", join=True)) == [istr("12"), istr("23"), istr("34")]
     assert list(istr.batched("12345", n=2)) == [(istr("1"), istr("2")), (istr("3"), istr("4")), (istr("5"),)]
-    assert list(istr.batched("12345", n=2,join=True)) == [istr("12"), istr("34"), istr("5")]
-    assert list(istr.batched("1234", n=2,strict=True)) == [(istr("1"), istr("2")), (istr("3"), istr("4"))]
+    assert list(istr.batched("12345", n=2, join=True)) == [istr("12"), istr("34"), istr("5")]
+    assert list(istr.batched("1234", n=2, strict=True)) == [(istr("1"), istr("2")), (istr("3"), istr("4"))]
     with pytest.raises(ValueError):
-        list(istr.batched("12345", n=2,strict=True))
+        list(istr.batched("12345", n=2, strict=True))
+
 
 def test_all_distinct():
     assert istr("abcdef").all_distinct()
@@ -1033,7 +1059,7 @@ def test_tuple_join():
     assert istr.is_even(istr(1, 2))
     assert istr.is_divisible_by(istr(1, 2), 3)
     assert istr.is_triangular(istr(1, 0))
-    assert istr.is_consecutive(istr(1,2,3))
+    assert istr.is_consecutive(istr(1, 2, 3))
     assert istr.is_increasing(istr(1, 2))
     assert istr.is_non_decreasing(istr(1, 2, 2, 3))
     assert istr.is_decreasing(istr(2, 1))
@@ -1047,7 +1073,7 @@ def test_tuple_join():
     assert not istr.is_even(istr(1, 3))
     assert not istr.is_divisible_by(istr(1, 2), 5)
     assert not istr.is_triangular(istr(1, 1))
-    assert not istr.is_consecutive(istr(1,2,4))
+    assert not istr.is_consecutive(istr(1, 2, 4))
     assert not istr.is_increasing(istr(1, 1))
     assert not istr.is_non_decreasing(istr(1, 2, 2, 1))
     assert not istr.is_decreasing(istr(2, 2))