istr-python 1.1.4__tar.gz → 1.1.4.post0__tar.gz

{istr_python-1.1.4 → istr_python-1.1.4.post0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.4
+Version: 1.1.4.post0
 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
@@ -558,8 +558,30 @@ istr.digits('3-') ==> istr('34567879')
 istr.digits('X-') ==> istr('XYZ')
 ```
 
+#### Decomposing to and composing from letter variables
+
+When we have an istr, we can decompose the value into individual one letter (global) variables with the `decompose()` method.
+E.g.
+
+```
+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.
+
+With `istr.compose()`, an istr can be constructed from individual (global) variables.
+E.g.
+
+```
+x = 3
+y = 9
+z = 6
+test = istr.compose("xyz")
+```
+Now, `test` will be `istr(396)` .
 
 #### Subclassing istr
+
 When a class is derived from istr, all methods will return that newly derived class. 
 
 E.g.

{istr_python-1.1.4 → istr_python-1.1.4.post0}/README.md

@@ -545,8 +545,30 @@ istr.digits('3-') ==> istr('34567879')
 istr.digits('X-') ==> istr('XYZ')
 ```
 
+#### Decomposing to and composing from letter variables
+
+When we have an istr, we can decompose the value into individual one letter (global) variables with the `decompose()` method.
+E.g.
+
+```
+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.
+
+With `istr.compose()`, an istr can be constructed from individual (global) variables.
+E.g.
+
+```
+x = 3
+y = 9
+z = 6
+test = istr.compose("xyz")
+```
+Now, `test` will be `istr(396)` .
 
 #### Subclassing istr
+
 When a class is derived from istr, all methods will return that newly derived class. 
 
 E.g.

{istr_python-1.1.4 → istr_python-1.1.4.post0}/istr/istr.py

@@ -366,14 +366,28 @@ class istr(str):
         return n % 2 == 1
 
     def is_square(self):
+        return istr._is_power_of(self, 2)
+
+    def is_cube(self):
+        return istr._is_power_of(self, 3)
+
+    def is_power_of(self, power_of):
+        return istr._is_power_of(self, power_of)
+
+    @staticmethod
+    def _is_power_of(self, power_of):
         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)
+        if power_of < 1:
+            raise ValueError(f"power_of must be >=1; not {power_of}")
+        if not isinstance(power_of, int):
+            raise TypeError(f"power_of must be int; not {type(power_of)}")
 
-        return n >= 0 and self == math.isqrt(n) ** 2
+        return n >= 0 and self == round(n ** (1 / power_of)) ** power_of
 
     def is_prime(self):
         if isinstance(self, istr):
@@ -411,13 +425,10 @@ class istr(str):
                 raise ValueError(f"multiple values found for variable {letter}")
             if not letter.isidentifier():
                 raise ValueError(f"{letter} cannot be used as a variable")
-
             lookup[letter] = ch
         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):
-            namespace[letter] = ch
+        namespace.update(lookup)
 
     def __or__(self, other):
         try:
@@ -626,18 +637,18 @@ class istr(str):
         cls._digits_cache[key] = result
         return result
 
+    @classmethod
+    def compose(cls, letters, namespace=None):
+        """
+        compose an istr from individual letter variables
+        """
+        if namespace is None:
+            namespace = inspect.currentframe().f_back.f_globals
+        for letter in letters:
+            if letter not in namespace:
+                raise ValueError(f"variable {letter} not defined")
 
-def compose(letters, namespace=None):
-    """
-    compose an istr from individual letter variables
-    """
-    if namespace is None:
-        namespace = inspect.currentframe().f_back.f_globals
-    for letter in letters:
-        if letter not in namespace:
-            raise ValueError(f"variable {letter} not defined")
-
-    return istr("").join(istr(namespace[letter]) for letter in letters)
+        return istr("").join(istr(namespace[letter]) for letter in letters)
 
 
 istr.type = type(istr(0))

{istr_python-1.1.4 → istr_python-1.1.4.post0}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.4
+Version: 1.1.4.post0
 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
@@ -558,8 +558,30 @@ istr.digits('3-') ==> istr('34567879')
 istr.digits('X-') ==> istr('XYZ')
 ```
 
+#### Decomposing to and composing from letter variables
+
+When we have an istr, we can decompose the value into individual one letter (global) variables with the `decompose()` method.
+E.g.
+
+```
+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.
+
+With `istr.compose()`, an istr can be constructed from individual (global) variables.
+E.g.
+
+```
+x = 3
+y = 9
+z = 6
+test = istr.compose("xyz")
+```
+Now, `test` will be `istr(396)` .
 
 #### Subclassing istr
+
 When a class is derived from istr, all methods will return that newly derived class. 
 
 E.g.

{istr_python-1.1.4 → istr_python-1.1.4.post0}/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.4"
+version = "1.1.4.post0"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = []

{istr_python-1.1.4 → istr_python-1.1.4.post0}/tests/test_istr.py

@@ -330,7 +330,43 @@ 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()
+    assert istr(1).is_cube()
+    assert not istr(2).is_cube()
+    assert istr(8).is_cube()
+    assert istr(27).is_cube()
+    assert not istr(99).is_cube()
+    with pytest.raises(TypeError, match=re.escape(f"not interpretable as int")):
+        istr("a").is_cube()
+    assert istr.is_cube(0)
+    assert istr.is_cube(1)
+    assert not istr.is_cube(2)
+    assert istr.is_cube(8)
+    assert istr.is_cube(27)
+
+
+def test_is_power_of():
+    assert not istr(-1).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)
+    assert istr(8).is_power_of(3)
+    assert istr(27).is_power_of(3)
+    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)
+    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()