istr-python 1.1.6__tar.gz → 1.1.8__tar.gz

{istr_python-1.1.6 → istr_python-1.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.6
+Version: 1.1.8
 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>
@@ -31,20 +31,33 @@ can be nicely, albeit not very efficient, coded as:
 import istr
 
 for s, e, n, d, m, o, r, y in istr.permutations(range(10), 8):
-    if m and ((s|e|n|d) + (m|o|r|e) == (m|o|n|e|y)):
+    if m and ((s|e|n|d) + (m|o|r|e) == (m|o|n|e|y):
         print(f' {s|e|n|d}')
         print(f' {m|o|r|e}')
         print('-----')
         print(f'{m|o|n|e|y}')
 ```
 
+or even
+
+```
+import istr
+
+for S, E, N, D, M, O, R, Y in istr.permutations(range(10), 8):
+    if m and (istr.compose("SEND") + ist.compose("MORE") == istr.compose("MONEY"):
+        print(" ",istr.compose("SEND"))
+        print(" ",istr.compose("MORE"))
+        print('-----')
+        print(istr.compose("MONEY"))
+```
+
 Of, if we want to add all the digits in a string:
 
 ```
 sum_digits = sum(istr('9282334'))  # answer 31
 ```
 
-And the module is a demonstration of extending a class (str) with extra and changed functionality.
+The module is a demonstration of extending a class (str) with additional and modified functionality.
 
 ### Installation
 Installing istr with pip is easy.
@@ -55,7 +68,7 @@ or when you want to upgrade,
 ```
 pip install istr-python --upgrade
 ```
-Alternatively, istr.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istr).
+Alternatively, istr.py can be just copied into your current work directory from GitHub (https://github.com/salabim/istr).
 
 No dependencies!
 
@@ -156,16 +169,16 @@ four, five = istr(4, 5)
 ```
 
 ##### Important
->All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
-> Also divisions are always floor divisions!
+>All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced, it will be converted to an int.
+> Also, divisions are always floor divisions!
 
 #### Use istr as a string
 
 We should realize that istrs are in fact strings.
 
-In order to concatenate two istrs (or an istr and a str), we cannot use the `+` operator (remember `four + five` is `istr('9')`).
+To concatenate two istrs (or an istr and a str), we cannot use the `+` operator (remember `four + five` is `istr('9')`).
 
-In order to concatenate istrs,  we use the or operator (`|`). So
+To concatenate strings, we use the or operator (`|`). So
 
 ```
 four | five
@@ -178,9 +191,9 @@ And
 ```
 is `istr('9')`.
 
-In order to repeat a string in the usual sense, you cannot use the `*` operator (remember `3 * four` is `istr('12')`. 
+To repeat a string in the usual sense, you cannot use the `*` operator (remember `3 * four` is `istr('12')`. 
 
-In order to repeat we use the matrix multiplication operator (`@`). So
+To  repeat, we use the matrix multiplication operator (`@`). So
 
  `3 @ four`
 
@@ -199,7 +212,7 @@ is also `istr('444')`
 #### istr that can't be interpreted as an int
 
 
-Although usualy istrs are to be interpreted as an int, that's not a requirement.
+Although usually istrs are to be interpreted as an int, that's not a requirement.
 
 So
 
@@ -215,7 +228,7 @@ istr('1,2,3')
 
 are perfectly acceptable.
 
-But, we can't do any arithmetic or comparison with them. 
+However, we cannot perform any arithmetic or comparison operations with them. 
 
 If we try
 
@@ -295,9 +308,9 @@ several other types:
 
 
 - if a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
-  ```
+```
   istr({'one': 1, 'two':2}) ==> {'one': istr('1'), 'two': istr('2')}
-  ```
+```
 
 - if an iterator, the iterator will be mapped with istr
   ```
@@ -313,11 +326,11 @@ several other types:
 
 - if an iterable, the same type will be returned with all elements istr'ed
 
-```
+  ```
     istr([0, 1, 4]) ==> [istr('0'), istr('1'), istr('4')]
     istr((0, 1, 4)) ==> (istr('0'), istr('1'), istr('4'))
     istr({0, 1, 4}) ==> `{istr('4'), istr('0'), istr('1')}  # or similar  
-```
+  ```
 
 - if a range, an istr.range instance will be returned
   
@@ -328,26 +341,25 @@ several other types:
 ```
 
 - if an istr.range instance, the same istr.range will be returned
-  ```
+```
   istr(istr.range(5)) ==> istr.range(5)
-  ```
+```
 
 
 - if an istr, the same istr will be returned
 
-  ```
-    istr(istr('4')) ==> istr ('4')
-  ```
+```
+  istr(istr('4')) ==> istr ('4')
+```
 
 #### More than one parameter for istr
 It is possible to give more than one parameter, in which case a tuple
 of the istrs of the parameters will be returned, which can be handy
 to unpack multiple values, e.g.
 
-```
+  ```
 a, b, c = istr(5, 6, 7) ==> a=istr('5') , b=istr('6'), c=istr('7') 
-```
-
+  ```
 #### 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.
 
@@ -360,6 +372,21 @@ It is also possible to test for even/odd of an ordinary int:
 istr.is_even(4) ==> True
 istr.is_odd(5) ==> True
 ```
+#### test for divisibility
+
+It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.
+
+```
+istr(18).is_divisible_by(3) ==> True
+istr(18).is_divisible_by(istr(3)) ==> True
+istr(19).is_divisible_by(3) ==> False
+istr(19).is_divisible_by(istr(3)) == False
+```
+It is also possible to test for divisibility of an ordinary int:
+```
+istr.is_divisible(18, 3) ==> True
+istr.is_divisible(19, 3) ==> False
+```
 #### 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.
@@ -415,21 +442,6 @@ It is also possible to test for prime of an ordinary int:
 istr.is_prime(4) ==> False
 istr.is_prime(5) ==> True
 ```
-#### test for divisibility
-
-It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.
-
-```
-istr(18).is_divisible_by(3) ==> True
-istr(18).is_divisible_by(istr(3)) ==> True
-istr(19).is_divisible_by(3) ==> False
-istr(19).is_divisible_by(istr(3)) == False
-```
-It is also possible to test for divisibility of an ordinary int:
-```
-istr.is_divisible(18, 3) ==> True
-istr.is_divisible(19, 3) ==> False
-```
 #### 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).
@@ -450,7 +462,7 @@ The method `reversed()` will return an istr with the reversed content:
 istr(456).reversed() ==> istr('654')
 istr('0456').reversed() ==> istr('6540')
 ```
-The same can -of course- be achieved with
+The same can, of course, be achieved with
 ```
 istr(456)[::-1] ==> istr('654')
 istr('0456')[::-1] ==> istr('6540')
@@ -597,6 +609,12 @@ istr(485).decompose("abc")
 will set the global variables `a`,  `b` and `c` to be set to `istr(4)`. `istr(8)` and` istr(5)`.
 Note that the length of the letters specifier must be the same as the length of the istr. Furthermore, multiple values for the same variables result in a ValueError.
 
+To decompose an istr into individual variables, it is arguably easier and safer to unpack the istr,  like
+
+```
+a, b, c = istr(485)
+```
+
 With `istr.compose()`, an istr can be constructed from individual (global) variables.
 E.g.
 
@@ -778,7 +796,7 @@ istr('1234')
 
 ### Overview of operations
 
-The table below shows whether the string or the int version of istr is applied.
+The table below indicates whether the string or integer version of istr is applied.
 
 ```
 operator/function   int  str   Example
@@ -786,31 +804,30 @@ 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')
-                     ==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
-                     bool                 x    x *) bool(istr(' 0 ')) ==> False | 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
-                     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')
+/                    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')
+==                   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
+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')
                                ...
 -----------------------------------------------------------------------------------------
 *) str is applied if is_int() is False
-
 ```
 ### Test script
 There's an extensive pytest script in the `\tests` directory.

{istr_python-1.1.6 → istr_python-1.1.8}/README.md

@@ -18,20 +18,33 @@ can be nicely, albeit not very efficient, coded as:
 import istr
 
 for s, e, n, d, m, o, r, y in istr.permutations(range(10), 8):
-    if m and ((s|e|n|d) + (m|o|r|e) == (m|o|n|e|y)):
+    if m and ((s|e|n|d) + (m|o|r|e) == (m|o|n|e|y):
         print(f' {s|e|n|d}')
         print(f' {m|o|r|e}')
         print('-----')
         print(f'{m|o|n|e|y}')
 ```
 
+or even
+
+```
+import istr
+
+for S, E, N, D, M, O, R, Y in istr.permutations(range(10), 8):
+    if m and (istr.compose("SEND") + ist.compose("MORE") == istr.compose("MONEY"):
+        print(" ",istr.compose("SEND"))
+        print(" ",istr.compose("MORE"))
+        print('-----')
+        print(istr.compose("MONEY"))
+```
+
 Of, if we want to add all the digits in a string:
 
 ```
 sum_digits = sum(istr('9282334'))  # answer 31
 ```
 
-And the module is a demonstration of extending a class (str) with extra and changed functionality.
+The module is a demonstration of extending a class (str) with additional and modified functionality.
 
 ### Installation
 Installing istr with pip is easy.
@@ -42,7 +55,7 @@ or when you want to upgrade,
 ```
 pip install istr-python --upgrade
 ```
-Alternatively, istr.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istr).
+Alternatively, istr.py can be just copied into your current work directory from GitHub (https://github.com/salabim/istr).
 
 No dependencies!
 
@@ -143,16 +156,16 @@ four, five = istr(4, 5)
 ```
 
 ##### Important
->All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
-> Also divisions are always floor divisions!
+>All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced, it will be converted to an int.
+> Also, divisions are always floor divisions!
 
 #### Use istr as a string
 
 We should realize that istrs are in fact strings.
 
-In order to concatenate two istrs (or an istr and a str), we cannot use the `+` operator (remember `four + five` is `istr('9')`).
+To concatenate two istrs (or an istr and a str), we cannot use the `+` operator (remember `four + five` is `istr('9')`).
 
-In order to concatenate istrs,  we use the or operator (`|`). So
+To concatenate strings, we use the or operator (`|`). So
 
 ```
 four | five
@@ -165,9 +178,9 @@ And
 ```
 is `istr('9')`.
 
-In order to repeat a string in the usual sense, you cannot use the `*` operator (remember `3 * four` is `istr('12')`. 
+To repeat a string in the usual sense, you cannot use the `*` operator (remember `3 * four` is `istr('12')`. 
 
-In order to repeat we use the matrix multiplication operator (`@`). So
+To  repeat, we use the matrix multiplication operator (`@`). So
 
  `3 @ four`
 
@@ -186,7 +199,7 @@ is also `istr('444')`
 #### istr that can't be interpreted as an int
 
 
-Although usualy istrs are to be interpreted as an int, that's not a requirement.
+Although usually istrs are to be interpreted as an int, that's not a requirement.
 
 So
 
@@ -202,7 +215,7 @@ istr('1,2,3')
 
 are perfectly acceptable.
 
-But, we can't do any arithmetic or comparison with them. 
+However, we cannot perform any arithmetic or comparison operations with them. 
 
 If we try
 
@@ -282,9 +295,9 @@ several other types:
 
 
 - if a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
-  ```
+```
   istr({'one': 1, 'two':2}) ==> {'one': istr('1'), 'two': istr('2')}
-  ```
+```
 
 - if an iterator, the iterator will be mapped with istr
   ```
@@ -300,11 +313,11 @@ several other types:
 
 - if an iterable, the same type will be returned with all elements istr'ed
 
-```
+  ```
     istr([0, 1, 4]) ==> [istr('0'), istr('1'), istr('4')]
     istr((0, 1, 4)) ==> (istr('0'), istr('1'), istr('4'))
     istr({0, 1, 4}) ==> `{istr('4'), istr('0'), istr('1')}  # or similar  
-```
+  ```
 
 - if a range, an istr.range instance will be returned
   
@@ -315,26 +328,25 @@ several other types:
 ```
 
 - if an istr.range instance, the same istr.range will be returned
-  ```
+```
   istr(istr.range(5)) ==> istr.range(5)
-  ```
+```
 
 
 - if an istr, the same istr will be returned
 
-  ```
-    istr(istr('4')) ==> istr ('4')
-  ```
+```
+  istr(istr('4')) ==> istr ('4')
+```
 
 #### More than one parameter for istr
 It is possible to give more than one parameter, in which case a tuple
 of the istrs of the parameters will be returned, which can be handy
 to unpack multiple values, e.g.
 
-```
+  ```
 a, b, c = istr(5, 6, 7) ==> a=istr('5') , b=istr('6'), c=istr('7') 
-```
-
+  ```
 #### 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.
 
@@ -347,6 +359,21 @@ It is also possible to test for even/odd of an ordinary int:
 istr.is_even(4) ==> True
 istr.is_odd(5) ==> True
 ```
+#### test for divisibility
+
+It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.
+
+```
+istr(18).is_divisible_by(3) ==> True
+istr(18).is_divisible_by(istr(3)) ==> True
+istr(19).is_divisible_by(3) ==> False
+istr(19).is_divisible_by(istr(3)) == False
+```
+It is also possible to test for divisibility of an ordinary int:
+```
+istr.is_divisible(18, 3) ==> True
+istr.is_divisible(19, 3) ==> False
+```
 #### 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.
@@ -402,21 +429,6 @@ It is also possible to test for prime of an ordinary int:
 istr.is_prime(4) ==> False
 istr.is_prime(5) ==> True
 ```
-#### test for divisibility
-
-It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.
-
-```
-istr(18).is_divisible_by(3) ==> True
-istr(18).is_divisible_by(istr(3)) ==> True
-istr(19).is_divisible_by(3) ==> False
-istr(19).is_divisible_by(istr(3)) == False
-```
-It is also possible to test for divisibility of an ordinary int:
-```
-istr.is_divisible(18, 3) ==> True
-istr.is_divisible(19, 3) ==> False
-```
 #### 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).
@@ -437,7 +449,7 @@ The method `reversed()` will return an istr with the reversed content:
 istr(456).reversed() ==> istr('654')
 istr('0456').reversed() ==> istr('6540')
 ```
-The same can -of course- be achieved with
+The same can, of course, be achieved with
 ```
 istr(456)[::-1] ==> istr('654')
 istr('0456')[::-1] ==> istr('6540')
@@ -584,6 +596,12 @@ istr(485).decompose("abc")
 will set the global variables `a`,  `b` and `c` to be set to `istr(4)`. `istr(8)` and` istr(5)`.
 Note that the length of the letters specifier must be the same as the length of the istr. Furthermore, multiple values for the same variables result in a ValueError.
 
+To decompose an istr into individual variables, it is arguably easier and safer to unpack the istr,  like
+
+```
+a, b, c = istr(485)
+```
+
 With `istr.compose()`, an istr can be constructed from individual (global) variables.
 E.g.
 
@@ -765,7 +783,7 @@ istr('1234')
 
 ### Overview of operations
 
-The table below shows whether the string or the int version of istr is applied.
+The table below indicates whether the string or integer version of istr is applied.
 
 ```
 operator/function   int  str   Example
@@ -773,31 +791,30 @@ 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')
-                     ==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
-                     bool                 x    x *) bool(istr(' 0 ')) ==> False | 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
-                     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')
+/                    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')
+==                   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
+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')
                                ...
 -----------------------------------------------------------------------------------------
 *) str is applied if is_int() is False
-
 ```
 ### Test script
 There's an extensive pytest script in the `\tests` directory.

{istr_python-1.1.6 → istr_python-1.1.8}/istr/istr.py

@@ -5,12 +5,14 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.6"
+__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):
@@ -250,6 +252,9 @@ class istr(str):
             if hasattr(value, "__next__"):
                 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))
         as_int = cls._to_int(value)
         if isinstance(value, str):
             as_str = value
@@ -346,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
@@ -384,13 +389,14 @@ class istr(str):
 
     def decompose(self, letters, namespace=None):
         """
-        decompose letter variables into local variables
-        each letter variable must represent just one character
-        same letter variables represent the the same character
+        decompose one-letter variables into global variables
+        each one-letter variable must represent just one character
+        same one-letter variables represent the the same character
         the istr must have the same length as the letters
         """
         if namespace is None:
             namespace = inspect.currentframe().f_back.f_globals
+
         lookup = {}
 
         for letter, ch in zip(letters, self):
@@ -485,6 +491,16 @@ class istr(str):
     def concat(cls, iterable):
         return map(lambda x: istr("").join(x), istr(iterable))
 
+    @classmethod
+    def prod(cls, iterable, *, start=1):
+        return math.prod(iterable, start=cls(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):
@@ -515,7 +531,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)
@@ -624,6 +640,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.6 → istr_python-1.1.8}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.6
+Version: 1.1.8
 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>
@@ -31,20 +31,33 @@ can be nicely, albeit not very efficient, coded as:
 import istr
 
 for s, e, n, d, m, o, r, y in istr.permutations(range(10), 8):
-    if m and ((s|e|n|d) + (m|o|r|e) == (m|o|n|e|y)):
+    if m and ((s|e|n|d) + (m|o|r|e) == (m|o|n|e|y):
         print(f' {s|e|n|d}')
         print(f' {m|o|r|e}')
         print('-----')
         print(f'{m|o|n|e|y}')
 ```
 
+or even
+
+```
+import istr
+
+for S, E, N, D, M, O, R, Y in istr.permutations(range(10), 8):
+    if m and (istr.compose("SEND") + ist.compose("MORE") == istr.compose("MONEY"):
+        print(" ",istr.compose("SEND"))
+        print(" ",istr.compose("MORE"))
+        print('-----')
+        print(istr.compose("MONEY"))
+```
+
 Of, if we want to add all the digits in a string:
 
 ```
 sum_digits = sum(istr('9282334'))  # answer 31
 ```
 
-And the module is a demonstration of extending a class (str) with extra and changed functionality.
+The module is a demonstration of extending a class (str) with additional and modified functionality.
 
 ### Installation
 Installing istr with pip is easy.
@@ -55,7 +68,7 @@ or when you want to upgrade,
 ```
 pip install istr-python --upgrade
 ```
-Alternatively, istr.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istr).
+Alternatively, istr.py can be just copied into your current work directory from GitHub (https://github.com/salabim/istr).
 
 No dependencies!
 
@@ -156,16 +169,16 @@ four, five = istr(4, 5)
 ```
 
 ##### Important
->All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
-> Also divisions are always floor divisions!
+>All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced, it will be converted to an int.
+> Also, divisions are always floor divisions!
 
 #### Use istr as a string
 
 We should realize that istrs are in fact strings.
 
-In order to concatenate two istrs (or an istr and a str), we cannot use the `+` operator (remember `four + five` is `istr('9')`).
+To concatenate two istrs (or an istr and a str), we cannot use the `+` operator (remember `four + five` is `istr('9')`).
 
-In order to concatenate istrs,  we use the or operator (`|`). So
+To concatenate strings, we use the or operator (`|`). So
 
 ```
 four | five
@@ -178,9 +191,9 @@ And
 ```
 is `istr('9')`.
 
-In order to repeat a string in the usual sense, you cannot use the `*` operator (remember `3 * four` is `istr('12')`. 
+To repeat a string in the usual sense, you cannot use the `*` operator (remember `3 * four` is `istr('12')`. 
 
-In order to repeat we use the matrix multiplication operator (`@`). So
+To  repeat, we use the matrix multiplication operator (`@`). So
 
  `3 @ four`
 
@@ -199,7 +212,7 @@ is also `istr('444')`
 #### istr that can't be interpreted as an int
 
 
-Although usualy istrs are to be interpreted as an int, that's not a requirement.
+Although usually istrs are to be interpreted as an int, that's not a requirement.
 
 So
 
@@ -215,7 +228,7 @@ istr('1,2,3')
 
 are perfectly acceptable.
 
-But, we can't do any arithmetic or comparison with them. 
+However, we cannot perform any arithmetic or comparison operations with them. 
 
 If we try
 
@@ -295,9 +308,9 @@ several other types:
 
 
 - if a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
-  ```
+```
   istr({'one': 1, 'two':2}) ==> {'one': istr('1'), 'two': istr('2')}
-  ```
+```
 
 - if an iterator, the iterator will be mapped with istr
   ```
@@ -313,11 +326,11 @@ several other types:
 
 - if an iterable, the same type will be returned with all elements istr'ed
 
-```
+  ```
     istr([0, 1, 4]) ==> [istr('0'), istr('1'), istr('4')]
     istr((0, 1, 4)) ==> (istr('0'), istr('1'), istr('4'))
     istr({0, 1, 4}) ==> `{istr('4'), istr('0'), istr('1')}  # or similar  
-```
+  ```
 
 - if a range, an istr.range instance will be returned
   
@@ -328,26 +341,25 @@ several other types:
 ```
 
 - if an istr.range instance, the same istr.range will be returned
-  ```
+```
   istr(istr.range(5)) ==> istr.range(5)
-  ```
+```
 
 
 - if an istr, the same istr will be returned
 
-  ```
-    istr(istr('4')) ==> istr ('4')
-  ```
+```
+  istr(istr('4')) ==> istr ('4')
+```
 
 #### More than one parameter for istr
 It is possible to give more than one parameter, in which case a tuple
 of the istrs of the parameters will be returned, which can be handy
 to unpack multiple values, e.g.
 
-```
+  ```
 a, b, c = istr(5, 6, 7) ==> a=istr('5') , b=istr('6'), c=istr('7') 
-```
-
+  ```
 #### 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.
 
@@ -360,6 +372,21 @@ It is also possible to test for even/odd of an ordinary int:
 istr.is_even(4) ==> True
 istr.is_odd(5) ==> True
 ```
+#### test for divisibility
+
+It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.
+
+```
+istr(18).is_divisible_by(3) ==> True
+istr(18).is_divisible_by(istr(3)) ==> True
+istr(19).is_divisible_by(3) ==> False
+istr(19).is_divisible_by(istr(3)) == False
+```
+It is also possible to test for divisibility of an ordinary int:
+```
+istr.is_divisible(18, 3) ==> True
+istr.is_divisible(19, 3) ==> False
+```
 #### 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.
@@ -415,21 +442,6 @@ It is also possible to test for prime of an ordinary int:
 istr.is_prime(4) ==> False
 istr.is_prime(5) ==> True
 ```
-#### test for divisibility
-
-It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.
-
-```
-istr(18).is_divisible_by(3) ==> True
-istr(18).is_divisible_by(istr(3)) ==> True
-istr(19).is_divisible_by(3) ==> False
-istr(19).is_divisible_by(istr(3)) == False
-```
-It is also possible to test for divisibility of an ordinary int:
-```
-istr.is_divisible(18, 3) ==> True
-istr.is_divisible(19, 3) ==> False
-```
 #### 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).
@@ -450,7 +462,7 @@ The method `reversed()` will return an istr with the reversed content:
 istr(456).reversed() ==> istr('654')
 istr('0456').reversed() ==> istr('6540')
 ```
-The same can -of course- be achieved with
+The same can, of course, be achieved with
 ```
 istr(456)[::-1] ==> istr('654')
 istr('0456')[::-1] ==> istr('6540')
@@ -597,6 +609,12 @@ istr(485).decompose("abc")
 will set the global variables `a`,  `b` and `c` to be set to `istr(4)`. `istr(8)` and` istr(5)`.
 Note that the length of the letters specifier must be the same as the length of the istr. Furthermore, multiple values for the same variables result in a ValueError.
 
+To decompose an istr into individual variables, it is arguably easier and safer to unpack the istr,  like
+
+```
+a, b, c = istr(485)
+```
+
 With `istr.compose()`, an istr can be constructed from individual (global) variables.
 E.g.
 
@@ -778,7 +796,7 @@ istr('1234')
 
 ### Overview of operations
 
-The table below shows whether the string or the int version of istr is applied.
+The table below indicates whether the string or integer version of istr is applied.
 
 ```
 operator/function   int  str   Example
@@ -786,31 +804,30 @@ 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')
-                     ==                   x    x    istr(20) == 20 ==> True | istr(20) == '20' ==> True
-                     bool                 x    x *) bool(istr(' 0 ')) ==> False | 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
-                     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')
+/                    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')
+==                   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
+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')
                                ...
 -----------------------------------------------------------------------------------------
 *) str is applied if is_int() is False
-
 ```
 ### Test script
 There's an extensive pytest script in the `\tests` directory.

{istr_python-1.1.6 → istr_python-1.1.8}/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.6"
+version = "1.1.8"
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 dependencies = []
 classifiers = [
     "Development Status :: 5 - Production/Stable",

{istr_python-1.1.6 → istr_python-1.1.8}/tests/test_istr.py

@@ -314,6 +314,17 @@ def test_even_odd():
     assert istr.is_odd(11111111)
 
 
+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)
+    assert not istr(19).is_divisible_by(istr(3))
+    with pytest.raises(TypeError, match=re.escape(f"not interpretable as int")):
+        istr("a").is_divisible_by(3)
+    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()
@@ -330,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()
@@ -357,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()
@@ -544,6 +557,12 @@ def test_unpacking():
     assert x.equals(istr(1))
     assert y.equals(istr(2))
     assert z.equals(istr(3))
+    del x, y, z
+
+    x, y, z = a
+    assert x.equals(istr(1))
+    assert y.equals(istr(2))
+    assert z == "3"
 
 
 def test_repr_mode():
@@ -635,17 +654,6 @@ def test_base():
         assert a * a == 225
 
 
-def test_is_divisible():
-    assert istr(18).is_divisible_by(3)
-    assert istr(18).is_divisible_by(istr(3))
-    assert not istr(19).is_divisible_by(3)
-    assert not istr(19).is_divisible_by(istr(3))
-    with pytest.raises(TypeError, match=re.escape(f"not interpretable as int")):
-        istr("a").is_divisible_by(3)
-    assert istr.is_divisible_by(18, 3)
-    assert not istr.is_divisible_by(19, 3)
-
-
 def test_digits():
     assert istr.digits().equals(istr("0123456789"))
     assert istr.digits("").equals(istr("0123456789"))
@@ -697,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():
@@ -712,6 +723,23 @@ 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))
+
+
+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): ...