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

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

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

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.29"
+__version__ = "1.1.30"
 import functools
 import itertools
 import types
@@ -677,6 +677,22 @@ 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):
@@ -687,6 +703,16 @@ class istr(str):
             n = int(self)
         return n
 
+
+    def interpret_as_float(self):
+        if isinstance(self, istr):
+            if not self.is_int():
+                raise TypeError(f"not interpretable as float: {self._frepr(self)}")
+            n = self._as_int
+        else:
+            n = float(self)
+        return n
+
     def _str_method(self, name, *args, **kwargs):
         return self.__class__(getattr(super(), name)(*args, **kwargs))
 

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

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

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

@@ -987,7 +987,24 @@ def test_decompose():
     with pytest.raises(ValueError):
         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_compose():
     global x, y, z, _
     x = 1