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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.29
+Version: 1.1.31
 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
@@ -548,6 +548,46 @@ istr('0456')[::-1] ==> istr('6540')
 > istr(-456).reversed() + 3 ==> TypeError
 > ```
 
+
+#### ceil
+
+The `istr.ceil` method can be used to find the smallest integer, divisible by a given number (divisible_by), greater than or equal to the value.
+This can be useful to step through all multiples of n, >= m, like:
+
+```
+for i in istr.range(istr(1000/3, 10000, 3)) ==> # 1002, 1005, ... 9999
+for i in istr.count(int(istr,ceil(1000/3)), 3))  ==> 1002, 1005, ...
+```
+Examples:
+```
+istr(1000).ceil() ==> 1000 # divisible_by is 1 by default
+istr(1000).ceil(2) ==> 1000
+istr(1000).ceil(3) ==> 1002
+```
+It is also possible to use the ceil method for floats or ints:
+```
+istr.ceil(1000.2) ==> 1001
+istr.ceil(1000.2, 2)  ==> 1002
+istr.ceil(1000.2, 3 ==> 1002
+```
+
+#### floor
+
+The `istr.floor` method can be used to find the largest integer, divisible by a given number (divisible_by), smaller than or equal to the value.
+
+Examples:
+```
+istr(1000).floor() ==> 1000 # divisible_by is 1 by default
+istr(1000).floor(2) ==> 1000
+istr(1000).floor(3) ==> 999
+```
+It is also possible to use the ceil method for floats or ints:
+```
+istr.floor(1000.2) ==> 1000
+istr.floor(1000.2, 2)  ==> 1000
+istr.floor(1000.2, 3 ==> 999
+```
+
 #### enumerate with istrs
 
 The `istr.enumerate` class method can be used just as the built-in enumerate function.

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

@@ -535,6 +535,46 @@ istr('0456')[::-1] ==> istr('6540')
 > istr(-456).reversed() + 3 ==> TypeError
 > ```
 
+
+#### ceil
+
+The `istr.ceil` method can be used to find the smallest integer, divisible by a given number (divisible_by), greater than or equal to the value.
+This can be useful to step through all multiples of n, >= m, like:
+
+```
+for i in istr.range(istr(1000/3, 10000, 3)) ==> # 1002, 1005, ... 9999
+for i in istr.count(int(istr,ceil(1000/3)), 3))  ==> 1002, 1005, ...
+```
+Examples:
+```
+istr(1000).ceil() ==> 1000 # divisible_by is 1 by default
+istr(1000).ceil(2) ==> 1000
+istr(1000).ceil(3) ==> 1002
+```
+It is also possible to use the ceil method for floats or ints:
+```
+istr.ceil(1000.2) ==> 1001
+istr.ceil(1000.2, 2)  ==> 1002
+istr.ceil(1000.2, 3 ==> 1002
+```
+
+#### floor
+
+The `istr.floor` method can be used to find the largest integer, divisible by a given number (divisible_by), smaller than or equal to the value.
+
+Examples:
+```
+istr(1000).floor() ==> 1000 # divisible_by is 1 by default
+istr(1000).floor(2) ==> 1000
+istr(1000).floor(3) ==> 999
+```
+It is also possible to use the ceil method for floats or ints:
+```
+istr.floor(1000.2) ==> 1000
+istr.floor(1000.2, 2)  ==> 1000
+istr.floor(1000.2, 3 ==> 999
+```
+
 #### enumerate with istrs
 
 The `istr.enumerate` class method can be used just as the built-in enumerate function.

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

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.29"
+__version__ = "1.1.31"
 import functools
 import itertools
 import types
@@ -15,7 +15,7 @@ import math
 import operator
 import copy
 import bisect
-
+import collections
 """
 Note: the changelog is in changelog.md
 
@@ -404,23 +404,23 @@ class istr(str):
         return not istr.is_divisible_by(self, 2)
 
     def is_palindrome(self):
-        self_as_str = str(self)
+        self_as_str = istr.interpret_as_str(self)
         return self_as_str == self_as_str[::-1]
 
     def is_non_decreasing(self):
-        self_as_str = str(self)
+        self_as_str = istr.interpret_as_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)
+        self_as_str = istr.interpret_as_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)
+        self_as_str = istr.interpret_as_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)
+        self_as_str = istr.interpret_as_str(self)
         return all(i0 > i1 for i0, i1 in zip(self_as_str, self_as_str[1:]))
 
     def is_divisible_by(self, divisor):
@@ -677,15 +677,50 @@ class istr(str):
 
     def reversed(self):
         return self[::-1]
+    
+    def ceil(self, divisible_by=1):
+        if divisible_by<=0:
+            raise ValueError(f"step has to be >0, not {divisible_by}")
+        if divisible_by!=int(divisible_by):
+            raise ValueError(f"step has to be an integer value, not {divisible_by}")
+        n = istr.interpret_as_float(self)
+        return istr((math.ceil(n/divisible_by))*divisible_by)
+
+    def floor(self, divisible_by=1):
+        if divisible_by<=0:
+            raise ValueError(f"step has to be >0, not {divisible_by}")
+        if divisible_by!=int(divisible_by):
+            raise ValueError(f"step has to be an integer value, not {divisible_by}")
+        return istr((math.floor(self/divisible_by))*divisible_by)
+
 
     def interpret_as_int(self):
         if isinstance(self, istr):
             if not self.is_int():
                 raise TypeError(f"not interpretable as int: {self._frepr(self)}")
-            n = self._as_int
-        else:
-            n = int(self)
-        return n
+            return self._as_int
+        if isinstance(self, collections.abc.Iterable) and not isinstance(self,str):
+            return int(istr.join(self))
+        
+        return int(self)
+
+
+    def interpret_as_float(self):
+        if isinstance(self, istr):
+            if not self.is_int():
+                raise TypeError(f"not interpretable as float: {self._frepr(self)}")
+            return self._as_int
+        if isinstance(self, collections.abc.Iterable) and not isinstance(self,str):
+            return float(istr.join(self))
+        
+        return float(self)
+
+    def interpret_as_str(self):
+
+        if isinstance(self, collections.abc.Iterable) and not isinstance(self,str):
+            return istr.join(self)
+        
+        return str(self)
 
     def _str_method(self, name, *args, **kwargs):
         return self.__class__(getattr(super(), name)(*args, **kwargs))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.29
+Version: 1.1.31
 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
@@ -548,6 +548,46 @@ istr('0456')[::-1] ==> istr('6540')
 > istr(-456).reversed() + 3 ==> TypeError
 > ```
 
+
+#### ceil
+
+The `istr.ceil` method can be used to find the smallest integer, divisible by a given number (divisible_by), greater than or equal to the value.
+This can be useful to step through all multiples of n, >= m, like:
+
+```
+for i in istr.range(istr(1000/3, 10000, 3)) ==> # 1002, 1005, ... 9999
+for i in istr.count(int(istr,ceil(1000/3)), 3))  ==> 1002, 1005, ...
+```
+Examples:
+```
+istr(1000).ceil() ==> 1000 # divisible_by is 1 by default
+istr(1000).ceil(2) ==> 1000
+istr(1000).ceil(3) ==> 1002
+```
+It is also possible to use the ceil method for floats or ints:
+```
+istr.ceil(1000.2) ==> 1001
+istr.ceil(1000.2, 2)  ==> 1002
+istr.ceil(1000.2, 3 ==> 1002
+```
+
+#### floor
+
+The `istr.floor` method can be used to find the largest integer, divisible by a given number (divisible_by), smaller than or equal to the value.
+
+Examples:
+```
+istr(1000).floor() ==> 1000 # divisible_by is 1 by default
+istr(1000).floor(2) ==> 1000
+istr(1000).floor(3) ==> 999
+```
+It is also possible to use the ceil method for floats or ints:
+```
+istr.floor(1000.2) ==> 1000
+istr.floor(1000.2, 2)  ==> 1000
+istr.floor(1000.2, 3 ==> 999
+```
+
 #### enumerate with istrs
 
 The `istr.enumerate` class method can be used just as the built-in enumerate function.

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

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

@@ -988,6 +988,52 @@ def test_decompose():
         istr(123).decompose("xy1")
 
 
+def test_ceil():
+    assert istr(1000).ceil() == 1000
+    assert istr(1000).ceil(1) == 1000
+    assert istr(1000).ceil(2) == 1000
+    assert istr(1000).ceil(3) == 1002
+    assert istr.ceil(1000) == 1000
+    assert istr.ceil(1000, 1) == 1000
+    assert istr.ceil(1000.2, 1).equals(istr(1001))
+
+
+def test_floor():
+    assert istr(1000).floor() == 1000
+    assert istr(1000).floor(1) == 1000
+    assert istr(1000).floor(2) == 1000
+    assert istr(1000).floor(3) == 999
+    assert istr.floor(1000) == 1000
+    assert istr.floor(1000, 1) == 1000
+    assert istr.floor(1000.2, 1).equals(istr(1000))
+
+
+def test_tuple_join():
+    assert istr.is_prime(istr(1, 3))
+    assert istr.is_square(istr(6, 4))
+    assert istr.is_cube(istr(6, 4))
+    assert istr.is_power_of(istr(3, 2), 5)
+    assert istr.is_odd(istr(1, 3))
+    assert istr.is_even(istr(1, 2))
+    assert istr.is_triangular(istr(1, 0))
+    assert istr.is_increasing(istr(1, 2))
+    assert istr.is_non_decreasing(istr(1, 2, 2, 3))
+    assert istr.is_decreasing(istr(2, 1))
+    assert istr.is_non_increasing(istr(3, 2, 2, 1))
+
+    assert not istr.is_prime(istr(1, 4))
+    assert not istr.is_square(istr(6, 5))
+    assert not istr.is_cube(istr(6, 5))
+    assert not istr.is_power_of(istr(3, 3), 5)
+    assert not istr.is_odd(istr(1, 4))
+    assert not istr.is_even(istr(1, 3))
+    assert not istr.is_triangular(istr(1, 1))
+    assert not istr.is_increasing(istr(1, 1))
+    assert not istr.is_non_decreasing(istr(1, 2, 2, 1))
+    assert not istr.is_decreasing(istr(2, 2))
+    assert not istr.is_non_increasing(istr(3, 2, 2, 4))
+
+
 def test_compose():
     global x, y, z, _
     x = 1