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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.3
+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.3 → 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.3 → istr_python-1.1.4.post0}/istr/istr.py

@@ -5,12 +5,13 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.3"
+__version__ = "1.1.4"
 import functools
 import math
 import itertools
 import types
 import sys
+import inspect
 
 """
 Note: the changelog is now in changelog.md
@@ -305,7 +306,7 @@ class istr(str):
         # like repr, but if obj is an istr, the as_repr is not used to make sure the
         # the returned value is istr(...) and not infuenced by the repr mode
         if isinstance(obj, self.__class__):
-            return f"{obj.__class__.__name__}({super(istr,obj).__repr__()})"
+            return f"{obj.__class__.__name__}({super(istr, obj).__repr__()})"
         return repr(obj)
 
     def _int_method(self, name, op, *args):
@@ -365,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):
@@ -394,6 +409,27 @@ class istr(str):
                 return False
         return True
 
+    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
+        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):
+            if letter in lookup and lookup[letter] != ch:
+                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)}")
+        namespace.update(lookup)
+
     def __or__(self, other):
         try:
             return self.__class__(str(self).__add__(other))
@@ -483,8 +519,7 @@ 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
@@ -494,6 +529,8 @@ class istr(str):
         def __new__(cls, cls_repr_mode, mode=None):
             if mode is None:
                 return cls_repr_mode._repr_mode
+            if mode == int:
+                mode = "int"
             if mode in ("istr", "str", "int"):  # _istr is used only for TypeErrors
                 return super().__new__(cls)
             raise TypeError(f"mode not 'istr', 'str' or 'int', but {repr(mode)}")
@@ -503,8 +540,7 @@ 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
@@ -523,8 +559,7 @@ 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
@@ -601,23 +636,39 @@ class istr(str):
         result = istr("".join(result))
         cls._digits_cache[key] = result
         return result
-        
-istr.type=type(istr(0))
+
+    @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")
+
+        return istr("").join(istr(namespace[letter]) for letter in letters)
+
+
+istr.type = type(istr(0))
 
 
-def main():
-    ...
+def main(): ...
+
 
 class istrModule(types.ModuleType):
     def __call__(self, *args, **kwargs):
         return istr.__call__(*args, **kwargs)
+
     def __setattr__(self, item, value):
-        setattr(istr,item,value)
-    def __getattr__(self, item,):
-        return getattr(istr,item)
+        setattr(istr, item, value)
+
+    def __getattr__(self, item):
+        return getattr(istr, item)
 
-sys.modules["istr"].__class__ = istrModule
 
 if __name__ == "__main__":
     main()
-
+else:
+    sys.modules["istr"].__class__ = istrModule

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.3
+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.3 → 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.3"
+version = "1.1.4.post0"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = []

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

@@ -5,11 +5,11 @@ import sys
 import re
 from pathlib import Path
 
-# if __name__ == "__main__":  # to make the tests run without the pytest cli
-#     file_folder = os.path.dirname(__file__)
-#     os.chdir(file_folder)
-#     sys.path.insert(0, file_folder + "/../istr") 
-       
+if __name__ == "__main__":  # to make the tests run without the pytest cli
+    file_folder = os.path.dirname(__file__)
+    os.chdir(file_folder)
+    sys.path.insert(0, file_folder + "/../istr")
+
 import pytest
 
 import istr
@@ -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()
@@ -677,12 +713,50 @@ def test_all_distinct():
 
 
 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'))"
 
 
+def test_decompose():
+    istr("123").decompose("xyz")
+    assert x == 1
+    assert y == 2
+    assert z == 3
+    istr(456).decompose("xyz")
+    assert x == 4
+    assert y == 5
+    assert z == 6
+    istr(1231).decompose("xyzx")
+    assert x == 1
+    assert y == 2
+    assert z == 3
+    namespace = {}
+    istr(123).decompose("xyz", namespace=namespace)
+    assert namespace == dict(x=istr(1), y=istr(2), z=istr(3))
+
+    with pytest.raises(ValueError):
+        istr(1234).decompose("xyzx")
+    with pytest.raises(ValueError):
+        istr(1234).decompose("xyz")
+    with pytest.raises(ValueError):
+        istr(12).decompose("xyz")
+    with pytest.raises(ValueError):
+        istr(123).decompose("xy1")
+
+
+def test_compose():
+    x = 1
+    y = 2
+    z = 3
+    s = istr.compose("xyz")
+    assert s == 123
+    with pytest.raises(ValueError):
+        s = istr.compose("wxyz", globals())  # w is not defined
+    s = istr.compose("xyz", namespace=dict(x=3, y=istr(4), z="5"))
+    assert s == 345
+
+
 if __name__ == "__main__":
     pytest.main(["-vv", "-s", "-x", __file__])