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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.6
+Version: 1.1.7
 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
@@ -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.7}/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.7}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.6"
+__version__ = "1.1.7"
 import functools
 import itertools
 import types
@@ -250,6 +250,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
@@ -384,13 +387,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):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.6
+Version: 1.1.7
 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
@@ -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.7}/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.6"
+version = "1.1.7"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = []

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

@@ -313,6 +313,15 @@ def test_even_odd():
     assert istr.is_even(12345678)
     assert istr.is_odd(11111111)
 
+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_is_square():
     assert not istr(-1).is_square()
@@ -544,7 +553,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():
     hundred = istr(100)
@@ -635,15 +649,7 @@ 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():
@@ -744,6 +750,8 @@ def test_decompose():
         istr(12).decompose("xyz")
     with pytest.raises(ValueError):
         istr(123).decompose("xy1")
+        
+
 
 
 def test_compose():