istr-python 1.1.9__tar.gz → 1.1.11__tar.gz

{istr_python-1.1.9 → istr_python-1.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.9
+Version: 1.1.11
 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
@@ -648,7 +648,14 @@ Now, `test` will be `istr(396)` .
 Composing can also be done by prefixing a string with '=', like:
 
 ```
-test = istr("=xyz")
+test = istr("=xyz")  # test will be assigned istr(396)
+```
+
+Composing and assignment can be done by prefixing a string with ':=', like:
+
+```
+if istr("=xyz") > 300:
+	print(f"{xyx=}"")  # ==> will print xyz=396
 ```
 
 Usually, composing and decomposing use the globals namespace, but this can be overridden with the namespace parameter. See the test suite for details.
@@ -838,6 +845,9 @@ 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')

{istr_python-1.1.9 → istr_python-1.1.11}/README.md

@@ -635,7 +635,14 @@ Now, `test` will be `istr(396)` .
 Composing can also be done by prefixing a string with '=', like:
 
 ```
-test = istr("=xyz")
+test = istr("=xyz")  # test will be assigned istr(396)
+```
+
+Composing and assignment can be done by prefixing a string with ':=', like:
+
+```
+if istr("=xyz") > 300:
+	print(f"{xyx=}"")  # ==> will print xyz=396
 ```
 
 Usually, composing and decomposing use the globals namespace, but this can be overridden with the namespace parameter. See the test suite for details.
@@ -825,6 +832,9 @@ 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')

{istr_python-1.1.9 → istr_python-1.1.11}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.9"
+__version__ = "1.1.11"
 import functools
 import itertools
 import types
@@ -13,6 +13,7 @@ import sys
 import inspect
 import math
 import operator
+import copy
 
 """
 Note: the changelog is now in changelog.md
@@ -30,7 +31,7 @@ class _range:
     based on https://codereview.stackexchange.com/questions/229073/pure-python-range-implementation
     """
 
-    def __init__(self, cls, start, stop=None, step=1):
+    def __init__(self, cls, start, stop=None, step=1, base=None, int_format=None, repr_mode=None):
         if stop is None:
             start, stop = 0, start
         self.start, self.stop, self.step = (int(obj) for obj in (start, stop, step))
@@ -42,6 +43,9 @@ class _range:
             step_sign = 1
         self._len = max(1 + (self.stop - self.start - step_sign) // self.step, 0)
         self.parent_cls = cls
+        self.base = cls._base if base is None else base
+        self.int_format = cls._int_format if int_format is None else int_format
+        self.repr_mode = cls._repr_mode if repr_mode is None else repr_mode
         self.init_done = True
 
     def __setattr__(self, name, value):
@@ -100,13 +104,20 @@ class _range:
 
         if isinstance(index, slice):
             start, stop, step = adjust_indices(self._len, index.start, index.stop, index.step)
-            return self.parent_cls.range(self.start + self.step * start, self.start + self.step * stop, self.step * step)
+            return self.parent_cls.range(
+                self.start + self.step * start,
+                self.start + self.step * stop,
+                self.step * step,
+                base=self.base,
+                int_format=self.int_format,
+                repr_mode=self.repr_mode,
+            )
         index = int(index)
         if index < 0:
             index += self._len
         if not 0 <= index < self._len:
             raise IndexError("range object index out of range")
-        return self.parent_cls(self.start + self.step * index)
+        return self.parent_cls(self.start + self.step * index, base=self.base, int_format=self.int_format, repr_mode=self.repr_mode)
 
     def __hash__(self):
         if self._len == 0:
@@ -117,11 +128,11 @@ class _range:
         value = self.start
         if self.step > 0:
             while value < self.stop:
-                yield self.parent_cls(value)
+                yield self.parent_cls(value, base=self.base, int_format=self.int_format, repr_mode=self.repr_mode)
                 value += self.step
         else:
             while value > self.stop:
-                yield self.parent_cls(value)
+                yield self.parent_cls(value, base=self.base, int_format=self.int_format, repr_mode=self.repr_mode)
                 value += self.step
 
     def __len__(self):
@@ -207,7 +218,7 @@ class istr(str):
             a, b, c = istr(5, 6, 7) ==> a=istr('5') , b=istr('6'), c=istr('7')
     """
 
-    __slots__ = ("_as_int", "_as_repr")
+    __slots__ = ("_as_int", "_as_repr","_this_base", "_this_int_format", "_this_repr_mode")
 
     _int_format = ""
     _repr_mode = "istr"
@@ -226,61 +237,74 @@ class istr(str):
         return result[::-1] or "0"
 
     @classmethod
-    def _to_int(cls, value):
+    def _to_int(cls, value, base=10):
         try:
-            if cls._base != 10 and isinstance(value, str):
-                return int(value, cls._base)
+            if base != 10 and isinstance(value, str):
+                return int(value, base)
             else:
                 return int(value)
         except Exception:
             return cls._nan
 
-    def __new__(cls, *value, namespace=None):
+    def __new__(cls, *value, namespace=None, base=None, int_format=None, repr_mode=None):
         if namespace is None:
             try:
                 namespace = inspect.currentframe().f_back.f_back.f_globals
             except AttributeError:
                 namespace = inspect.currentframe().f_back.f_globals  # only used when running istr itself
+        base = cls._base if base is None else base
+        int_format = cls._int_format if int_format is None else int_format
+        repr_mode = cls._repr_mode if repr_mode is None else repr_mode
         if len(value) == 0:
             raise TypeError("no parameter given")
         if len(value) == 1:
             value = value[0]  # normal case of 1 parameter
         if isinstance(value, range):
-            return cls.range(value.start, value.stop, value.step)
+            return cls.range(value.start, value.stop, value.step, base=base, int_format=int_format, repr_mode=repr_mode)
         if isinstance(value, _range):
             return value
         if isinstance(value, cls):
-            return value
+            if value.is_int():
+                return cls(value._as_int, base=base, int_format=int_format, repr_mode=repr_mode)
+            else:
+                return copy.copy(value)
         if isinstance(value, dict):
-            return type(value)((k, cls(v, namespace=namespace)) for k, v in value.items())
+            return type(value)((k, cls(v, base=base, int_format=int_format, repr_mode=repr_mode, namespace=namespace)) for k, v in value.items())
         if not isinstance(value, (str, type)) and hasattr(value, "__iter__"):
             if hasattr(value, "__next__"):
-                return map(lambda v: cls(v, namespace=namespace), value)
-            return type(value)(map(lambda v: cls(v, namespace=namespace), value))
+                return map(lambda v: cls(v, base=base, int_format=int_format, repr_mode=repr_mode, namespace=namespace), value)
+            return type(value)(map(lambda v: cls(v, base=base, int_format=int_format, repr_mode=repr_mode, namespace=namespace), value))
         if isinstance(value, str) and value.startswith("=") and value != "=":
             value = str(cls.compose(value[1:], namespace=namespace))
-        as_int = cls._to_int(value)
+        if isinstance(value, str) and value.startswith(":=") and value != ";=":
+            var_name=value[2:]
+            value = str(cls.compose(value[2:], namespace=namespace))  
+            namespace[var_name]=cls(value)         
+        as_int = cls._to_int(value, base)
         if isinstance(value, str):
             as_str = value
         else:
             if as_int is cls._nan:
                 raise TypeError(f"incorrect value for {cls.__name__}: {repr(value)}")
-            if cls._int_format == "" or cls._base != 10:
-                if cls._base == 10:
+            if int_format == "" or base != 10:
+                if base == 10:
                     as_str = str(as_int)
                 else:
-                    as_str = istr._to_base(as_int, cls._base)
+                    as_str = istr._to_base(as_int, base)
             else:
-                as_str = f"{as_int:{cls._int_format}}"
+                as_str = f"{as_int:{int_format}}"
 
         self = super().__new__(cls, as_str)
         self._as_int = as_int
-        if self._repr_mode == "istr":
+        if repr_mode == "istr":
             self._as_repr = f"{cls.__name__}({repr(as_str)})"
-        elif self._repr_mode == "int":
+        elif repr_mode == "int":
             self._as_repr = "?" if as_int is self._nan else repr(as_int)
         else:
             self._as_repr = repr(as_str)
+        self._this_base=base
+        self._this_int_format=int_format
+        self._this_repr_mode=repr_mode
         return self
 
     def __iter__(self):
@@ -353,9 +377,19 @@ class istr(str):
 
     def __int__(self):
         if not self.is_int():
-            raise ValueError(f"invalid literal for int() with base 10: {self._frepr(self)}")
+            raise ValueError(f"invalid literal for int(): {self._frepr(self)}")
         return int(self._as_int)
 
+    def __float__(self):
+        if not self.is_int():
+            raise ValueError(f"invalid literal for float(): {self._frepr(self)}")
+        return float(self._as_int)
+        
+    def __complex__(self):
+        if not self.is_int():
+            raise ValueError(f"invalid literal for complex(): {self._frepr(self)}")
+        return complex(self._as_int)
+        
     def is_even(self):
         return istr.is_divisible_by(self, 2)
 
@@ -404,13 +438,12 @@ class istr(str):
             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
+            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)
@@ -425,8 +458,8 @@ class istr(str):
         for letter in letters:
             if letter not in namespace:
                 raise ValueError(f"variable {letter} not defined")
-
-        return istr("", namespace=None).join(str(namespace[letter]) for letter in letters)
+        s = "".join(str(namespace[letter]) for letter in letters)
+        return istr(s)
 
     def __or__(self, other):
         try:
@@ -510,7 +543,16 @@ class istr(str):
     def enumerate(cls, iterable, start=0):
         for i, value in enumerate(iterable, start):
             yield cls(i), value
+            
+    def this_base(self):
+        return self._this_base
 
+    def this_int_format(self):
+        return self._this_int_format
+
+    def this_repr_mode(self):
+        return self._this_repr_mode
+        
     @classmethod
     class int_format:
         def __new__(cls, cls_int_format, int_format=None):
@@ -525,7 +567,6 @@ class istr(str):
                 raise ValueError(f"{repr(int_format)} is incorrect int_format")
 
             cls._int_format = int_format
-
         def __enter__(self):
             ...
 
@@ -539,7 +580,7 @@ class istr(str):
                 return cls_repr_mode._repr_mode
             if mode is int:
                 mode = "int"
-            if mode in ("istr", "str", "int"):  # _istr is used only for TypeErrors
+            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)}")
 
@@ -575,8 +616,8 @@ class istr(str):
             self.saved_cls._base = self.saved_base
 
     @classmethod
-    def range(cls, start, stop=None, step=1):
-        return _range(cls, start, stop, step)
+    def range(cls, start, stop=None, step=1, base=None, int_format=None, repr_mode=None):
+        return _range(cls, start, stop, step, base=base, int_format=int_format, repr_mode=repr_mode)
 
     @classmethod
     def digits(cls, *args):

{istr_python-1.1.9 → istr_python-1.1.11}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.9
+Version: 1.1.11
 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
@@ -648,7 +648,14 @@ Now, `test` will be `istr(396)` .
 Composing can also be done by prefixing a string with '=', like:
 
 ```
-test = istr("=xyz")
+test = istr("=xyz")  # test will be assigned istr(396)
+```
+
+Composing and assignment can be done by prefixing a string with ':=', like:
+
+```
+if istr("=xyz") > 300:
+	print(f"{xyx=}"")  # ==> will print xyz=396
 ```
 
 Usually, composing and decomposing use the globals namespace, but this can be overridden with the namespace parameter. See the test suite for details.
@@ -838,6 +845,9 @@ 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')

{istr_python-1.1.9 → istr_python-1.1.11}/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.9"
+version = "1.1.11"
 readme = "README.md"
 requires-python = ">=3.8"
 dependencies = []

{istr_python-1.1.9 → istr_python-1.1.11}/tests/test_istr.py

@@ -5,9 +5,10 @@ import sys
 import re
 
 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 os, sys  # three lines to use the local package and chdir
+
+    os.chdir(os.path.dirname(__file__))
+    sys.path.insert(0, os.path.dirname(__file__) + "/../" + os.path.dirname(__file__).split(os.sep)[-2])
 
 import pytest
 
@@ -186,6 +187,8 @@ def test_range():
 
     with pytest.raises(IndexError):
         one_to_twelve[12]
+        
+    assert str(list(istr.range(5, base=2, repr_mode='str'))) == "['0', '1', '10', '11', '100']"
 
 
 def test_misc():
@@ -305,9 +308,12 @@ def test_range_int_format():
     r = istr.range(11)
     assert repr(r) == "istr.range(0, 11)"
     assert " ".join(r) == "0 1 2 3 4 5 6 7 8 9 10"
-    r = istr.range(11)
+
     with istr.int_format("02"):
+        r = istr.range(11)
         assert " ".join(r) == "00 01 02 03 04 05 06 07 08 09 10"
+    r = istr.range(11, int_format="03")
+    assert " ".join(r) == "000 001 002 003 004 005 006 007 008 009 010"
 
 
 def test_even_odd():
@@ -665,7 +671,27 @@ def test_base():
     with istr.base(10):
         assert a * a == 225
 
-
+    a = istr(255)
+    x = istr("?")
+    with istr.base(16):
+        assert istr(a) == "FF"
+        assert istr(a, base=36) == "73"
+        assert istr(x) == "?"
+        assert istr(x, base=36) == "?"
+        
+def test_this_queries():
+    a = istr(12, base=36, int_format="04", repr_mode="str")
+    assert repr(a)=="'C'"
+    assert a.this_base()==36
+    assert a.this_int_format()=='04'
+    assert a.this_repr_mode()=='str'
+
+    a = istr(12, int_format="04", repr_mode="str")
+    assert repr(a)=="'0012'"
+    assert a.this_base()==10
+    assert a.this_int_format()=='04'
+    assert a.this_repr_mode()=='str'
+    
 def test_digits():
     assert istr.digits().equals(istr("0123456789"))
     assert istr.digits("").equals(istr("0123456789"))
@@ -790,7 +816,6 @@ def test_decompose():
 
 
 def test_compose():
-    global x, y, z
     x = 1
     y = "2"
     z = istr(3)
@@ -803,14 +828,15 @@ def test_compose():
     assert istr("=") == "="
 
     assert istr(["=xyz", "=y"]) == [istr(123), istr(2)]
-    assert istr(("=xyz", "=y")) == (istr(123), istr(2))
-    assert istr({"=xyz", "=y"}) == {istr(123), istr(2)}
-
+ 
     assert istr(dict(xyz="=xyz", y="=y")) == {"xyz": istr(123), "y": istr(2)}
     assert istr(dict(xyz="=xyz", y="=y"), namespace=dict(x=3, y=4, z="z")) == {"xyz": istr("34z"), "y": istr(4)}
 
     assert istr(istr("=xyz")) == istr(123)
 
+    assert istr(":=xyz").equals(istr(123))
+    assert xyz.equals(istr(123))
+
 
 if __name__ == "__main__":
     pytest.main(["-vv", "-s", "-x", __file__])