istr-python 1.1.24__tar.gz → 1.1.26__tar.gz

{istr_python-1.1.24 → istr_python-1.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.24
+Version: 1.1.26
 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
@@ -379,6 +379,22 @@ It is also possible to test for even/odd of an ordinary int:
 istr.is_even(4) ==> True
 istr.is_odd(5) ==> True
 ```
+
+#### test for palindrome
+
+It is possible to test whether an istr is palindromic, like 
+```
+istr(12321).is_palindrome() ==> True
+istr('aba').is_palindrome() ==> True
+istr(123).is_palindrome() ==> False
+```
+It is also possible to test for a palindrome for anything that can be converted to a str:
+```
+istr.is_palindrome(121) ==> True
+istr.is_palindrome('no devil lived on') ==> True
+istr.is_palindrome(min) ==> False
+```
+
 #### test for divisibility
 
 It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.

{istr_python-1.1.24 → istr_python-1.1.26}/README.md

@@ -366,6 +366,22 @@ It is also possible to test for even/odd of an ordinary int:
 istr.is_even(4) ==> True
 istr.is_odd(5) ==> True
 ```
+
+#### test for palindrome
+
+It is possible to test whether an istr is palindromic, like 
+```
+istr(12321).is_palindrome() ==> True
+istr('aba').is_palindrome() ==> True
+istr(123).is_palindrome() ==> False
+```
+It is also possible to test for a palindrome for anything that can be converted to a str:
+```
+istr.is_palindrome(121) ==> True
+istr.is_palindrome('no devil lived on') ==> True
+istr.is_palindrome(min) ==> False
+```
+
 #### test for divisibility
 
 It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.

{istr_python-1.1.24 → istr_python-1.1.26}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.24"
+__version__ = "1.1.26"
 import functools
 import itertools
 import types
@@ -17,7 +17,7 @@ import copy
 import bisect
 
 """
-Note: the changelog is now in changelog.md
+Note: the changelog is in changelog.md
 
 You can view the changelog on www.salabim.org/istr/changelog
 
@@ -198,6 +198,10 @@ class istr(str):
             istr('8') ==> istr('8')
         if numeric, the value will be interpreted as an int
             istr(8) ==> istr('8')
+        if str and starts with '=', the value will be retrieved from letter variables and other characters unprocessed, e.g.
+            if a=4 and b=32, istr('=ab1') will be istr'('4321')
+        if str and starts with ':=', the value will be retrieved from letter variables. And the corresponding value will be set, e.g.
+            if a=4 and b=32, istr(':=ab') will be istr'('432') and ab will be assigned that value too.
         if a dict (or subtype of dict), the same type dict will be returned with all values istr'ed
             istr({0: 0, 1: 1, 2: 4}) ==> {0: istr('0'), 1: istr('1'), 2: istr('4')}
         if an iterator, the iterator will be mapped with istr
@@ -281,9 +285,9 @@ class istr(str):
                 value = str(cls.compose(value[1:], namespace=get_namespace(namespace)))
             else:  # it's :=
                 var_name = value[2:]
-                value = str(cls.compose(value[2:], namespace=get_namespace(namespace)))
                 if not var_name.isidentifier():
                     raise ValueError(f"{var_name!r} is not a valid identifier")
+                value = str(cls.compose(var_name, namespace=get_namespace(namespace)))
                 get_namespace(namespace)[var_name] = cls(value)
         as_int = cls._to_int(value, base)
         if as_int is cls._nan or isinstance(value, str):
@@ -311,7 +315,7 @@ class istr(str):
         return hash((self.__class__, str(self)))
 
     def __eq__(self, other):
-        if isinstance(other, self.__class__):
+        if isinstance(other, istr):
             if self.is_int() and other.is_int():
                 return self._as_int == other._as_int
         if isinstance(other, str):
@@ -398,6 +402,9 @@ class istr(str):
 
     def is_odd(self):
         return not istr.is_divisible_by(self, 2)
+        
+    def is_palindrome(self):
+        return str(self)==str(self)[::-1]
 
     def is_divisible_by(self, divisor):
         return istr.divided_by(self, divisor) is not None
@@ -410,7 +417,7 @@ class istr(str):
 
     def is_prime(self):
         n = istr.interpret_as_int(self)
-        if n < 1000000:
+        if n < 1_000_000:
             return n in istr._primes_up_to_1_000_000_as_set()
 
         if not n & 1:
@@ -451,7 +458,7 @@ class istr(str):
             if sieve[i]:
                 sieve[i * i : ub + 1 : i] = b"\x00" * (((ub - i * i) // i) + 1)
 
-        return list(map(cls, ([i for i, is_prime in enumerate(sieve) if is_prime and lb <= i < ub])))
+        return list(map(cls, ([i for i, is_prime in enumerate(sieve) if is_prime and lb <= i < ub])))  # range check just to be sure
 
     @classmethod
     @functools.lru_cache
@@ -483,11 +490,11 @@ class istr(str):
                 return n == 1
             case 1:
                 return True
-            case _ if exponent < 0:
-                raise ValueError(f"exponent must be >=1; not {exponent}")
+            case x if x < 0:
+                raise ValueError(f"exponent must be >=0; not {exponent}")
             case _ if not isinstance(exponent, int):
                 raise TypeError(f"exponent must be int; not {type(exponent)}")
-            case _ if n < 1000000:
+            case _ if n < 1_000_000:
                 return n in istr._power_ofs_up_to_1_000_000_as_set(exponent)
             case _:
                 ...
@@ -523,7 +530,7 @@ class istr(str):
                     result = []
             case 1:
                 result = cls(list(range(lb, ub)))
-            case _ if (exponent % 2 == 0 or lb >= 0) and ub <= 1_000_000:
+            case x if (x % 2 == 0 or lb >= 0) and ub <= 1_000_000:
                 result = in_range(cls._power_ofs_up_to_1_000_000(exponent), lb, ub)
             case _:
                 result = cls._power_ofs(exponent, lb, ub)
@@ -532,10 +539,10 @@ class istr(str):
         return result
 
     @classmethod
-    def _power_ofs(cls, n, lb, ub):
-        if n % 2 == 0:
+    def _power_ofs(cls, exponent, lb, ub):
+        if exponent % 2 == 0:
             lb = max(0, lb)
-        match n:
+        match exponent:
             case 0:
                 if lb <= 1 < ub:
                     result = [1]
@@ -546,11 +553,11 @@ class istr(str):
             case _:
                 result = []
                 if lb < 0:  # can't be the case for even n (because of above limiting)
-                    i = -int((-lb) ** (1 / n))
+                    i = -int((-lb) ** (1 / exponent))
                 else:
-                    i = int(lb ** (1 / n))
-                while (i_n := i**n) < ub:
-                    if i_n >= lb:
+                    i = int(lb ** (1 / exponent))
+                while (i_n := i**exponent) < ub:
+                    if i_n >= lb:  # just to be sure
                         result.append(i_n)
                     i += 1
 
@@ -573,8 +580,7 @@ class istr(str):
         same one-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
+        namespace = get_namespace(namespace)
 
         lookup = {}
         for letter, ch in zip(letters, self):
@@ -592,12 +598,11 @@ class istr(str):
         """
         compose an istr from individual letter variables
         """
-        if namespace is None:
-            namespace = inspect.currentframe().f_back.f_globals
-        namespace |= {ch: ch for ch in "0123456789"}
+        namespace = get_namespace(namespace) | {ch: ch for ch in "0123456789_"}
         for letter in letters:
-            if letter not in namespace:
-                raise ValueError(f"variable {repr(letter)} not defined")
+            if letter.isidentifier():
+                if letter not in namespace:
+                    raise ValueError(f"variable {repr(letter)} not defined")
         s = "".join(str(namespace[letter]) for letter in letters)
         return cls(s)
 
@@ -924,16 +929,22 @@ def in_range(lst, lb, ub):
 
 def get_namespace(namespace):
     if namespace is None:
-        frame = sys._getframe().f_back
-        while frame:
-            module_name = frame.f_globals.get("__name__")
-            if module_name != __name__:
-                break
-            frame = frame.f_back
+        frame = real_caller_frame()
         namespace = frame.f_globals
     return namespace
 
 
+def real_caller_frame():
+    # this will return the frame of the first frame on the stack that does not belong to this module,
+    # so in the 'user' space
+    frame = inspect.currentframe()
+    frame_name = frame.f_globals.get("__name__")
+    frame = frame.f_back
+    while frame is not None and frame_name == frame.f_globals.get("__name__"):
+        frame = frame.f_back
+    return frame
+
+
 istr.type = type(istr(0))
 
 

{istr_python-1.1.24 → istr_python-1.1.26}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.24
+Version: 1.1.26
 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
@@ -379,6 +379,22 @@ It is also possible to test for even/odd of an ordinary int:
 istr.is_even(4) ==> True
 istr.is_odd(5) ==> True
 ```
+
+#### test for palindrome
+
+It is possible to test whether an istr is palindromic, like 
+```
+istr(12321).is_palindrome() ==> True
+istr('aba').is_palindrome() ==> True
+istr(123).is_palindrome() ==> False
+```
+It is also possible to test for a palindrome for anything that can be converted to a str:
+```
+istr.is_palindrome(121) ==> True
+istr.is_palindrome('no devil lived on') ==> True
+istr.is_palindrome(min) ==> False
+```
+
 #### test for divisibility
 
 It is possible to test whether an istr is divisible by a given value with the `is_divisible_by method,` e.g.

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

{istr_python-1.1.24 → istr_python-1.1.26}/tests/test_istr.py

@@ -332,6 +332,16 @@ def test_even_odd():
     assert istr.is_odd(11111111)
 
 
+def test_is_palindrome():
+    assert istr(121).is_palindrome()
+    assert istr(1234321).is_palindrome()
+    assert not istr(123).is_palindrome()    
+    assert istr('aba').is_palindrome()        
+    assert not istr('abc').is_palindrome()             
+    assert istr('').is_palindrome()            
+    assert istr.is_palindrome('121')
+    assert istr.is_palindrome(121)    
+                    
 def test_is_divisible_by():
     assert istr(18).is_divisible_by(3)
     assert istr(18).is_divisible_by(istr(3))
@@ -964,9 +974,10 @@ def test_compose():
     assert istr(":=xyz").equals(istr(123))
     assert xyz.equals(istr(123))
 
-    assert istr(":=xyz0").equals(istr(1230))
-    assert xyz0.equals(istr(1230))
-    
+    assert istr(":=xyz_000").equals(istr('123_000'))
+    assert xyz_000.equals(istr('123_000'))
+    assert xyz_000==123000
+        
     with pytest.raises(ValueError, match=re.escape(f"'0xyz' is not a valid identifier")):
         istr(":=0xyz")