istr-python 0.0.2__tar.gz → 0.0.3__tar.gz

{istr_python-0.0.2/istr_python.egg-info → istr_python-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: istr-python
-Version: 0.0.2
+Version: 0.0.3
 Summary: istr is a module to use strings as if they were integers.
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Requires-Python: >=3.7
@@ -12,7 +12,26 @@ The istr module has exactly one class: istr.
 
 With this it is possible to interpret string as if they were integers.
 
-This can be very handy for solving puzzles, but also for other purposes.
+This can be very handy for solving puzzles, but also for other purposes. For instance the
+famous send more money puzzle
+```
+  S E N D
+  M O R E
+--------- +
+M O N E Y
+```
+can be nicely, albeit not very efficient, coded as:
+```
+import itertools
+from istr import istr
+
+for s, e, n, d, m, o, r, y in istr(itertools.permutations(range(10), 8)):
+    if m and ((s | e | n | d) + (m | o | r | e) == (m | o | n | e | y)):
+        print(f" {s|e|n|d}")
+        print(f" {m|o|r|e}")
+        print("-----")
+        print(f"{m|o|n|e|y}")
+```
 
 And it is a nice demonstration of extending a class (str) with extra and changed functionality.
 
@@ -91,6 +110,17 @@ abs(four)
 -four 
 ```
 
+The bool operator works for integer value of an istr. So
+`bool('0')` ==> `False`
+`bool('1')` ==> `True`
+```
+if istr('0'):
+    print("True")
+else:
+    print("False")
+```
+this will print `False`
+
 For the in operator a istr is treated as an ordinary string, although it is possible to use ints as well:
 ```
 "34" in istr(1234)
@@ -123,5 +153,33 @@ is
 
 `'0 1 2 3 4 5 6 7 8 9 10 11'`
 
+# Using other values for istr than int or str
+Apart from with simple int or str, istr can be initialized with
+
+-
+
 # Additional methods
-It is possible to test for even/odd
+It is possible to test for even/odd with the
+
+`is_even` and `is_odd` method, e.g.
+
+```
+print(istr(4).is_even())
+print(istr(5).is_odd())
+```
+This will print `True` twice.
+
+The method `istr.reversed()` will return the an istr with the reversed content:
+```
+print(repr(istr(456).reversed()))
+print(repr(istr("0456").reversed()))
+```
+result:
+```
+istr('654')
+istr('6540')
+```
+Note that is impossible to reverse a negative istr.
+
+# Subclassing istr
+

istr_python-0.0.2/PKG-INFO → istr_python-0.0.3/README.md

@@ -1,127 +1,177 @@
-Metadata-Version: 2.1
-Name: istr-python
-Version: 0.0.2
-Summary: istr is a module to use strings as if they were integers.
-Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-
-# Introduction
-
-The istr module has exactly one class: istr.
-
-With this it is possible to interpret string as if they were integers.
-
-This can be very handy for solving puzzles, but also for other purposes.
-
-And it is a nice demonstration of extending a class (str) with extra and changed functionality.
-
-# Installation
-Installing istr with pip is easy.
-```
-$ pip install istr-python
-```
-or when you want to upgrade,
-```
-$ pip install istr-python --upgrade
-```
-Alternatively, istr.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istr).
-
-No dependencies!
-
-# Usage
-Just start with
-
-```
-from istr import istr
-```
-
-Now we can define some istrs:
-```
-four = istr("4")
-five = istr("5")
-```
-Them we can do
-```
-x= four * five
-```
-, after which x is `istr("20")`
-
-And now we can do
-```
-print(x == 20)
-print(x == "20")
-```
-resulting in two times `True`. That's because istr instances are treated as int, although they are strings.
-
-That means that we can also say
-```
-print(x < 30)
-print(x >= "10")
-```
-again resulting in two times `True`.
-
-In contrast to an ordinary string
-```
-print(four + five)
-```
-prints `9`, as istr are treated as ints.
-
-So, how can we concatenate istrs? Just use the or operator (|): 
-```
-print(four | five)
-```
-will output `45`.
-
-And the result is again an istr.
-
-That means that
-```
-(four | five) / 3
-```
-is `istr("9")`.
-
-In order to multiply a string in the usual sense, you cannot use `3 * four`, as that will be `12`. 
-
-We use the matrix multiplication operator (@) for this. So `3 @ four` is `444`.
-
-Also allowed are
-```
-abs(four)
--four 
-```
-
-For the in operator a istr is treated as an ordinary string, although it is possible to use ints as well:
-```
-"34" in istr(1234)
-34 in istr(1234)
-```
-On the left hand side an istr is always treated as a string:
-```
-istr(1234) in "01234566890ABCDEF"
-```
-
-Note that all calculations are strictly integer calculations. That means that if a float variale is ever produced it will be converted to an int.
-Also divisions are always floor divisions!
-
-There's a special case for `istr("")`. This is a proper empty string, but also represents the value of 0.
-That is to allow for istr("").join(i for i in "01234)"
-
-Sorting a list of istrs is based on the integer value, not the string. So
-
-`' '.join(sorted('1 3 2 4 5 6 11 7 9 8 10 12 0'.split()))`
-
-is
-
-`'0 1 10 11 2 3 4 5 6 7 8 9'`
-
-,whereas
-
-`' '.join(sorted(istr('1 3 2 4 5 6 11 7 9 8 10 12 0'.split())))`
-
-is 
-
-`'0 1 2 3 4 5 6 7 8 9 10 11'`
-
-# Additional methods
-It is possible to test for even/odd
+# Introduction
+
+The istr module has exactly one class: istr.
+
+With this it is possible to interpret string as if they were integers.
+
+This can be very handy for solving puzzles, but also for other purposes. For instance the
+famous send more money puzzle
+```
+  S E N D
+  M O R E
+--------- +
+M O N E Y
+```
+can be nicely, albeit not very efficient, coded as:
+```
+import itertools
+from istr import istr
+
+for s, e, n, d, m, o, r, y in istr(itertools.permutations(range(10), 8)):
+    if m and ((s | e | n | d) + (m | o | r | e) == (m | o | n | e | y)):
+        print(f" {s|e|n|d}")
+        print(f" {m|o|r|e}")
+        print("-----")
+        print(f"{m|o|n|e|y}")
+```
+
+And it is a nice demonstration of extending a class (str) with extra and changed functionality.
+
+# Installation
+Installing istr with pip is easy.
+```
+$ pip install istr-python
+```
+or when you want to upgrade,
+```
+$ pip install istr-python --upgrade
+```
+Alternatively, istr.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istr).
+
+No dependencies!
+
+# Usage
+Just start with
+
+```
+from istr import istr
+```
+
+Now we can define some istrs:
+```
+four = istr("4")
+five = istr("5")
+```
+Them we can do
+```
+x= four * five
+```
+, after which x is `istr("20")`
+
+And now we can do
+```
+print(x == 20)
+print(x == "20")
+```
+resulting in two times `True`. That's because istr instances are treated as int, although they are strings.
+
+That means that we can also say
+```
+print(x < 30)
+print(x >= "10")
+```
+again resulting in two times `True`.
+
+In contrast to an ordinary string
+```
+print(four + five)
+```
+prints `9`, as istr are treated as ints.
+
+So, how can we concatenate istrs? Just use the or operator (|): 
+```
+print(four | five)
+```
+will output `45`.
+
+And the result is again an istr.
+
+That means that
+```
+(four | five) / 3
+```
+is `istr("9")`.
+
+In order to multiply a string in the usual sense, you cannot use `3 * four`, as that will be `12`. 
+
+We use the matrix multiplication operator (@) for this. So `3 @ four` is `444`.
+
+Also allowed are
+```
+abs(four)
+-four 
+```
+
+The bool operator works for integer value of an istr. So
+`bool('0')` ==> `False`
+`bool('1')` ==> `True`
+```
+if istr('0'):
+    print("True")
+else:
+    print("False")
+```
+this will print `False`
+
+For the in operator a istr is treated as an ordinary string, although it is possible to use ints as well:
+```
+"34" in istr(1234)
+34 in istr(1234)
+```
+On the left hand side an istr is always treated as a string:
+```
+istr(1234) in "01234566890ABCDEF"
+```
+
+Note that all calculations are strictly integer calculations. That means that if a float variale is ever produced it will be converted to an int.
+Also divisions are always floor divisions!
+
+There's a special case for `istr("")`. This is a proper empty string, but also represents the value of 0.
+That is to allow for istr("").join(i for i in "01234)"
+
+Sorting a list of istrs is based on the integer value, not the string. So
+
+`' '.join(sorted('1 3 2 4 5 6 11 7 9 8 10 12 0'.split()))`
+
+is
+
+`'0 1 10 11 2 3 4 5 6 7 8 9'`
+
+,whereas
+
+`' '.join(sorted(istr('1 3 2 4 5 6 11 7 9 8 10 12 0'.split())))`
+
+is 
+
+`'0 1 2 3 4 5 6 7 8 9 10 11'`
+
+# Using other values for istr than int or str
+Apart from with simple int or str, istr can be initialized with
+
+-
+
+# Additional methods
+It is possible to test for even/odd with the
+
+`is_even` and `is_odd` method, e.g.
+
+```
+print(istr(4).is_even())
+print(istr(5).is_odd())
+```
+This will print `True` twice.
+
+The method `istr.reversed()` will return the an istr with the reversed content:
+```
+print(repr(istr(456).reversed()))
+print(repr(istr("0456").reversed()))
+```
+result:
+```
+istr('654')
+istr('6540')
+```
+Note that is impossible to reverse a negative istr.
+
+# Subclassing istr
+

{istr_python-0.0.2 → istr_python-0.0.3}/istr/istr.py

@@ -10,21 +10,37 @@ class istr(str):
     Parameters
     ----------
     value : any
-        value to store
-
-
-    """
+        if str the value will to be interpreted as an int
+            istr('8') ==> istr('8')
+        if numeric, the value will be interpreted as an int
+            istr(8) ==> istr('8')
+        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
+            istr(i * i for i in range(3)) ==> <map object>
+            list(istr(i * i for i in range(3))) ==> [istr('0'), istr('1'), istr('4')]
+        if an iterable, the same type will be returned with all elements istr'ed
+            istr([0, 1, 4]) ==> [istr('0'), istr('1'), istr('4')]
+            istr((0, 1, 4)) ==> (istr('0'), istr('1'), istr('4'))
+            istr({0, 1, 4}) ==> {istr('4'), istr('0'), istr('1')} # or similar
+        if a range, an istr.range instance will be returned
+            istr(range(3)) ==> istr.range(3)
+            list(istr(range(3))) ==> [istr('0'), istr('1'), istr('2')]
+            len(istr(range(3))) ==> 3
+
+        it is possible to give more than one parameter, in which case a tuple
+        of the istrs of the parameters will be returned, which can be handy
+        to multiple assign, e.g.
+            a, b, c = istr(5, 6, 7) ==> a=istr("5') , b=istr("6"), c=istr("7")"""
 
     _format = ""
 
     @classmethod
     def toint(cls, value):
-        if isinstance(value, cls):
-            return value.asint
-        if isinstance(value, str):
-            if value == "":
-                return 0
-        return int(value)
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            raise ValueError(f"unable to convert {repr(value)} to int")
 
     @classmethod
     def check_format(cls, format):
@@ -34,25 +50,38 @@ class istr(str):
             raise ValueError(f"{repr(format)} is incorrect format")
         return format
 
-    def __new__(cls, value=""):
+    def __new__(cls, *value):
+        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)
-        if not isinstance(value, str) and hasattr(value, "__iter__"):
+        if isinstance(value, dict):
+            return type(value)((k, cls(v)) for k, v in value.items())
+        if not isinstance(value, (str, type)) and hasattr(value, "__iter__"):
             if hasattr(value, "__next__") or type(value) == range:
                 return map(partial(cls), value)
             return type(value)(map(partial(cls), value))
-
-        if cls._format == "" or value == "":
-            return super().__new__(cls, str(value))
+        if value == "":
+            asstr = ""
+            asint = 0
         else:
-            return super().__new__(cls, f"{cls.toint(value):{cls._format}}")
+            asint = cls.toint(value)
+            if cls._format == "":
+                if isinstance(value, str):
+                    asstr = value
+                else:
+                    asstr = str(asint)
+            else:
+                asstr = f"{asint:{cls._format}}"
 
-    def __init__(self, value=""):
-        self.asint = self.toint(value)
-        super().__init__()
+        self = super().__new__(cls, asstr)
+        self.asint = asint
+        return self
 
     def __hash__(self):
-        return hash((self.__class__, self.asint))
+        return hash((self.__class__, str(self)))
 
     def __eq__(self, other):
         if isinstance(other, self.__class__):
@@ -85,6 +114,9 @@ class istr(str):
     def __gt__(self, other):
         return self.asint > self.toint(other)
 
+    def __bool__(self):
+        return bool(self.asint)
+
     def __add__(self, other):
         return self.__class__(self.asint + self.toint(other))
 
@@ -179,6 +211,12 @@ class istr(str):
         s = super().join(iterable)
         return self.__class__(s)
 
+    def reversed(self):
+        return self[::-1]
+
+    def __getitem__(self, key):
+        return self.__class__(super().__getitem__(key))
+
     @classmethod
     def enumerate(cls, iterable, start=0):
         for i, value in enumerate(iterable, start):
@@ -344,8 +382,9 @@ class istr(str):
 
 
 def main():
-    ...
+    zero=istr("0")
+    print(bool(zero))
+
 
 if __name__ == "__main__":
     main()
-

{istr_python-0.0.2 → istr_python-0.0.3}/istr/sendmoremoney.py

@@ -1,6 +1,7 @@
 import itertools
 from istr import istr
-print(istr)
+import istr
+print(istr,istr(8))
 
 for s, e, n, d, m, o, r, y in istr(itertools.permutations("0123456789", 8)):
     if (m > 0) and ((s | e | n | d) + (m | o | r | e) == (m | o | n | e | y)):

istr_python-0.0.2/README.md → istr_python-0.0.3/istr_python.egg-info/PKG-INFO

@@ -1,119 +1,185 @@
-# Introduction
-
-The istr module has exactly one class: istr.
-
-With this it is possible to interpret string as if they were integers.
-
-This can be very handy for solving puzzles, but also for other purposes.
-
-And it is a nice demonstration of extending a class (str) with extra and changed functionality.
-
-# Installation
-Installing istr with pip is easy.
-```
-$ pip install istr-python
-```
-or when you want to upgrade,
-```
-$ pip install istr-python --upgrade
-```
-Alternatively, istr.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istr).
-
-No dependencies!
-
-# Usage
-Just start with
-
-```
-from istr import istr
-```
-
-Now we can define some istrs:
-```
-four = istr("4")
-five = istr("5")
-```
-Them we can do
-```
-x= four * five
-```
-, after which x is `istr("20")`
-
-And now we can do
-```
-print(x == 20)
-print(x == "20")
-```
-resulting in two times `True`. That's because istr instances are treated as int, although they are strings.
-
-That means that we can also say
-```
-print(x < 30)
-print(x >= "10")
-```
-again resulting in two times `True`.
-
-In contrast to an ordinary string
-```
-print(four + five)
-```
-prints `9`, as istr are treated as ints.
-
-So, how can we concatenate istrs? Just use the or operator (|): 
-```
-print(four | five)
-```
-will output `45`.
-
-And the result is again an istr.
-
-That means that
-```
-(four | five) / 3
-```
-is `istr("9")`.
-
-In order to multiply a string in the usual sense, you cannot use `3 * four`, as that will be `12`. 
-
-We use the matrix multiplication operator (@) for this. So `3 @ four` is `444`.
-
-Also allowed are
-```
-abs(four)
--four 
-```
-
-For the in operator a istr is treated as an ordinary string, although it is possible to use ints as well:
-```
-"34" in istr(1234)
-34 in istr(1234)
-```
-On the left hand side an istr is always treated as a string:
-```
-istr(1234) in "01234566890ABCDEF"
-```
-
-Note that all calculations are strictly integer calculations. That means that if a float variale is ever produced it will be converted to an int.
-Also divisions are always floor divisions!
-
-There's a special case for `istr("")`. This is a proper empty string, but also represents the value of 0.
-That is to allow for istr("").join(i for i in "01234)"
-
-Sorting a list of istrs is based on the integer value, not the string. So
-
-`' '.join(sorted('1 3 2 4 5 6 11 7 9 8 10 12 0'.split()))`
-
-is
-
-`'0 1 10 11 2 3 4 5 6 7 8 9'`
-
-,whereas
-
-`' '.join(sorted(istr('1 3 2 4 5 6 11 7 9 8 10 12 0'.split())))`
-
-is 
-
-`'0 1 2 3 4 5 6 7 8 9 10 11'`
-
-# Additional methods
-It is possible to test for even/odd
+Metadata-Version: 2.1
+Name: istr-python
+Version: 0.0.3
+Summary: istr is a module to use strings as if they were integers.
+Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Introduction
+
+The istr module has exactly one class: istr.
+
+With this it is possible to interpret string as if they were integers.
+
+This can be very handy for solving puzzles, but also for other purposes. For instance the
+famous send more money puzzle
+```
+  S E N D
+  M O R E
+--------- +
+M O N E Y
+```
+can be nicely, albeit not very efficient, coded as:
+```
+import itertools
+from istr import istr
+
+for s, e, n, d, m, o, r, y in istr(itertools.permutations(range(10), 8)):
+    if m and ((s | e | n | d) + (m | o | r | e) == (m | o | n | e | y)):
+        print(f" {s|e|n|d}")
+        print(f" {m|o|r|e}")
+        print("-----")
+        print(f"{m|o|n|e|y}")
+```
+
+And it is a nice demonstration of extending a class (str) with extra and changed functionality.
+
+# Installation
+Installing istr with pip is easy.
+```
+$ pip install istr-python
+```
+or when you want to upgrade,
+```
+$ pip install istr-python --upgrade
+```
+Alternatively, istr.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istr).
+
+No dependencies!
+
+# Usage
+Just start with
+
+```
+from istr import istr
+```
+
+Now we can define some istrs:
+```
+four = istr("4")
+five = istr("5")
+```
+Them we can do
+```
+x= four * five
+```
+, after which x is `istr("20")`
+
+And now we can do
+```
+print(x == 20)
+print(x == "20")
+```
+resulting in two times `True`. That's because istr instances are treated as int, although they are strings.
+
+That means that we can also say
+```
+print(x < 30)
+print(x >= "10")
+```
+again resulting in two times `True`.
+
+In contrast to an ordinary string
+```
+print(four + five)
+```
+prints `9`, as istr are treated as ints.
+
+So, how can we concatenate istrs? Just use the or operator (|): 
+```
+print(four | five)
+```
+will output `45`.
+
+And the result is again an istr.
+
+That means that
+```
+(four | five) / 3
+```
+is `istr("9")`.
+
+In order to multiply a string in the usual sense, you cannot use `3 * four`, as that will be `12`. 
+
+We use the matrix multiplication operator (@) for this. So `3 @ four` is `444`.
+
+Also allowed are
+```
+abs(four)
+-four 
+```
+
+The bool operator works for integer value of an istr. So
+`bool('0')` ==> `False`
+`bool('1')` ==> `True`
+```
+if istr('0'):
+    print("True")
+else:
+    print("False")
+```
+this will print `False`
+
+For the in operator a istr is treated as an ordinary string, although it is possible to use ints as well:
+```
+"34" in istr(1234)
+34 in istr(1234)
+```
+On the left hand side an istr is always treated as a string:
+```
+istr(1234) in "01234566890ABCDEF"
+```
+
+Note that all calculations are strictly integer calculations. That means that if a float variale is ever produced it will be converted to an int.
+Also divisions are always floor divisions!
+
+There's a special case for `istr("")`. This is a proper empty string, but also represents the value of 0.
+That is to allow for istr("").join(i for i in "01234)"
+
+Sorting a list of istrs is based on the integer value, not the string. So
+
+`' '.join(sorted('1 3 2 4 5 6 11 7 9 8 10 12 0'.split()))`
+
+is
+
+`'0 1 10 11 2 3 4 5 6 7 8 9'`
+
+,whereas
+
+`' '.join(sorted(istr('1 3 2 4 5 6 11 7 9 8 10 12 0'.split())))`
+
+is 
+
+`'0 1 2 3 4 5 6 7 8 9 10 11'`
+
+# Using other values for istr than int or str
+Apart from with simple int or str, istr can be initialized with
+
+-
+
+# Additional methods
+It is possible to test for even/odd with the
+
+`is_even` and `is_odd` method, e.g.
+
+```
+print(istr(4).is_even())
+print(istr(5).is_odd())
+```
+This will print `True` twice.
+
+The method `istr.reversed()` will return the an istr with the reversed content:
+```
+print(repr(istr(456).reversed()))
+print(repr(istr("0456").reversed()))
+```
+result:
+```
+istr('654')
+istr('6540')
+```
+Note that is impossible to reverse a negative istr.
+
+# Subclassing istr
+

{istr_python-0.0.2 → istr_python-0.0.3}/pyproject.toml

@@ -8,8 +8,7 @@ authors = [
     {name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com"}
 ]
 description = "istr is a module to use strings as if they were integers."
-
-version = "0.0.2"
+version = "0.0.3"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = [

{istr_python-0.0.2 → istr_python-0.0.3}/tests/test_istr.py

@@ -1,10 +1,17 @@
-from __future__ import print_function
-from __future__ import division
-from istr import istr
 import math
 
+if __name__ == "__main__":  # to make the tests run without the pytest cli
+    import sys
+
+    sys.path = ["../istr"] + sys.path
+
 import pytest
 
+from istr import istr
+
+istr.equals = lambda self, other: type(self) == type(other) and (str(self) == str(other))
+# this method tests whether self and other are exactly the same
+
 for i, name in enumerate("minus_one zero one two three four five six seven eight nine ten eleven twelve thirteen".split(), -1):
     globals()[name] = istr(i)
 one_to_twelve = istr.range(1, thirteen)
@@ -161,8 +168,8 @@ def test_misc():
     assert istr(istr(6)) == "6"
     assert istr(" 12 ") == " 12 "
     with istr.format("03"):
-        assert istr(" 12 ") == "012"
-        assert istr("")==""
+        assert istr("   12  ") == "012"
+        assert istr("") == ""
 
 
 def test_divmod():
@@ -193,7 +200,7 @@ def test_lazy():
 
 
 def test_str_repr():
-    assert repr(one) == "istr('1')"
+    assert one.equals(istr("1"))
     assert str(one) == "1"
     assert f"{one}" == "1"
     assert repr(one_to_twelve) == "istr.range(1, 13)"
@@ -306,11 +313,8 @@ def test_join():
 
 
 def test_matmul():
-    assert five @ 3 == "555"
-    assert five @ 3 == 555
-
-    assert 3 @ five == "555"
-    assert 3 @ five == 555
+    assert (five @ 3).equals(istr("555"))
+    assert (3 @ five).equals(istr("555"))
 
     with pytest.raises(TypeError):
         three @ five
@@ -319,44 +323,68 @@ def test_matmul():
     with pytest.raises(TypeError):
         "3" @ five
 
-
 def test_str():
     assert repr(str(five)) == "'5'"
 
 
 def test_trunc_and_friends():
-    assert repr(math.trunc(one)) == "istr('1')"
-    assert repr(math.ceil(one)) == "istr('1')"
-    assert repr(math.floor(one)) == "istr('1')"
-    assert repr(round(one)) == "istr('1')"
+    assert math.trunc(one).equals(istr("1"))
+    assert math.ceil(one).equals(istr("1"))
+    assert math.floor(one).equals(istr("1"))
+    assert round(one).equals(istr("1"))
 
 
 def test_data_structures():
-    assert istr(list(range(1, 4))) == [1, 2, 3]
-    assert istr(list(range(1, 4))) == ["1", "2", "3"]
-
-    assert istr(tuple(range(1, 4))) == (1, 2, 3)
-    assert istr(tuple(range(1, 4))) == ("1", "2", "3")
+    assert repr(istr(list(range(1, 4)))) == "[istr('1'), istr('2'), istr('3')]"
+    assert repr(istr(tuple(range(1, 4)))) == "(istr('1'), istr('2'), istr('3'))"
     assert istr(set(range(1, 4))) == {istr(1), istr(2), istr(3)}
 
-    assert list(istr(range(1, 4))) == [1, 2, 3]
-    assert list(istr(range(1, 4))) == ["1", "2", "3"]
+    assert repr(list(istr(range(1, 4)))) == "[istr('1'), istr('2'), istr('3')]"
+
+    assert repr(list(istr.enumerate("abc"))) == "[(istr('0'), 'a'), (istr('1'), 'b'), (istr('2'), 'c')]"
+    assert repr(list(istr.enumerate("abc", 1))) == "[(istr('1'), 'a'), (istr('2'), 'b'), (istr('3'), 'c')]"
+
+    assert repr(istr(dict(zero=0, one=1, two=4))) == "{'zero': istr('0'), 'one': istr('1'), 'two': istr('4')}"
 
-    assert list(istr(range(1, 4))) == [1, 2, 3]
-    assert list(istr(range(1, 4))) == ["1", "2", "3"]
 
-    assert list(istr.enumerate("abc")) == [(0, "a"), (1, "b"), (2, "c")]
-    assert list(istr.enumerate("abc")) == [("0", "a"), ("1", "b"), ("2", "c")]
+def test_indexing():
+    a = istr(12345)
+    assert a[0].equals(istr(1))
+    assert a[:2].equals(istr(12))
+    assert a[::-1].equals(istr(54321))
+    assert a[-2:].equals(istr(45))
+
+
+def test_reverse():
+    a = istr(12345)
+    assert a.reversed(), same(istr(54321))
 
 
 def test_edge_cases():
     with pytest.raises(ValueError):
         istr("ab")
-    with pytest.raises(TypeError):
+    with pytest.raises(ValueError):
         istr(istr)
-    assert repr(istr(istr(one))) == "istr('1')"
+    assert istr(istr(one)).equals(istr("1"))
+    with pytest.raises(TypeError):
+        istr()
+
+
+def test_unpacking():
+    a = istr("123")
+    x, y, z = istr(*a)
+    assert x.equals(istr(1))
+    assert y.equals(istr(2))
+    assert z.equals(istr(3))
+
+
+def test_subclassing():
+    class jstr(istr):
+        ...
+
+    assert jstr(5).equals(jstr(5))
+    assert repr(jstr(*range(3))) == "(jstr('0'), jstr('1'), jstr('2'))"
 
 
 if __name__ == "__main__":
     pytest.main(["-vv", "-s", "-x", __file__])
-