istr-python 1.1.35__tar.gz → 1.1.36__tar.gz

{istr_python-1.1.35 → istr_python-1.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.35
+Version: 1.1.36
 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
@@ -312,6 +312,7 @@ is
 Apart from with numeric (to be interpreted as an int) or str, istr can be initialized with
 several other types:
 
+- if `None`, `None` will be returned.
 
 - if a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
 ```
@@ -377,6 +378,37 @@ In contrast to the builtin `range`, `istr.range` supports a non keyword paramete
 
 `list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
 
+#### 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.
+```
+istr(64).sqrt() ==> istr('8')
+istr(65).sqrt() ==> istr('0')
+istr(1234**3).cbrt() ==> istr('1234')
+istr(1234**3+1).cbrt() ==> istr('0')
+istr(1234**5).nth_root(5) ==> istr('1234')
+istr(1234**5+1).nth_root(5) ==> istr('0')
+istr(1234**5+1).nth_root(5, 1) ==> istr('1')
+istr(1234**5+1).nth_root(5, None) ==> None
+
+istr.sqrt(64) ==> istr('8')
+```
+
+#### integer division
+The method `divided_by` not only tests divisibility, but also returns the result of the division. If not possible, `istr('0')` will be returned, unless the *fallback* (last argument) is given, in which case *fallback* will be returned.
+
+The result will be always istr-ed, except for None.
+```
+istr(18).divided_by(3) ==> 6 (actually istr("6"))
+istr(18).divided_by(istr(3)) ==> 6
+istr(19).divided_by(3) ==> istr('0')
+istr(19).divided_by(3, 1) ==> istr('1')
+istr(19).divided_by(3) ==> istr('0')
+istr(19).divided_by(istr(3)) ==> istr('0')
+istr.divided_by(18, 3) ==>  6
+istr.divided_by(19, 3) ==>  istr('0')
+istr.divided_by(19, 3, 1) ==>  istr('1')
+```
+
 #### 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.
@@ -409,16 +441,16 @@ istr.is_palindrome(min) ==> False
 #### test for increasing, decreasing, non-decreasing and non-increasing
 
 It is possible to test whether the characters of an istr are increasing, decreasing, non-decreasing or non-increasing, like 
- ```
+```
 istr(1223).is_increasing() ==> False
 istr(1223).is_non_decreasing() ==> True
 istr(3221).is_decreasing() ==> False
 istr(3221).is_non_increasing ==> True
- ```
-It is also possible to test for 'increasingness' and friends for anything that can be converted to a str:
 ```
+It is also possible to test for 'increasingness' and friends for anything that can be converted to a str:
+ ```
 istr.is_increasing(123) ==> True  
-```
+ ```
 
 #### test for divisibility
 
@@ -435,20 +467,6 @@ 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, `istr('0')` will be returned, unless the *fallback* (last argument) is given, in which case *fallback* will be returned.
-
-The result will be always istr-ed, except for None.
-```
-istr(18).divided_by(3) ==> 6 (actually istr("6"))
-istr(18).divided_by(istr(3)) ==> 6
-istr(19).divided_by(3) ==> istr('0')
-istr(19).divided_by(3, 1) ==> istr('1')
-istr(19).divided_by(3) ==> istr('0')
-istr(19).divided_by(istr(3)) ==> istr('0')
-istr.divided_by(18, 3) ==>  6
-istr.divided_by(19, 3) ==>  istr('0')
-istr.divided_by(19, 3, 1) ==>  istr('1')
-```
 #### 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.
@@ -745,11 +763,11 @@ istr.count(10,3) ==> istr('10'), istr('13'), istr('16'), ...
 #### istr.zip
 
 The class method `istr.zip` is the equivalent of the zip builtin, but applies istr to each element. `istr.zip` also supports the join parameter:
-  ```
+```
   print(list(istr.zip('12', '345')))
   print(list(istr.zip('12', '345', join=True)))
   print(list(istr.zip('12', '345', strict=True)))
-  ```
+```
   results in
   ```
   [(istr('1'), istr('3')), (istr('2'), istr('4'))]
@@ -763,11 +781,11 @@ to `istr` and then concatenate these.
 
 `
 
-```
+  ```
 list(istr.concat(((1,2),(3,4))) ==> istr([12,34])
 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
 
@@ -1097,29 +1115,29 @@ operator/function   int  str   Example
 +                    x         istr(20) + 3 ==> istr('23')
 _                    x         istr(20) - 3 ==> istr('17')
 *                    x         istr(20) * 3 ==> istr('60')
-/                    x         istr(20) / 3 ==> istr('6')
-//                   x         istr(20) // 3 ==> istr('6')
-%                    x         istr(20) % 3 ==> istr('2')
-divmod               x         divmod(istr(20), 3) ==> (istr('6'), istr('2'))
-**                   x         istr(2) ** 3 ==> istr('8')
-<=, <, >, >=         x         istr('100') > istr('2') ==> True
-abs                  x         abs(istr(-20)) ==> istr('20')
-int                  x         int(istr("20")) ==> 20
-float                x         float(istr("20")) ==> 20.0
-complex              x         complex(istr("20")) ==> (20+0j)
-==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
-bool                 x    x *) bool(istr(' 0 ')) ==> False | bool(istr('')) ==> False
-@                         x    istr(20) @ 3 ==> istr('202020')
-|                         x    istr(20) | '5' ==> istr('205')
-slicing                   x    istr(12345)[1:3] ==> istr('23')
-iterate                   x    [x for x in istr(20)] ==> [istr('2'), istr('0')]
-len                       x    len(istr(' 20 ')) ==> 4
-count                     x    istr(100).count(0) ==> 2
+                     /                    x         istr(20) / 3 ==> istr('6')
+                     //                   x         istr(20) // 3 ==> istr('6')
+                     %                    x         istr(20) % 3 ==> istr('2')
+                     divmod               x         divmod(istr(20), 3) ==> (istr('6'), istr('2'))
+                     **                   x         istr(2) ** 3 ==> istr('8')
+                     <=, <, >, >=         x         istr('100') > istr('2') ==> True
+                     abs                  x         abs(istr(-20)) ==> istr('20')
+                     int                  x         int(istr("20")) ==> 20
+                     float                x         float(istr("20")) ==> 20.0
+                     complex              x         complex(istr("20")) ==> (20+0j)
+                     ==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
+                     bool                 x    x *) bool(istr(' 0 ')) ==> False | bool(istr('')) ==> False
+                     @                         x    istr(20) @ 3 ==> istr('202020')
+                     |                         x    istr(20) | '5' ==> istr('205')
+                     slicing                   x    istr(12345)[1:3] ==> istr('23')
+                     iterate                   x    [x for x in istr(20)] ==> [istr('2'), istr('0')]
+                     len                       x    len(istr(' 20 ')) ==> 4
+                     count                     x    istr(100).count(0) ==> 2
                                istr.count(100) ==> istr('100'), istr('101'). istr('102'), ...
-index                     x    istr(' 100 ').index('0') ==> 2
-split                     x    istr('1 2').split() ==> (istr('1'), istr('2'))
-string format             x    f"|{istr(1234):6}|" ==> '|1234  |'
-other string methods      x    istr('aAbBcC').lower() ==> istr('aabbcc')
+                     index                     x    istr(' 100 ').index('0') ==> 2
+                     split                     x    istr('1 2').split() ==> (istr('1'), istr('2'))
+                     string format             x    f"|{istr(1234):6}|" ==> '|1234  |'
+                     other string methods      x    istr('aAbBcC').lower() ==> istr('aabbcc')
                                istr('aAbBcC').islower() ==> False
                                istr('  abc   ').strip() ==> istr('abc')
                                ...

{istr_python-1.1.35 → istr_python-1.1.36}/README.md

@@ -299,6 +299,7 @@ is
 Apart from with numeric (to be interpreted as an int) or str, istr can be initialized with
 several other types:
 
+- if `None`, `None` will be returned.
 
 - if a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
 ```
@@ -364,6 +365,37 @@ In contrast to the builtin `range`, `istr.range` supports a non keyword paramete
 
 `list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
 
+#### 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.
+```
+istr(64).sqrt() ==> istr('8')
+istr(65).sqrt() ==> istr('0')
+istr(1234**3).cbrt() ==> istr('1234')
+istr(1234**3+1).cbrt() ==> istr('0')
+istr(1234**5).nth_root(5) ==> istr('1234')
+istr(1234**5+1).nth_root(5) ==> istr('0')
+istr(1234**5+1).nth_root(5, 1) ==> istr('1')
+istr(1234**5+1).nth_root(5, None) ==> None
+
+istr.sqrt(64) ==> istr('8')
+```
+
+#### integer division
+The method `divided_by` not only tests divisibility, but also returns the result of the division. If not possible, `istr('0')` will be returned, unless the *fallback* (last argument) is given, in which case *fallback* will be returned.
+
+The result will be always istr-ed, except for None.
+```
+istr(18).divided_by(3) ==> 6 (actually istr("6"))
+istr(18).divided_by(istr(3)) ==> 6
+istr(19).divided_by(3) ==> istr('0')
+istr(19).divided_by(3, 1) ==> istr('1')
+istr(19).divided_by(3) ==> istr('0')
+istr(19).divided_by(istr(3)) ==> istr('0')
+istr.divided_by(18, 3) ==>  6
+istr.divided_by(19, 3) ==>  istr('0')
+istr.divided_by(19, 3, 1) ==>  istr('1')
+```
+
 #### 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.
@@ -396,16 +428,16 @@ istr.is_palindrome(min) ==> False
 #### test for increasing, decreasing, non-decreasing and non-increasing
 
 It is possible to test whether the characters of an istr are increasing, decreasing, non-decreasing or non-increasing, like 
- ```
+```
 istr(1223).is_increasing() ==> False
 istr(1223).is_non_decreasing() ==> True
 istr(3221).is_decreasing() ==> False
 istr(3221).is_non_increasing ==> True
- ```
-It is also possible to test for 'increasingness' and friends for anything that can be converted to a str:
 ```
+It is also possible to test for 'increasingness' and friends for anything that can be converted to a str:
+ ```
 istr.is_increasing(123) ==> True  
-```
+ ```
 
 #### test for divisibility
 
@@ -422,20 +454,6 @@ 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, `istr('0')` will be returned, unless the *fallback* (last argument) is given, in which case *fallback* will be returned.
-
-The result will be always istr-ed, except for None.
-```
-istr(18).divided_by(3) ==> 6 (actually istr("6"))
-istr(18).divided_by(istr(3)) ==> 6
-istr(19).divided_by(3) ==> istr('0')
-istr(19).divided_by(3, 1) ==> istr('1')
-istr(19).divided_by(3) ==> istr('0')
-istr(19).divided_by(istr(3)) ==> istr('0')
-istr.divided_by(18, 3) ==>  6
-istr.divided_by(19, 3) ==>  istr('0')
-istr.divided_by(19, 3, 1) ==>  istr('1')
-```
 #### 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.
@@ -732,11 +750,11 @@ istr.count(10,3) ==> istr('10'), istr('13'), istr('16'), ...
 #### istr.zip
 
 The class method `istr.zip` is the equivalent of the zip builtin, but applies istr to each element. `istr.zip` also supports the join parameter:
-  ```
+```
   print(list(istr.zip('12', '345')))
   print(list(istr.zip('12', '345', join=True)))
   print(list(istr.zip('12', '345', strict=True)))
-  ```
+```
   results in
   ```
   [(istr('1'), istr('3')), (istr('2'), istr('4'))]
@@ -750,11 +768,11 @@ to `istr` and then concatenate these.
 
 `
 
-```
+  ```
 list(istr.concat(((1,2),(3,4))) ==> istr([12,34])
 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
 
@@ -1084,29 +1102,29 @@ operator/function   int  str   Example
 +                    x         istr(20) + 3 ==> istr('23')
 _                    x         istr(20) - 3 ==> istr('17')
 *                    x         istr(20) * 3 ==> istr('60')
-/                    x         istr(20) / 3 ==> istr('6')
-//                   x         istr(20) // 3 ==> istr('6')
-%                    x         istr(20) % 3 ==> istr('2')
-divmod               x         divmod(istr(20), 3) ==> (istr('6'), istr('2'))
-**                   x         istr(2) ** 3 ==> istr('8')
-<=, <, >, >=         x         istr('100') > istr('2') ==> True
-abs                  x         abs(istr(-20)) ==> istr('20')
-int                  x         int(istr("20")) ==> 20
-float                x         float(istr("20")) ==> 20.0
-complex              x         complex(istr("20")) ==> (20+0j)
-==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
-bool                 x    x *) bool(istr(' 0 ')) ==> False | bool(istr('')) ==> False
-@                         x    istr(20) @ 3 ==> istr('202020')
-|                         x    istr(20) | '5' ==> istr('205')
-slicing                   x    istr(12345)[1:3] ==> istr('23')
-iterate                   x    [x for x in istr(20)] ==> [istr('2'), istr('0')]
-len                       x    len(istr(' 20 ')) ==> 4
-count                     x    istr(100).count(0) ==> 2
+                     /                    x         istr(20) / 3 ==> istr('6')
+                     //                   x         istr(20) // 3 ==> istr('6')
+                     %                    x         istr(20) % 3 ==> istr('2')
+                     divmod               x         divmod(istr(20), 3) ==> (istr('6'), istr('2'))
+                     **                   x         istr(2) ** 3 ==> istr('8')
+                     <=, <, >, >=         x         istr('100') > istr('2') ==> True
+                     abs                  x         abs(istr(-20)) ==> istr('20')
+                     int                  x         int(istr("20")) ==> 20
+                     float                x         float(istr("20")) ==> 20.0
+                     complex              x         complex(istr("20")) ==> (20+0j)
+                     ==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
+                     bool                 x    x *) bool(istr(' 0 ')) ==> False | bool(istr('')) ==> False
+                     @                         x    istr(20) @ 3 ==> istr('202020')
+                     |                         x    istr(20) | '5' ==> istr('205')
+                     slicing                   x    istr(12345)[1:3] ==> istr('23')
+                     iterate                   x    [x for x in istr(20)] ==> [istr('2'), istr('0')]
+                     len                       x    len(istr(' 20 ')) ==> 4
+                     count                     x    istr(100).count(0) ==> 2
                                istr.count(100) ==> istr('100'), istr('101'). istr('102'), ...
-index                     x    istr(' 100 ').index('0') ==> 2
-split                     x    istr('1 2').split() ==> (istr('1'), istr('2'))
-string format             x    f"|{istr(1234):6}|" ==> '|1234  |'
-other string methods      x    istr('aAbBcC').lower() ==> istr('aabbcc')
+                     index                     x    istr(' 100 ').index('0') ==> 2
+                     split                     x    istr('1 2').split() ==> (istr('1'), istr('2'))
+                     string format             x    f"|{istr(1234):6}|" ==> '|1234  |'
+                     other string methods      x    istr('aAbBcC').lower() ==> istr('aabbcc')
                                istr('aAbBcC').islower() ==> False
                                istr('  abc   ').strip() ==> istr('abc')
                                ...

{istr_python-1.1.35 → istr_python-1.1.36}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.35"
+__version__ = "1.1.36"
 import functools
 import itertools
 import types
@@ -261,6 +261,8 @@ class istr(str):
             raise TypeError("no parameter given")
 
         match value:
+            case None:
+                return None
             case range():
                 return cls.range(value.start, value.stop, value.step, base=base, int_format=int_format, repr_mode=repr_mode)
             case _range():
@@ -430,23 +432,17 @@ class istr(str):
         if fallback is not None:
             fallback = istr(fallback)
         if divisor == 0:
-            if fallback is None:
-                return None
-            else:
-                return istr(fallback)
+            return istr(fallback)
         quotient, remainder = divmod(istr.interpret_as_int(self), int(divisor))
         if remainder == 0:
             return istr(quotient)
         else:
-            if fallback is None:
-                return None
-            else:
-                return istr(fallback)
+            return istr(fallback)
 
     def divisors(self, sorted=True):
         n = istr.interpret_as_int(self)
-        if n<=0:
-            raise ValueError(f'must be >=0, not {n}')
+        if n <= 0:
+            raise ValueError(f"must be >=0, not {n}")
         tail = []
         for d in range(1, math.isqrt(n) + 1):
             q, r = divmod(n, d)
@@ -460,6 +456,23 @@ class istr(str):
         if sorted:
             yield from reversed(tail)
 
+    def sqrt(self, fallback=0):
+        return istr.nth_root(self, 2, fallback)
+
+    def cbrt(self, fallback=0):
+        return istr.nth_root(self, 3, fallback)
+
+    def nth_root(self, nth, fallback=0):
+        n = istr.interpret_as_int(self)
+        if nth < 1 or int(nth) != nth:
+            raise ValueError(f"nth should be integer >=1, not {nth}")
+        if n < 0:
+            raise ValueError(f"value should be integer >=0, not {n}")
+        result = round(n ** (1 / nth))
+        if result**nth != n:
+            result = fallback
+        return istr(result)
+
     def is_prime(self):
         n = istr.interpret_as_int(self)
         if n < 1_000_000:
@@ -623,10 +636,7 @@ class istr(str):
         try:
             return istr(istr.interpret_as_str(self)[int(index)])
         except IndexError:
-            if fallback is None:
-                return fallback
-            else:
-                return istr(fallback)
+            return istr(fallback)
 
     def decompose(self, letters, namespace=None):
         """
@@ -1097,7 +1107,7 @@ def get_namespace(namespace):
 
 
 def real_caller_frame():
-    # this will return the frame of the first frame on the stack that does not belong to this module,
+    # this will return the first frame on the stack that does not belong to this module,
     # so in the 'user' space
     frame = inspect.currentframe()
     frame_name = frame.f_globals.get("__name__")

{istr_python-1.1.35 → istr_python-1.1.36}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.35
+Version: 1.1.36
 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
@@ -312,6 +312,7 @@ is
 Apart from with numeric (to be interpreted as an int) or str, istr can be initialized with
 several other types:
 
+- if `None`, `None` will be returned.
 
 - if a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
 ```
@@ -377,6 +378,37 @@ In contrast to the builtin `range`, `istr.range` supports a non keyword paramete
 
 `list(istr.range(length=3))` is equivalent to `istr.range(100, 1000)`
 
+#### 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.
+```
+istr(64).sqrt() ==> istr('8')
+istr(65).sqrt() ==> istr('0')
+istr(1234**3).cbrt() ==> istr('1234')
+istr(1234**3+1).cbrt() ==> istr('0')
+istr(1234**5).nth_root(5) ==> istr('1234')
+istr(1234**5+1).nth_root(5) ==> istr('0')
+istr(1234**5+1).nth_root(5, 1) ==> istr('1')
+istr(1234**5+1).nth_root(5, None) ==> None
+
+istr.sqrt(64) ==> istr('8')
+```
+
+#### integer division
+The method `divided_by` not only tests divisibility, but also returns the result of the division. If not possible, `istr('0')` will be returned, unless the *fallback* (last argument) is given, in which case *fallback* will be returned.
+
+The result will be always istr-ed, except for None.
+```
+istr(18).divided_by(3) ==> 6 (actually istr("6"))
+istr(18).divided_by(istr(3)) ==> 6
+istr(19).divided_by(3) ==> istr('0')
+istr(19).divided_by(3, 1) ==> istr('1')
+istr(19).divided_by(3) ==> istr('0')
+istr(19).divided_by(istr(3)) ==> istr('0')
+istr.divided_by(18, 3) ==>  6
+istr.divided_by(19, 3) ==>  istr('0')
+istr.divided_by(19, 3, 1) ==>  istr('1')
+```
+
 #### 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.
@@ -409,16 +441,16 @@ istr.is_palindrome(min) ==> False
 #### test for increasing, decreasing, non-decreasing and non-increasing
 
 It is possible to test whether the characters of an istr are increasing, decreasing, non-decreasing or non-increasing, like 
- ```
+```
 istr(1223).is_increasing() ==> False
 istr(1223).is_non_decreasing() ==> True
 istr(3221).is_decreasing() ==> False
 istr(3221).is_non_increasing ==> True
- ```
-It is also possible to test for 'increasingness' and friends for anything that can be converted to a str:
 ```
+It is also possible to test for 'increasingness' and friends for anything that can be converted to a str:
+ ```
 istr.is_increasing(123) ==> True  
-```
+ ```
 
 #### test for divisibility
 
@@ -435,20 +467,6 @@ 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, `istr('0')` will be returned, unless the *fallback* (last argument) is given, in which case *fallback* will be returned.
-
-The result will be always istr-ed, except for None.
-```
-istr(18).divided_by(3) ==> 6 (actually istr("6"))
-istr(18).divided_by(istr(3)) ==> 6
-istr(19).divided_by(3) ==> istr('0')
-istr(19).divided_by(3, 1) ==> istr('1')
-istr(19).divided_by(3) ==> istr('0')
-istr(19).divided_by(istr(3)) ==> istr('0')
-istr.divided_by(18, 3) ==>  6
-istr.divided_by(19, 3) ==>  istr('0')
-istr.divided_by(19, 3, 1) ==>  istr('1')
-```
 #### 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.
@@ -745,11 +763,11 @@ istr.count(10,3) ==> istr('10'), istr('13'), istr('16'), ...
 #### istr.zip
 
 The class method `istr.zip` is the equivalent of the zip builtin, but applies istr to each element. `istr.zip` also supports the join parameter:
-  ```
+```
   print(list(istr.zip('12', '345')))
   print(list(istr.zip('12', '345', join=True)))
   print(list(istr.zip('12', '345', strict=True)))
-  ```
+```
   results in
   ```
   [(istr('1'), istr('3')), (istr('2'), istr('4'))]
@@ -763,11 +781,11 @@ to `istr` and then concatenate these.
 
 `
 
-```
+  ```
 list(istr.concat(((1,2),(3,4))) ==> istr([12,34])
 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
 
@@ -1097,29 +1115,29 @@ operator/function   int  str   Example
 +                    x         istr(20) + 3 ==> istr('23')
 _                    x         istr(20) - 3 ==> istr('17')
 *                    x         istr(20) * 3 ==> istr('60')
-/                    x         istr(20) / 3 ==> istr('6')
-//                   x         istr(20) // 3 ==> istr('6')
-%                    x         istr(20) % 3 ==> istr('2')
-divmod               x         divmod(istr(20), 3) ==> (istr('6'), istr('2'))
-**                   x         istr(2) ** 3 ==> istr('8')
-<=, <, >, >=         x         istr('100') > istr('2') ==> True
-abs                  x         abs(istr(-20)) ==> istr('20')
-int                  x         int(istr("20")) ==> 20
-float                x         float(istr("20")) ==> 20.0
-complex              x         complex(istr("20")) ==> (20+0j)
-==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
-bool                 x    x *) bool(istr(' 0 ')) ==> False | bool(istr('')) ==> False
-@                         x    istr(20) @ 3 ==> istr('202020')
-|                         x    istr(20) | '5' ==> istr('205')
-slicing                   x    istr(12345)[1:3] ==> istr('23')
-iterate                   x    [x for x in istr(20)] ==> [istr('2'), istr('0')]
-len                       x    len(istr(' 20 ')) ==> 4
-count                     x    istr(100).count(0) ==> 2
+                     /                    x         istr(20) / 3 ==> istr('6')
+                     //                   x         istr(20) // 3 ==> istr('6')
+                     %                    x         istr(20) % 3 ==> istr('2')
+                     divmod               x         divmod(istr(20), 3) ==> (istr('6'), istr('2'))
+                     **                   x         istr(2) ** 3 ==> istr('8')
+                     <=, <, >, >=         x         istr('100') > istr('2') ==> True
+                     abs                  x         abs(istr(-20)) ==> istr('20')
+                     int                  x         int(istr("20")) ==> 20
+                     float                x         float(istr("20")) ==> 20.0
+                     complex              x         complex(istr("20")) ==> (20+0j)
+                     ==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
+                     bool                 x    x *) bool(istr(' 0 ')) ==> False | bool(istr('')) ==> False
+                     @                         x    istr(20) @ 3 ==> istr('202020')
+                     |                         x    istr(20) | '5' ==> istr('205')
+                     slicing                   x    istr(12345)[1:3] ==> istr('23')
+                     iterate                   x    [x for x in istr(20)] ==> [istr('2'), istr('0')]
+                     len                       x    len(istr(' 20 ')) ==> 4
+                     count                     x    istr(100).count(0) ==> 2
                                istr.count(100) ==> istr('100'), istr('101'). istr('102'), ...
-index                     x    istr(' 100 ').index('0') ==> 2
-split                     x    istr('1 2').split() ==> (istr('1'), istr('2'))
-string format             x    f"|{istr(1234):6}|" ==> '|1234  |'
-other string methods      x    istr('aAbBcC').lower() ==> istr('aabbcc')
+                     index                     x    istr(' 100 ').index('0') ==> 2
+                     split                     x    istr('1 2').split() ==> (istr('1'), istr('2'))
+                     string format             x    f"|{istr(1234):6}|" ==> '|1234  |'
+                     other string methods      x    istr('aAbBcC').lower() ==> istr('aabbcc')
                                istr('aAbBcC').islower() ==> False
                                istr('  abc   ').strip() ==> istr('abc')
                                ...

{istr_python-1.1.35 → istr_python-1.1.36}/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.35"
+version = "1.1.36"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = []

{istr_python-1.1.35 → istr_python-1.1.36}/tests/test_istr.py

@@ -218,6 +218,9 @@ def test_divmod():
 def test_iter():
     assert [x for x in istr.range(3)] == [istr(0), istr(1), istr(2)]
 
+def test_none():
+    assert istr(None) is None
+
 
 def test_reversed():
     assert [x for x in reversed(istr.range(3))] == [istr(2), istr(1), istr(0)]
@@ -410,6 +413,56 @@ def test_getitem():
     assert istr.getitem(b, 6).equals(istr(""))
 
 
+def test_nth_power():
+    assert istr(1234).nth_root(1).equals(istr(1234))
+    assert istr(1234**5).nth_root(5).equals(istr(1234))
+    assert istr(1234**5 + 1).nth_root(5).equals(istr(0))
+    assert istr(1234**5 + 1).nth_root(5, 1).equals(istr(1))
+    assert istr(1234**5 + 1).nth_root(5, None) is None
+
+    assert istr.nth_root(1234**5, 5).equals(istr(1234))
+    assert istr.nth_root(1234**5 + 1, 5).equals(istr(0))
+    assert istr.nth_root(1234**5 + 1, 5, 1).equals(istr(1))
+    assert istr.nth_root(1234**5 + 1, 5, None) is None
+
+    with pytest.raises(ValueError):
+        istr(1234).nth_root(0)
+    with pytest.raises(ValueError):
+        istr(1234).nth_root(1.5)
+    with pytest.raises(ValueError):
+        istr(-(1234**5)).nth_root(5)
+
+
+def test_sqrt():
+    assert istr(1234**2).sqrt().equals(istr(1234))
+    assert istr(1234**2 + 1).sqrt().equals(istr(0))
+    assert istr(1234**2 + 1).sqrt(1).equals(istr(1))
+    assert istr(1234**2 + 1).sqrt(None) is None
+
+    assert istr.sqrt(1234**2).equals(istr(1234))
+    assert istr.sqrt(1234**2 + 1).equals(istr(0))
+    assert istr.sqrt(1234**2 + 1, 1).equals(istr(1))
+    assert istr.sqrt(1232**2 + 1, None) is None
+
+    with pytest.raises(ValueError):
+        istr(-125).sqrt()
+
+
+def test_cbrt():
+    assert istr(1234**3).cbrt().equals(istr(1234))
+    assert istr(1234**3 + 1).cbrt().equals(istr(0))
+    assert istr(1234**3 + 1).cbrt(1).equals(istr(1))
+    assert istr(1234**3 + 1).cbrt(None) is None
+
+    assert istr.cbrt(1234**3).equals(istr(1234))
+    assert istr.cbrt(1234**3 + 1).equals(istr(0))
+    assert istr.cbrt(1234**3 + 1, 1).equals(istr(1))
+    assert istr.cbrt(1232**3 + 1, None) is None
+
+    with pytest.raises(ValueError):
+        istr(-125).cbrt()
+
+
 def test_is_divisible_by():
     assert istr(18).is_divisible_by(3)
     assert istr(18).is_divisible_by(istr(3))
@@ -506,12 +559,14 @@ def test_is_power_of():
     assert istr(10).is_power_of(1)
     assert istr(-8).is_power_of(3)
 
+
 def test_is_power_of_no_arg():
     assert istr(2**10).is_power_of()
-    assert not istr(2**10+1).is_power_of()    
-    assert istr(1).is_power_of()    
-    assert istr((-5)**3).is_power_of()    
-    
+    assert not istr(2**10 + 1).is_power_of()
+    assert istr(1).is_power_of()
+    assert istr((-5) ** 3).is_power_of()
+
+
 def test_is_prime():
     assert not istr(0).is_prime()
     assert not istr(1).is_prime()
@@ -582,19 +637,21 @@ def test_power_ofs():
     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_divisors():
-    assert list(istr(36).divisors())==istr([1,2,3,4,6,9,12,18,36])
-    assert list(istr(36).divisors(sorted=False))==istr([1,36,2,18,3,12,4,9,6])    
-    assert list(istr(37).divisors())==istr([1,37])
-    assert list(istr(1).divisors())==istr([1])    
-    with pytest.raises(ValueError,match=re.escape("must be >=0, not 0")):
+    assert list(istr(36).divisors()) == istr([1, 2, 3, 4, 6, 9, 12, 18, 36])
+    assert list(istr(36).divisors(sorted=False)) == istr([1, 36, 2, 18, 3, 12, 4, 9, 6])
+    assert list(istr(37).divisors()) == istr([1, 37])
+    assert list(istr(1).divisors()) == istr([1])
+    with pytest.raises(ValueError, match=re.escape("must be >=0, not 0")):
         list(istr(0).divisors())
-    with pytest.raises(ValueError,match=re.escape("must be >=0, not -1")):
+    with pytest.raises(ValueError, match=re.escape("must be >=0, not -1")):
         list(istr(-1).divisors())
-    assert list(istr.divisors(36))==istr([1,2,3,4,6,9,12,18,36])
-    assert list(istr.divisors(36,False))==istr([1,36,2,18,3,12,4,9,6])    
-    assert list(istr.divisors(37))==istr([1,37])                
-        
+    assert list(istr.divisors(36)) == istr([1, 2, 3, 4, 6, 9, 12, 18, 36])
+    assert list(istr.divisors(36, False)) == istr([1, 36, 2, 18, 3, 12, 4, 9, 6])
+    assert list(istr.divisors(37)) == istr([1, 37])
+
+
 def test_in_range():
     primes1000 = istr.primes(1000)
     n = len(primes1000)