istr-python 1.1.27__tar.gz → 1.1.29__tar.gz

{istr_python-1.1.27 → istr_python-1.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.27
+Version: 1.1.29
 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
@@ -335,7 +335,7 @@ several other types:
   ```
     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  
+    istr({0, 1, 4}) ==> {istr('4'), istr('0'), istr('1')}  # or similar  
   ```
 
 - if a range, an istr.range instance will be returned
@@ -395,6 +395,20 @@ istr.is_palindrome('no devil lived on') ==> True
 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:
+```
+istr.is_increasing(123) ==> 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.
@@ -416,7 +430,7 @@ unless the *fallback* (last argument) is given, in which case *fallback* will be
 istr(18).divided_by(3) ==> 6 (actually istr("6"))
 istr(18).divided_by(istr(3)) ==> 6
 istr(19).divided_by(3) ==> None
-istr(19).divided_by(3, 0) ==> 
+istr(19).divided_by(3, 0) ==> 0
 istr(19).divided_by(3) ==> None
 istr(19).divided_by(istr(3)) ==> None
 istr.divided_by(18, 3) ==>  6
@@ -447,7 +461,7 @@ istr(28).is_cube()) ==> False
 It is also possible to test for cube of an ordinary int:
 ```
 istr.is_cube(27) ==> True
-istr.is_cube(28 ==> False
+istr.is_cube(28) ==> False
 ```
 
 #### test for power of
@@ -530,6 +544,7 @@ istr('0456')[::-1] ==> istr('6540')
 > It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
 >
 > ```
+> istr(-456).reversed() ==> istr('654-')
 > istr(-456).reversed() + 3 ==> TypeError
 > ```
 
@@ -723,7 +738,7 @@ To decompose an istr into individual variables, it is arguably easier and safer
 a, b, c = istr(485)
 ```
 
-With `istr.compose()`, an istr can be constructed from individual (global) variables and digits.
+With `istr.compose()`, an istr can be constructed from individual (global) variables and letters that can't be identifiers.
 E.g.
 
 ```
@@ -732,17 +747,19 @@ y = 9
 z = 6
 test1 = istr.compose("xyz")
 test2 = istr.compose("xyz0")
+test3 = istr.compose("(xyz)")
 ```
-Now, `test1` will be `istr(396)` and `test2` will be `istr(3960)`.
+Now, `test1` will be `istr(396)`, `test2` will be `istr(3960)` and `test3` will be `istr("(396)")`.
 
-Composing can also be done by prefixing a string with '=', like:
+Composing can also be done by prefixing a string with `=`, like:
 
 ```
 test1 = istr("=xyz")
 test2 = istr("=xyz0")
-
-Now, `test1` will be `istr(396)` and `test2` will be `istr(3960)`.
+test3 = istr("=(xyz)")
 ```
+Now, `test1` will be `istr(396)`, `test2` will be `istr(3960)` and `test3` will be `istr("(396)")`.
+
 Note that `str(istr("="))` is "=".
 
 Composing and assignment can be done by prefixing a string with ':=', like:
@@ -933,31 +950,32 @@ 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
-                     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')
-                                                    ...
+/                    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')
+                               istr('aAbBcC').islower() ==> False
+                               istr('  abc   ').strip() ==> istr('abc')
+                               ...
 -----------------------------------------------------------------------------------------
 *) str is applied if is_int() is False
 ```

{istr_python-1.1.27 → istr_python-1.1.29}/README.md

@@ -322,7 +322,7 @@ several other types:
   ```
     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  
+    istr({0, 1, 4}) ==> {istr('4'), istr('0'), istr('1')}  # or similar  
   ```
 
 - if a range, an istr.range instance will be returned
@@ -382,6 +382,20 @@ istr.is_palindrome('no devil lived on') ==> True
 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:
+```
+istr.is_increasing(123) ==> 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.
@@ -403,7 +417,7 @@ unless the *fallback* (last argument) is given, in which case *fallback* will be
 istr(18).divided_by(3) ==> 6 (actually istr("6"))
 istr(18).divided_by(istr(3)) ==> 6
 istr(19).divided_by(3) ==> None
-istr(19).divided_by(3, 0) ==> 
+istr(19).divided_by(3, 0) ==> 0
 istr(19).divided_by(3) ==> None
 istr(19).divided_by(istr(3)) ==> None
 istr.divided_by(18, 3) ==>  6
@@ -434,7 +448,7 @@ istr(28).is_cube()) ==> False
 It is also possible to test for cube of an ordinary int:
 ```
 istr.is_cube(27) ==> True
-istr.is_cube(28 ==> False
+istr.is_cube(28) ==> False
 ```
 
 #### test for power of
@@ -517,6 +531,7 @@ istr('0456')[::-1] ==> istr('6540')
 > It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
 >
 > ```
+> istr(-456).reversed() ==> istr('654-')
 > istr(-456).reversed() + 3 ==> TypeError
 > ```
 
@@ -710,7 +725,7 @@ To decompose an istr into individual variables, it is arguably easier and safer
 a, b, c = istr(485)
 ```
 
-With `istr.compose()`, an istr can be constructed from individual (global) variables and digits.
+With `istr.compose()`, an istr can be constructed from individual (global) variables and letters that can't be identifiers.
 E.g.
 
 ```
@@ -719,17 +734,19 @@ y = 9
 z = 6
 test1 = istr.compose("xyz")
 test2 = istr.compose("xyz0")
+test3 = istr.compose("(xyz)")
 ```
-Now, `test1` will be `istr(396)` and `test2` will be `istr(3960)`.
+Now, `test1` will be `istr(396)`, `test2` will be `istr(3960)` and `test3` will be `istr("(396)")`.
 
-Composing can also be done by prefixing a string with '=', like:
+Composing can also be done by prefixing a string with `=`, like:
 
 ```
 test1 = istr("=xyz")
 test2 = istr("=xyz0")
-
-Now, `test1` will be `istr(396)` and `test2` will be `istr(3960)`.
+test3 = istr("=(xyz)")
 ```
+Now, `test1` will be `istr(396)`, `test2` will be `istr(3960)` and `test3` will be `istr("(396)")`.
+
 Note that `str(istr("="))` is "=".
 
 Composing and assignment can be done by prefixing a string with ':=', like:
@@ -920,31 +937,32 @@ 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
-                     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')
-                                                    ...
+/                    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')
+                               istr('aAbBcC').islower() ==> False
+                               istr('  abc   ').strip() ==> istr('abc')
+                               ...
 -----------------------------------------------------------------------------------------
 *) str is applied if is_int() is False
 ```

{istr_python-1.1.27 → istr_python-1.1.29}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.27"
+__version__ = "1.1.29"
 import functools
 import itertools
 import types
@@ -407,6 +407,22 @@ class istr(str):
         self_as_str = str(self)
         return self_as_str == self_as_str[::-1]
 
+    def is_non_decreasing(self):
+        self_as_str = str(self)
+        return all(i0 <= i1 for i0, i1 in zip(self_as_str, self_as_str[1:]))
+
+    def is_non_increasing(self):
+        self_as_str = str(self)
+        return all(i0 >= i1 for i0, i1 in zip(self_as_str, self_as_str[1:]))
+
+    def is_increasing(self):
+        self_as_str = str(self)
+        return all(i0 < i1 for i0, i1 in zip(self_as_str, self_as_str[1:]))
+
+    def is_decreasing(self):
+        self_as_str = str(self)
+        return all(i0 > i1 for i0, i1 in zip(self_as_str, self_as_str[1:]))
+
     def is_divisible_by(self, divisor):
         return istr.divided_by(self, divisor) is not None
 
@@ -584,14 +600,16 @@ class istr(str):
         namespace = get_namespace(namespace)
 
         lookup = {}
+
+        if len(letters) != len(self):
+            raise ValueError(f"incorrect number of variables {len(letters)}; should be {len(self)}")
+
         for letter, ch in zip(letters, self):
             if letter in lookup and lookup[letter] != ch:
                 raise ValueError(f"multiple values found for variable {letter}")
             if not letter.isidentifier():
                 raise ValueError(f"{repr(letter)} cannot be used as a variable")
             lookup[str(letter)] = ch
-        if len(letters) != len(self):
-            raise ValueError(f"incorrect number of variables {len(letters)}; should be {len(self)}")
         namespace.update(lookup)
 
     @classmethod
@@ -599,13 +617,16 @@ class istr(str):
         """
         compose an istr from individual letter variables
         """
-        namespace = get_namespace(namespace) | {ch: ch for ch in "0123456789_"}
+        namespace = get_namespace(namespace)        
+        result=[]
         for letter in letters:
             if letter.isidentifier():
                 if letter not in namespace:
                     raise ValueError(f"variable {repr(letter)} not defined")
-        s = "".join(str(namespace[letter]) for letter in letters)
-        return cls(s)
+                result.append(str(namespace[letter]))
+            else:
+                result.append(letter)
+        return cls("".join(result))
 
     def __or__(self, other):
         if isinstance(other, str):
@@ -746,7 +767,8 @@ class istr(str):
 
             cls._int_format = int_format
 
-        def __enter__(self): ...
+        def __enter__(self):
+            ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._int_format = self.saved_int_format
@@ -767,7 +789,8 @@ class istr(str):
             self.saved_cls = cls
             cls._repr_mode = mode
 
-        def __enter__(self): ...
+        def __enter__(self):
+            ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._repr_mode = self.saved_repr_mode
@@ -786,7 +809,8 @@ class istr(str):
             self.saved_cls = cls
             cls._base = base
 
-        def __enter__(self): ...
+        def __enter__(self):
+            ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._base = self.saved_base
@@ -968,3 +992,4 @@ class istrModule(types.ModuleType):
 
 if __name__ != "__main__":
     sys.modules["istr"].__class__ = istrModule
+

{istr_python-1.1.27 → istr_python-1.1.29}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.27
+Version: 1.1.29
 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
@@ -335,7 +335,7 @@ several other types:
   ```
     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  
+    istr({0, 1, 4}) ==> {istr('4'), istr('0'), istr('1')}  # or similar  
   ```
 
 - if a range, an istr.range instance will be returned
@@ -395,6 +395,20 @@ istr.is_palindrome('no devil lived on') ==> True
 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:
+```
+istr.is_increasing(123) ==> 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.
@@ -416,7 +430,7 @@ unless the *fallback* (last argument) is given, in which case *fallback* will be
 istr(18).divided_by(3) ==> 6 (actually istr("6"))
 istr(18).divided_by(istr(3)) ==> 6
 istr(19).divided_by(3) ==> None
-istr(19).divided_by(3, 0) ==> 
+istr(19).divided_by(3, 0) ==> 0
 istr(19).divided_by(3) ==> None
 istr(19).divided_by(istr(3)) ==> None
 istr.divided_by(18, 3) ==>  6
@@ -447,7 +461,7 @@ istr(28).is_cube()) ==> False
 It is also possible to test for cube of an ordinary int:
 ```
 istr.is_cube(27) ==> True
-istr.is_cube(28 ==> False
+istr.is_cube(28) ==> False
 ```
 
 #### test for power of
@@ -530,6 +544,7 @@ istr('0456')[::-1] ==> istr('6540')
 > It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
 >
 > ```
+> istr(-456).reversed() ==> istr('654-')
 > istr(-456).reversed() + 3 ==> TypeError
 > ```
 
@@ -723,7 +738,7 @@ To decompose an istr into individual variables, it is arguably easier and safer
 a, b, c = istr(485)
 ```
 
-With `istr.compose()`, an istr can be constructed from individual (global) variables and digits.
+With `istr.compose()`, an istr can be constructed from individual (global) variables and letters that can't be identifiers.
 E.g.
 
 ```
@@ -732,17 +747,19 @@ y = 9
 z = 6
 test1 = istr.compose("xyz")
 test2 = istr.compose("xyz0")
+test3 = istr.compose("(xyz)")
 ```
-Now, `test1` will be `istr(396)` and `test2` will be `istr(3960)`.
+Now, `test1` will be `istr(396)`, `test2` will be `istr(3960)` and `test3` will be `istr("(396)")`.
 
-Composing can also be done by prefixing a string with '=', like:
+Composing can also be done by prefixing a string with `=`, like:
 
 ```
 test1 = istr("=xyz")
 test2 = istr("=xyz0")
-
-Now, `test1` will be `istr(396)` and `test2` will be `istr(3960)`.
+test3 = istr("=(xyz)")
 ```
+Now, `test1` will be `istr(396)`, `test2` will be `istr(3960)` and `test3` will be `istr("(396)")`.
+
 Note that `str(istr("="))` is "=".
 
 Composing and assignment can be done by prefixing a string with ':=', like:
@@ -933,31 +950,32 @@ 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
-                     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')
-                                                    ...
+/                    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')
+                               istr('aAbBcC').islower() ==> False
+                               istr('  abc   ').strip() ==> istr('abc')
+                               ...
 -----------------------------------------------------------------------------------------
 *) str is applied if is_int() is False
 ```

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

{istr_python-1.1.27 → istr_python-1.1.29}/tests/test_istr.py

@@ -256,24 +256,25 @@ def test_index():
 
 def test_str_count():
     assert istr("100").count("0") == 2
-    assert istr("100").count("0",0) ==2
-    assert istr("100").count("0",1)==2
-    assert istr("100").count("0",2)==1
-    assert istr("100").count("0",0,1)==0
-    assert istr("100").count(0)==2
-    assert istr("100").count(10)==1
-    assert istr("100").count(100)==1
-    assert istr("1000").count(100)==1
-    assert isinstance(istr("100").count(),map)  # this is in fact the itertools version
+    assert istr("100").count("0", 0) == 2
+    assert istr("100").count("0", 1) == 2
+    assert istr("100").count("0", 2) == 1
+    assert istr("100").count("0", 0, 1) == 0
+    assert istr("100").count(0) == 2
+    assert istr("100").count(10) == 1
+    assert istr("100").count(100) == 1
+    assert istr("1000").count(100) == 1
+    assert isinstance(istr("100").count(), map)  # this is in fact the itertools version
 
 
 def test_itertools_count():
-    assert list(itertools.islice(istr.count(),3))==[istr('0'), istr('1'), istr('2')]
-    assert list(istr.islice(istr.count(10),3)) ==[istr('10'), istr('11'), istr('12')]
-    assert list(istr.islice(istr.count(istr(10)),3)) ==[istr('10'), istr('11'), istr('12')]
-    assert list(istr.islice(istr.count(10,3),3))==[istr('10'), istr('13'), istr('16')]
+    assert list(itertools.islice(istr.count(), 3)) == [istr("0"), istr("1"), istr("2")]
+    assert list(istr.islice(istr.count(10), 3)) == [istr("10"), istr("11"), istr("12")]
+    assert list(istr.islice(istr.count(istr(10)), 3)) == [istr("10"), istr("11"), istr("12")]
+    assert list(istr.islice(istr.count(10, 3), 3)) == [istr("10"), istr("13"), istr("16")]
+
+    assert istr.count(istr(10), 1) == 1  # this is in fact the istr version
 
-    assert istr.count(istr(10),1)==1  # this is in fact the istr version
 
 def test_hash():
     assert hash(istr.range(1, 13)) == hash(one_to_twelve)
@@ -347,13 +348,40 @@ def test_even_odd():
 def test_is_palindrome():
     assert istr(121).is_palindrome()
     assert istr(1234321).is_palindrome()
-    assert not istr(123).is_palindrome()    
-    assert istr('aba').is_palindrome()        
-    assert not istr('abc').is_palindrome()             
-    assert istr('').is_palindrome()            
-    assert istr.is_palindrome('121')
-    assert istr.is_palindrome(121)    
-                    
+    assert not istr(123).is_palindrome()
+    assert istr("aba").is_palindrome()
+    assert not istr("abc").is_palindrome()
+    assert istr("").is_palindrome()
+    assert istr.is_palindrome("121")
+    assert istr.is_palindrome(121)
+
+
+def test_is_increasing_and_friends():
+    assert istr(123).is_increasing()
+    assert not istr(222).is_increasing()
+    assert not istr(321).is_increasing()
+
+    assert not istr(123).is_decreasing()
+    assert not istr(222).is_decreasing()
+    assert istr(321).is_decreasing()
+
+    assert istr(123).is_non_decreasing()
+    assert istr(222).is_non_decreasing()
+    assert not istr(321).is_non_decreasing()
+
+    assert not istr(123).is_non_increasing()
+    assert istr(222).is_non_increasing()
+    assert istr(321).is_non_increasing()
+
+    assert istr(1).is_increasing()
+    assert istr("").is_increasing()
+
+    assert not istr.is_increasing(222)
+    assert not istr.is_decreasing(222)
+    assert istr.is_non_decreasing(222)
+    assert istr.is_non_increasing(222)
+
+
 def test_is_divisible_by():
     assert istr(18).is_divisible_by(3)
     assert istr(18).is_divisible_by(istr(3))
@@ -375,9 +403,9 @@ def test_divided_by():
     assert istr.divided_by(18, 3).equals(istr(6))
     assert istr.divided_by(19, 3) is None
     assert istr.divided_by(18, 3, 0).equals(istr(6))
-    assert istr.divided_by(19, 3, 0)==0
-    assert istr.divided_by(4,0) is None
-    assert istr.divided_by(4,0,0) == 0
+    assert istr.divided_by(19, 3, 0) == 0
+    assert istr.divided_by(4, 0) is None
+    assert istr.divided_by(4, 0, 0) == 0
 
 
 def test_is_square():
@@ -426,7 +454,7 @@ def test_is_power_of():
     assert not istr(-1).is_power_of(4)
     assert istr(-1).is_power_of(5)
     assert istr(12345**3).is_power_of(3)
-    assert istr(-12345**3).is_power_of(3)
+    assert istr(-(12345**3)).is_power_of(3)
     assert istr(0).is_power_of(3)
     assert istr(1).is_power_of(3)
     assert not istr(2).is_power_of(3)
@@ -491,10 +519,10 @@ def test_cubes():
 def test_power_ofs():
     assert istr.power_ofs(0, 1, 5) == [istr("1")]
     assert istr.power_ofs(0, 1) == []
-    assert istr.power_ofs(1, -1, 5) == [istr("-1"),istr("0"), istr("1"), istr("2"), istr("3"), istr("4")]
+    assert istr.power_ofs(1, -1, 5) == [istr("-1"), istr("0"), istr("1"), istr("2"), istr("3"), istr("4")]
     assert istr.power_ofs(2, -10, 10) == [istr("0"), istr("1"), istr("4"), istr("9")]
-    assert istr.power_ofs(3, -10, 10) == [istr("-8"), istr("-1"), istr("0"), istr("1"),istr("8")]
-    assert istr.power_ofs(3, -10, 9) == [istr("-8"), istr("-1"), istr("0"), istr("1"),istr("8")]
+    assert istr.power_ofs(3, -10, 10) == [istr("-8"), istr("-1"), istr("0"), istr("1"), istr("8")]
+    assert istr.power_ofs(3, -10, 9) == [istr("-8"), istr("-1"), istr("0"), istr("1"), istr("8")]
     assert istr.power_ofs(3, -10, 8) == [istr("-8"), istr("-1"), istr("0"), istr("1")]
     assert istr.power_ofs(4, -10, 10) == [istr("0"), istr("1")]
     assert istr.power_ofs(2, 10, 0) == []
@@ -504,16 +532,18 @@ 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_in_range():
-    primes1000=istr.primes(1000)
-    n=len(primes1000)
-    assert len(primes1000)==n
-    assert istr.in_range(primes1000,0,5)==[istr('2'), istr('3')]
-    assert istr.in_range(primes1000,0,6)==[istr('2'), istr('3'),istr('5')]
-    assert istr.in_range(primes1000,3,6)==[istr('3'),istr('5')]
-    assert len(istr.in_range(primes1000,0,998))==n
-    assert len(istr.in_range(primes1000,0,997))==n-1
-    assert len(istr.in_range(primes1000,3,997))==n-2
+    primes1000 = istr.primes(1000)
+    n = len(primes1000)
+    assert len(primes1000) == n
+    assert istr.in_range(primes1000, 0, 5) == [istr("2"), istr("3")]
+    assert istr.in_range(primes1000, 0, 6) == [istr("2"), istr("3"), istr("5")]
+    assert istr.in_range(primes1000, 3, 6) == [istr("3"), istr("5")]
+    assert len(istr.in_range(primes1000, 0, 998)) == n
+    assert len(istr.in_range(primes1000, 0, 997)) == n - 1
+    assert len(istr.in_range(primes1000, 3, 997)) == n - 2
+
 
 def test_join():
     s = "".join(istr(("4", "5", "6")))
@@ -683,12 +713,12 @@ def test_edge_cases():
         istr()
     rng = istr.range(5)
     assert rng is istr(rng)
-    x = istr(5+6j)
-    assert x == '(5+6j)'
+    x = istr(5 + 6j)
+    assert x == "(5+6j)"
     assert not x.is_int()
     x = istr(min)
-    assert x == '<built-in function min>'
-    assert not x.is_int()    
+    assert x == "<built-in function min>"
+    assert not x.is_int()
 
 
 def test_unpacking():
@@ -925,8 +955,7 @@ def test_sumprod():
 
 
 def test_subclassing():
-    class jstr(istr.type):
-        ...
+    class jstr(istr.type): ...
 
     assert jstr(5).equals(jstr(5))
     assert repr(jstr(*range(3))) == "(jstr('0'), jstr('1'), jstr('2'))"
@@ -960,11 +989,10 @@ def test_decompose():
 
 
 def test_compose():
+    global x, y, z, _
     x = 1
     y = "2"
     z = istr(3)
-
-    assert istr.compose("xyz").equals(istr(123))
     with pytest.raises(ValueError):
         istr.compose("wxyz")  # w is not defined
     assert istr.compose("xyz", namespace=dict(x=3, y=istr(4), z="5")).equals(istr(345))
@@ -972,10 +1000,10 @@ def test_compose():
     assert istr("=xyz").equals(istr(123))
     assert istr("=xyz", "=x") == (istr(123), istr(1))
     assert istr("=") == "="
-    
-    assert istr('=09').equals(istr('09'))
-    assert istr('=x09z').equals(istr('1093'))
-    
+
+    assert istr("=09").equals(istr("09"))
+    assert istr("=x09z").equals(istr("1093"))
+
     assert istr(["=xyz", "=y"]) == [istr(123), istr(2)]
 
     assert istr(dict(xyz="=xyz", y="=y")) == {"xyz": istr(123), "y": istr(2)}
@@ -986,17 +1014,19 @@ def test_compose():
     assert istr(":=xyz").equals(istr(123))
     assert xyz.equals(istr(123))
 
-    assert istr(":=xyz_000").equals(istr('123_000'))
-    assert xyz_000.equals(istr('123_000'))
-    assert xyz_000==123000
-        
+    with pytest.raises(ValueError):
+        istr("=123_000")
+    _ = "_"
+    xyz_000 = istr("=123_000")
+    assert xyz_000.equals(istr("123_000"))
+    assert xyz_000 == 123000
+
     with pytest.raises(ValueError, match=re.escape(f"'0xyz' is not a valid identifier")):
-        istr(":=0xyz") 
-    
+        istr(":=0xyz")
+
     assert istr(":=") == ":="
     assert istr("=") == "="
 
 
 if __name__ == "__main__":
     pytest.main(["-vv", "-s", "-x", __file__])
-