istr-python 1.0.1__tar.gz → 1.0.2__tar.gz

{istr_python-1.0.1 → istr_python-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: istr-python
-Version: 1.0.1
+Version: 1.0.2
 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
@@ -150,10 +150,10 @@ or even
 four, five = istr(4, 5)
 ```
 
-> > [!IMPORTANT]
-> >
-> > All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
-> > Also divisions are always floor divisions!
+##### Important
+>
+> All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
+> Also divisions are always floor divisions!
 
 #### Use istrs as string
 
@@ -188,12 +188,13 @@ And
 
 is also `istr('444')`
 
-> Note:
+##### Note
+
 >
 > It is not allowed to use the `@` operator for two istrs. So, `four @ five` raises a TypeError.
-
 #### istrs that can't be interpreted as an int
 
+
 Although usualy, istrs are to be interpreted as an int, that's not a requirement.
 
 So
@@ -234,7 +235,7 @@ is `False`.
 
 
 
-The bool operator works normally on the integer value of an istr. So
+The `bool` operator works normally on the integer value of an istr. So
 
 `bool(istr('0'))` ==> `False`
 `bool(istr('1'))` ==> `True`
@@ -251,6 +252,7 @@ For the `in` operator, an istr is treated as an ordinary string, although it is
 ```
 '34' in istr(1234)
 34 in istr(1234)
+
 ```
 On the left hand side an istr is always treated as a string:
 ```
@@ -280,47 +282,39 @@ is
 ```
 '0 1 2 3 4 5 6 7 8 9 10 11'
 ```
+#### Using values that are neither string or numeric to initialize istr
 
-#### Using values to inialitize istr other than numeric value or str
-Apart from with simple numeric (to be interpreted as an int) or str, istr can be initialized with
+Apart from with numeric (to be interpreted as an int) or str, istr can be initialized with
 several other types:
 
-- 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 a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
 
 - 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
-    ```
+    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
-  ```
+```
+  istr(range(3)) ==> istr.range(3)
+  list(istr(range(3))) ==> [istr('0'), istr('1'), istr('2')]
+  len(istr(range(3))) ==> 3
+```
 
 - if an istr.range instance, the same istr.range will be returned
 
 - if an istr, the same istr will be used
 
-    ```
+  ```
     istr(istr('4')) ==> istr ('4')
-    ```
+  ```
 
 #### More than one parameter for istr
 It is possible to give more than one parameter, in which case a tuple
@@ -355,7 +349,7 @@ istr(n100).all_distinct() ==> False
 
 #### reverse an istr
 
-The method `istr.reversed()` will return the an istr with the reversed content:
+The method `istr.reversed()` will return an istr with the reversed content:
 ```
 istr(456).reversed() ==> istr('654')
 istr('0456').reversed() ==> istr('6540')
@@ -365,13 +359,13 @@ The same can -of course- be achieved with
 istr(456)[::-1] ==> istr('654')
 istr('0456')[::-1] ==> istr('6540')
 ```
-> > [!NOTE]
-> >
-> > It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
-> >
-> > ```
-> > istr(-456) ==> TypeError
-> > ```
+##### Note
+>
+> It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
+>
+> ```
+> istr(-456).reversed() ==> TypeError
+> ```
 
 #### enumerate with istrs
 
@@ -379,8 +373,8 @@ The `istr.enumerate` method can be used just as the builtin enumerate function.
 The iteration counter however is an istr rather than an int. E.g. 
 
 ```
-    for i, c in istr.enumerate('abc'):
-        print(f'{repr(i)} {c}')
+for i, c in istr.enumerate('abc'):
+    print(f'{repr(i)} {c}')
 ```
 prints
 ```
@@ -414,7 +408,8 @@ The given argument(s) result in a range of digits.
 - `<n>` ==> n
 - `<n-m>` ==> n, n+1, ..., m
 - `-n>` ==> 0, 1, ... n
-- `n->` ==> n, n+1, ..., 9
+- `n->` ==> n, n+1, ..., 9 if n is numeric (0-9), n, n+1, ... Z if n is a letter
+- `'-'` ==> 0, 1, ..., 9
 - `''` ==> 0, 1, ..., 9
 
 (n and m must be digits between 0 and 9 or letters letters between A and Z)
@@ -460,9 +455,9 @@ will print `jstr('20')`
 
 It is possible to control the way an `istr` instance will be repr'ed.
 
-By default, the `istr(5)` is represented as `istr('5')`.
+By default, `istr(5)` is represented as `istr('5')`.
 
-With the istr.repr_mode() context manager, that can be changed:
+With the `istr.repr_mode()` context manager, that can be changed:
 ```
 with istr.repr_mode('str'):
     five = istr(5)
@@ -480,7 +475,7 @@ This will print
 5
 istr('5')
 ```
-If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `nan` (not a number) will be returned:
+If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `?` will be returned:
 
 ```
  with istr.repr_mode('int'):
@@ -491,12 +486,12 @@ If the repr_mode is `'int'` and the istr can't be interpreted as an int the stri
 This will print
 
 ```
-nan
+?
 ```
 
-> > [!NOTE]
-> >
-> > The way an `istr` is represented is determined at initialization.
+##### Note
+>
+> The way an `istr` is represented is determined at initialization.
 
 It is also possible to set the repr mode without a context manager:
 
@@ -530,13 +525,13 @@ with istr.base(16):
     a = istr('7fff')
     print(int(a))
 
-    b = istr(15)
+    b = istr(127)
     print(repr(b))
 ```
 This will result in
 ```
 32767
-istr('F')
+istr('7F')
 ```
 All calculations are done in the decimal 10 system.
 
@@ -559,7 +554,7 @@ will result in `10`.
 
 #### Changing the format of the string
 
-When an  istr is initialized with a string the istr will be just stored as such.
+When an  istr is initialized with a string the istr will be always stored as such.
 
 ```
 repr('4')) ==> istr('4')
@@ -573,7 +568,7 @@ For initializing with an int (or other numeric) value, the string is by default
 repr(4)) ==> istr('4')
 ```
 
- With the `istr.int_format()` context manager this behavior can be changed.
+With the `istr.int_format()` context manager this behavior can be changed.
 If the format specifier is a number, most likely a single digit, that
 will be the minimum number of characters in the string:
 
@@ -606,24 +601,10 @@ istr('012')
 istr('123')
 istr('1234')
 ```
-> > [!NOTE]
-> >
-> > if a string is used to initialize an istr AND that string can be interpreted as an int. the string will reformatted:
-> >
-> > ```
-> > with istr.int_format('03'):
-> >    print(repr(istr(12)))
-> > ```
-> >
-> > will result in
-> >
-> > ```
-> > istr('0012')
-> > ```
+
+##### Note
 >
-> > [!NOTE]
-> >
-> > For bases other than 10, the string will never be reformatted!
+> For bases other than 10, the string will never be reformatted!
 
 ### Overview of operations
 
@@ -663,6 +644,8 @@ There's an extensive pytest script in the `\tests` directory.
 
 This script also shows clearly the ways istr can be used, including several edge cases. Highly recommended to have a look at.
 
+
+
 ### Badges
 ![PyPI](https://img.shields.io/pypi/v/istr-python) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/istr-python) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/istr-python)
 

{istr_python-1.0.1 → istr_python-1.0.2}/README.md

@@ -137,10 +137,10 @@ or even
 four, five = istr(4, 5)
 ```
 
-> > [!IMPORTANT]
-> >
-> > All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
-> > Also divisions are always floor divisions!
+##### Important
+>
+> All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
+> Also divisions are always floor divisions!
 
 #### Use istrs as string
 
@@ -175,12 +175,13 @@ And
 
 is also `istr('444')`
 
-> Note:
+##### Note
+
 >
 > It is not allowed to use the `@` operator for two istrs. So, `four @ five` raises a TypeError.
-
 #### istrs that can't be interpreted as an int
 
+
 Although usualy, istrs are to be interpreted as an int, that's not a requirement.
 
 So
@@ -221,7 +222,7 @@ is `False`.
 
 
 
-The bool operator works normally on the integer value of an istr. So
+The `bool` operator works normally on the integer value of an istr. So
 
 `bool(istr('0'))` ==> `False`
 `bool(istr('1'))` ==> `True`
@@ -238,6 +239,7 @@ For the `in` operator, an istr is treated as an ordinary string, although it is
 ```
 '34' in istr(1234)
 34 in istr(1234)
+
 ```
 On the left hand side an istr is always treated as a string:
 ```
@@ -267,47 +269,39 @@ is
 ```
 '0 1 2 3 4 5 6 7 8 9 10 11'
 ```
+#### Using values that are neither string or numeric to initialize istr
 
-#### Using values to inialitize istr other than numeric value or str
-Apart from with simple numeric (to be interpreted as an int) or str, istr can be initialized with
+Apart from with numeric (to be interpreted as an int) or str, istr can be initialized with
 several other types:
 
-- 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 a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
 
 - 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
-    ```
+    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
-  ```
+```
+  istr(range(3)) ==> istr.range(3)
+  list(istr(range(3))) ==> [istr('0'), istr('1'), istr('2')]
+  len(istr(range(3))) ==> 3
+```
 
 - if an istr.range instance, the same istr.range will be returned
 
 - if an istr, the same istr will be used
 
-    ```
+  ```
     istr(istr('4')) ==> istr ('4')
-    ```
+  ```
 
 #### More than one parameter for istr
 It is possible to give more than one parameter, in which case a tuple
@@ -342,7 +336,7 @@ istr(n100).all_distinct() ==> False
 
 #### reverse an istr
 
-The method `istr.reversed()` will return the an istr with the reversed content:
+The method `istr.reversed()` will return an istr with the reversed content:
 ```
 istr(456).reversed() ==> istr('654')
 istr('0456').reversed() ==> istr('6540')
@@ -352,13 +346,13 @@ The same can -of course- be achieved with
 istr(456)[::-1] ==> istr('654')
 istr('0456')[::-1] ==> istr('6540')
 ```
-> > [!NOTE]
-> >
-> > It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
-> >
-> > ```
-> > istr(-456) ==> TypeError
-> > ```
+##### Note
+>
+> It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
+>
+> ```
+> istr(-456).reversed() ==> TypeError
+> ```
 
 #### enumerate with istrs
 
@@ -366,8 +360,8 @@ The `istr.enumerate` method can be used just as the builtin enumerate function.
 The iteration counter however is an istr rather than an int. E.g. 
 
 ```
-    for i, c in istr.enumerate('abc'):
-        print(f'{repr(i)} {c}')
+for i, c in istr.enumerate('abc'):
+    print(f'{repr(i)} {c}')
 ```
 prints
 ```
@@ -401,7 +395,8 @@ The given argument(s) result in a range of digits.
 - `<n>` ==> n
 - `<n-m>` ==> n, n+1, ..., m
 - `-n>` ==> 0, 1, ... n
-- `n->` ==> n, n+1, ..., 9
+- `n->` ==> n, n+1, ..., 9 if n is numeric (0-9), n, n+1, ... Z if n is a letter
+- `'-'` ==> 0, 1, ..., 9
 - `''` ==> 0, 1, ..., 9
 
 (n and m must be digits between 0 and 9 or letters letters between A and Z)
@@ -447,9 +442,9 @@ will print `jstr('20')`
 
 It is possible to control the way an `istr` instance will be repr'ed.
 
-By default, the `istr(5)` is represented as `istr('5')`.
+By default, `istr(5)` is represented as `istr('5')`.
 
-With the istr.repr_mode() context manager, that can be changed:
+With the `istr.repr_mode()` context manager, that can be changed:
 ```
 with istr.repr_mode('str'):
     five = istr(5)
@@ -467,7 +462,7 @@ This will print
 5
 istr('5')
 ```
-If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `nan` (not a number) will be returned:
+If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `?` will be returned:
 
 ```
  with istr.repr_mode('int'):
@@ -478,12 +473,12 @@ If the repr_mode is `'int'` and the istr can't be interpreted as an int the stri
 This will print
 
 ```
-nan
+?
 ```
 
-> > [!NOTE]
-> >
-> > The way an `istr` is represented is determined at initialization.
+##### Note
+>
+> The way an `istr` is represented is determined at initialization.
 
 It is also possible to set the repr mode without a context manager:
 
@@ -517,13 +512,13 @@ with istr.base(16):
     a = istr('7fff')
     print(int(a))
 
-    b = istr(15)
+    b = istr(127)
     print(repr(b))
 ```
 This will result in
 ```
 32767
-istr('F')
+istr('7F')
 ```
 All calculations are done in the decimal 10 system.
 
@@ -546,7 +541,7 @@ will result in `10`.
 
 #### Changing the format of the string
 
-When an  istr is initialized with a string the istr will be just stored as such.
+When an  istr is initialized with a string the istr will be always stored as such.
 
 ```
 repr('4')) ==> istr('4')
@@ -560,7 +555,7 @@ For initializing with an int (or other numeric) value, the string is by default
 repr(4)) ==> istr('4')
 ```
 
- With the `istr.int_format()` context manager this behavior can be changed.
+With the `istr.int_format()` context manager this behavior can be changed.
 If the format specifier is a number, most likely a single digit, that
 will be the minimum number of characters in the string:
 
@@ -593,24 +588,10 @@ istr('012')
 istr('123')
 istr('1234')
 ```
-> > [!NOTE]
-> >
-> > if a string is used to initialize an istr AND that string can be interpreted as an int. the string will reformatted:
-> >
-> > ```
-> > with istr.int_format('03'):
-> >    print(repr(istr(12)))
-> > ```
-> >
-> > will result in
-> >
-> > ```
-> > istr('0012')
-> > ```
+
+##### Note
 >
-> > [!NOTE]
-> >
-> > For bases other than 10, the string will never be reformatted!
+> For bases other than 10, the string will never be reformatted!
 
 ### Overview of operations
 
@@ -650,6 +631,8 @@ There's an extensive pytest script in the `\tests` directory.
 
 This script also shows clearly the ways istr can be used, including several edge cases. Highly recommended to have a look at.
 
+
+
 ### Badges
 ![PyPI](https://img.shields.io/pypi/v/istr-python) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/istr-python) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/istr-python)
 

{istr_python-1.0.1 → istr_python-1.0.2}/istr/changelog.md

@@ -1,5 +1,21 @@
 ## changelog
 
+### version 1.0.2 | 2024-05-08
+
+When a string that can't be interpreted as an istr is created when istr.repr_mode is 'int', the repr of that file will be `?` (was: `nan`):
+
+```
+with istr.repr_mode('int'):
+    a = istr('abc')
+print(a)
+```
+
+will print
+
+```
+?
+```
+
 ### version 1.0.1 | 2024-05-07
 
 From now on, the changelog is not anymore part of the istr.py file, but is in a separate `changelog.md` file.

{istr_python-1.0.1 → istr_python-1.0.2}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 import functools
 import math
 
@@ -15,6 +15,7 @@ Note: the changelog is now in changelog.md
 You can view the changelog on www.salabim/istr_changelog.html
 """
 
+_0_to_Z = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
 class _range:
     """
@@ -195,7 +196,7 @@ class istr(str):
     _int_format = ""
     _repr_mode = "istr"
     _base = 10
-    _nan = "nan"
+    _nan = object()
     _force_istr_repr = False
     _digits_cache = {}
 
@@ -205,7 +206,7 @@ class istr(str):
             raise ValueError(f"negative numbers are not allowed for base {base}")
         result = ""
         while number:
-            result += "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[number % base]
+            result += _0_to_Z[number % base]
             number //= base
         return result[::-1] or "0"
 
@@ -223,7 +224,7 @@ class istr(str):
         operator = args[len(args) == 2]
         if len(args) == 2:
             other = args[0]
-            if not self.is_int() or self._to_int(other) == self._nan:
+            if not self.is_int() or self._to_int(other) is self._nan:
                 self.__class__._force_istr_repr = True
                 if right:
                     message = f"unsupported operand for {operator}: {repr(other)} and {repr(self)}"
@@ -263,7 +264,7 @@ class istr(str):
         if isinstance(value, str):
             as_str = value
         else:
-            if as_int == cls._nan:
+            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:
@@ -278,7 +279,7 @@ class istr(str):
         if self._repr_mode == "istr":
             self._as_repr = f"{cls.__name__}({repr(as_str)})"
         elif self._repr_mode == "int":
-            self._as_repr = "nan" if as_int == self._nan else repr(as_int)
+            self._as_repr = "?" if as_int is self._nan else repr(as_int)
         else:
             self._as_repr = repr(as_str)
         return self
@@ -453,7 +454,7 @@ class istr(str):
         return len(self) == len(set(self))
 
     def is_int(self):
-        return self._as_int != self._nan
+        return self._as_int is not self._nan
 
     def reversed(self):
         return self[::-1]
@@ -569,7 +570,6 @@ class istr(str):
         key = (args, cls._base, cls._int_format, cls._repr_mode)
         if key in cls._digits_cache:
             return cls.digits_cache[key]
-        sequence = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         result = []
         if not args:
             args = ["0-9"]
@@ -580,9 +580,9 @@ class istr(str):
             if pre.strip() == "":
                 pre = "0"
             pre = pre.upper()
-            if len(pre) > 1 or pre not in sequence:
+            if len(pre) > 1 or pre not in _0_to_Z:
                 raise ValueError(f"incorrect specifier: {repr(arg)}")
-            start = sequence.index(pre)
+            start = _0_to_Z.index(pre)
 
             if post:
                 post = post[0]
@@ -592,14 +592,14 @@ class istr(str):
                     else:
                         post = "Z"
                 post = post.upper()
-                if len(post) > 1 or post not in sequence:
+                if len(post) > 1 or post not in _0_to_Z:
                     raise ValueError(f"incorrect specifier: {repr(arg)}")
-                stop = sequence.index(post)
+                stop = _0_to_Z.index(post)
                 if start > stop:
                     raise ValueError(f"incorrect specifier: {repr(arg)}")
             else:
                 stop = start
-            result.extend(sequence[i] for i in range(start, stop + 1))
+            result.extend(_0_to_Z[i] for i in range(start, stop + 1))
 
         result = istr("".join(result))
         cls._digits_cache[key] = result
@@ -679,8 +679,15 @@ class istr(str):
 
 
 def main():
-    ...
-
+    with istr.repr_mode("int"):
+        print(repr(istr(3)))
+        print(repr(istr("a")))
+        with istr.int_format("4"):
+            print(repr(istr(3)))
+            print(repr(istr("a")))
+        with istr.int_format("04"):
+            print(repr(istr(3)))
+            print(repr(istr("a")))
 
 if __name__ == "__main__":
     main()

{istr_python-1.0.1 → istr_python-1.0.2}/istr/readme.md

@@ -137,10 +137,10 @@ or even
 four, five = istr(4, 5)
 ```
 
-> > [!IMPORTANT]
-> >
-> > All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
-> > Also divisions are always floor divisions!
+##### Important
+>
+> All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
+> Also divisions are always floor divisions!
 
 #### Use istrs as string
 
@@ -175,12 +175,13 @@ And
 
 is also `istr('444')`
 
-> Note:
+##### Note
+
 >
 > It is not allowed to use the `@` operator for two istrs. So, `four @ five` raises a TypeError.
-
 #### istrs that can't be interpreted as an int
 
+
 Although usualy, istrs are to be interpreted as an int, that's not a requirement.
 
 So
@@ -221,7 +222,7 @@ is `False`.
 
 
 
-The bool operator works normally on the integer value of an istr. So
+The `bool` operator works normally on the integer value of an istr. So
 
 `bool(istr('0'))` ==> `False`
 `bool(istr('1'))` ==> `True`
@@ -238,6 +239,7 @@ For the `in` operator, an istr is treated as an ordinary string, although it is
 ```
 '34' in istr(1234)
 34 in istr(1234)
+
 ```
 On the left hand side an istr is always treated as a string:
 ```
@@ -267,47 +269,39 @@ is
 ```
 '0 1 2 3 4 5 6 7 8 9 10 11'
 ```
+#### Using values that are neither string or numeric to initialize istr
 
-#### Using values to inialitize istr other than numeric value or str
-Apart from with simple numeric (to be interpreted as an int) or str, istr can be initialized with
+Apart from with numeric (to be interpreted as an int) or str, istr can be initialized with
 several other types:
 
-- 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 a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
 
 - 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
-    ```
+    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
-  ```
+```
+  istr(range(3)) ==> istr.range(3)
+  list(istr(range(3))) ==> [istr('0'), istr('1'), istr('2')]
+  len(istr(range(3))) ==> 3
+```
 
 - if an istr.range instance, the same istr.range will be returned
 
 - if an istr, the same istr will be used
 
-    ```
+  ```
     istr(istr('4')) ==> istr ('4')
-    ```
+  ```
 
 #### More than one parameter for istr
 It is possible to give more than one parameter, in which case a tuple
@@ -342,7 +336,7 @@ istr(n100).all_distinct() ==> False
 
 #### reverse an istr
 
-The method `istr.reversed()` will return the an istr with the reversed content:
+The method `istr.reversed()` will return an istr with the reversed content:
 ```
 istr(456).reversed() ==> istr('654')
 istr('0456').reversed() ==> istr('6540')
@@ -352,13 +346,13 @@ The same can -of course- be achieved with
 istr(456)[::-1] ==> istr('654')
 istr('0456')[::-1] ==> istr('6540')
 ```
-> > [!NOTE]
-> >
-> > It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
-> >
-> > ```
-> > istr(-456) ==> TypeError
-> > ```
+##### Note
+>
+> It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
+>
+> ```
+> istr(-456).reversed() ==> TypeError
+> ```
 
 #### enumerate with istrs
 
@@ -366,8 +360,8 @@ The `istr.enumerate` method can be used just as the builtin enumerate function.
 The iteration counter however is an istr rather than an int. E.g. 
 
 ```
-    for i, c in istr.enumerate('abc'):
-        print(f'{repr(i)} {c}')
+for i, c in istr.enumerate('abc'):
+    print(f'{repr(i)} {c}')
 ```
 prints
 ```
@@ -401,7 +395,8 @@ The given argument(s) result in a range of digits.
 - `<n>` ==> n
 - `<n-m>` ==> n, n+1, ..., m
 - `-n>` ==> 0, 1, ... n
-- `n->` ==> n, n+1, ..., 9
+- `n->` ==> n, n+1, ..., 9 if n is numeric (0-9), n, n+1, ... Z if n is a letter
+- `'-'` ==> 0, 1, ..., 9
 - `''` ==> 0, 1, ..., 9
 
 (n and m must be digits between 0 and 9 or letters letters between A and Z)
@@ -447,9 +442,9 @@ will print `jstr('20')`
 
 It is possible to control the way an `istr` instance will be repr'ed.
 
-By default, the `istr(5)` is represented as `istr('5')`.
+By default, `istr(5)` is represented as `istr('5')`.
 
-With the istr.repr_mode() context manager, that can be changed:
+With the `istr.repr_mode()` context manager, that can be changed:
 ```
 with istr.repr_mode('str'):
     five = istr(5)
@@ -467,7 +462,7 @@ This will print
 5
 istr('5')
 ```
-If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `nan` (not a number) will be returned:
+If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `?` will be returned:
 
 ```
  with istr.repr_mode('int'):
@@ -478,12 +473,12 @@ If the repr_mode is `'int'` and the istr can't be interpreted as an int the stri
 This will print
 
 ```
-nan
+?
 ```
 
-> > [!NOTE]
-> >
-> > The way an `istr` is represented is determined at initialization.
+##### Note
+>
+> The way an `istr` is represented is determined at initialization.
 
 It is also possible to set the repr mode without a context manager:
 
@@ -517,13 +512,13 @@ with istr.base(16):
     a = istr('7fff')
     print(int(a))
 
-    b = istr(15)
+    b = istr(127)
     print(repr(b))
 ```
 This will result in
 ```
 32767
-istr('F')
+istr('7F')
 ```
 All calculations are done in the decimal 10 system.
 
@@ -546,7 +541,7 @@ will result in `10`.
 
 #### Changing the format of the string
 
-When an  istr is initialized with a string the istr will be just stored as such.
+When an  istr is initialized with a string the istr will be always stored as such.
 
 ```
 repr('4')) ==> istr('4')
@@ -560,7 +555,7 @@ For initializing with an int (or other numeric) value, the string is by default
 repr(4)) ==> istr('4')
 ```
 
- With the `istr.int_format()` context manager this behavior can be changed.
+With the `istr.int_format()` context manager this behavior can be changed.
 If the format specifier is a number, most likely a single digit, that
 will be the minimum number of characters in the string:
 
@@ -593,24 +588,10 @@ istr('012')
 istr('123')
 istr('1234')
 ```
-> > [!NOTE]
-> >
-> > if a string is used to initialize an istr AND that string can be interpreted as an int. the string will reformatted:
-> >
-> > ```
-> > with istr.int_format('03'):
-> >    print(repr(istr(12)))
-> > ```
-> >
-> > will result in
-> >
-> > ```
-> > istr('0012')
-> > ```
+
+##### Note
 >
-> > [!NOTE]
-> >
-> > For bases other than 10, the string will never be reformatted!
+> For bases other than 10, the string will never be reformatted!
 
 ### Overview of operations
 
@@ -650,6 +631,8 @@ There's an extensive pytest script in the `\tests` directory.
 
 This script also shows clearly the ways istr can be used, including several edge cases. Highly recommended to have a look at.
 
+
+
 ### Badges
 ![PyPI](https://img.shields.io/pypi/v/istr-python) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/istr-python) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/istr-python)
 

{istr_python-1.0.1 → istr_python-1.0.2}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: istr-python
-Version: 1.0.1
+Version: 1.0.2
 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
@@ -150,10 +150,10 @@ or even
 four, five = istr(4, 5)
 ```
 
-> > [!IMPORTANT]
-> >
-> > All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
-> > Also divisions are always floor divisions!
+##### Important
+>
+> All calculations are strictly integer calculations. That means that if a float or decimal variable is ever produced it will be converted to an int.
+> Also divisions are always floor divisions!
 
 #### Use istrs as string
 
@@ -188,12 +188,13 @@ And
 
 is also `istr('444')`
 
-> Note:
+##### Note
+
 >
 > It is not allowed to use the `@` operator for two istrs. So, `four @ five` raises a TypeError.
-
 #### istrs that can't be interpreted as an int
 
+
 Although usualy, istrs are to be interpreted as an int, that's not a requirement.
 
 So
@@ -234,7 +235,7 @@ is `False`.
 
 
 
-The bool operator works normally on the integer value of an istr. So
+The `bool` operator works normally on the integer value of an istr. So
 
 `bool(istr('0'))` ==> `False`
 `bool(istr('1'))` ==> `True`
@@ -251,6 +252,7 @@ For the `in` operator, an istr is treated as an ordinary string, although it is
 ```
 '34' in istr(1234)
 34 in istr(1234)
+
 ```
 On the left hand side an istr is always treated as a string:
 ```
@@ -280,47 +282,39 @@ is
 ```
 '0 1 2 3 4 5 6 7 8 9 10 11'
 ```
+#### Using values that are neither string or numeric to initialize istr
 
-#### Using values to inialitize istr other than numeric value or str
-Apart from with simple numeric (to be interpreted as an int) or str, istr can be initialized with
+Apart from with numeric (to be interpreted as an int) or str, istr can be initialized with
 several other types:
 
-- 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 a dict (or subtype of dict), the same type dict will be returned with all *values* istr'ed
 
 - 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
-    ```
+    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
-  ```
+```
+  istr(range(3)) ==> istr.range(3)
+  list(istr(range(3))) ==> [istr('0'), istr('1'), istr('2')]
+  len(istr(range(3))) ==> 3
+```
 
 - if an istr.range instance, the same istr.range will be returned
 
 - if an istr, the same istr will be used
 
-    ```
+  ```
     istr(istr('4')) ==> istr ('4')
-    ```
+  ```
 
 #### More than one parameter for istr
 It is possible to give more than one parameter, in which case a tuple
@@ -355,7 +349,7 @@ istr(n100).all_distinct() ==> False
 
 #### reverse an istr
 
-The method `istr.reversed()` will return the an istr with the reversed content:
+The method `istr.reversed()` will return an istr with the reversed content:
 ```
 istr(456).reversed() ==> istr('654')
 istr('0456').reversed() ==> istr('6540')
@@ -365,13 +359,13 @@ The same can -of course- be achieved with
 istr(456)[::-1] ==> istr('654')
 istr('0456')[::-1] ==> istr('6540')
 ```
-> > [!NOTE]
-> >
-> > It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
-> >
-> > ```
-> > istr(-456) ==> TypeError
-> > ```
+##### Note
+>
+> It is possible to reverse a negative istr, but the result can't be interpreted as an int anymore.
+>
+> ```
+> istr(-456).reversed() ==> TypeError
+> ```
 
 #### enumerate with istrs
 
@@ -379,8 +373,8 @@ The `istr.enumerate` method can be used just as the builtin enumerate function.
 The iteration counter however is an istr rather than an int. E.g. 
 
 ```
-    for i, c in istr.enumerate('abc'):
-        print(f'{repr(i)} {c}')
+for i, c in istr.enumerate('abc'):
+    print(f'{repr(i)} {c}')
 ```
 prints
 ```
@@ -414,7 +408,8 @@ The given argument(s) result in a range of digits.
 - `<n>` ==> n
 - `<n-m>` ==> n, n+1, ..., m
 - `-n>` ==> 0, 1, ... n
-- `n->` ==> n, n+1, ..., 9
+- `n->` ==> n, n+1, ..., 9 if n is numeric (0-9), n, n+1, ... Z if n is a letter
+- `'-'` ==> 0, 1, ..., 9
 - `''` ==> 0, 1, ..., 9
 
 (n and m must be digits between 0 and 9 or letters letters between A and Z)
@@ -460,9 +455,9 @@ will print `jstr('20')`
 
 It is possible to control the way an `istr` instance will be repr'ed.
 
-By default, the `istr(5)` is represented as `istr('5')`.
+By default, `istr(5)` is represented as `istr('5')`.
 
-With the istr.repr_mode() context manager, that can be changed:
+With the `istr.repr_mode()` context manager, that can be changed:
 ```
 with istr.repr_mode('str'):
     five = istr(5)
@@ -480,7 +475,7 @@ This will print
 5
 istr('5')
 ```
-If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `nan` (not a number) will be returned:
+If the repr_mode is `'int'` and the istr can't be interpreted as an int the string `?` will be returned:
 
 ```
  with istr.repr_mode('int'):
@@ -491,12 +486,12 @@ If the repr_mode is `'int'` and the istr can't be interpreted as an int the stri
 This will print
 
 ```
-nan
+?
 ```
 
-> > [!NOTE]
-> >
-> > The way an `istr` is represented is determined at initialization.
+##### Note
+>
+> The way an `istr` is represented is determined at initialization.
 
 It is also possible to set the repr mode without a context manager:
 
@@ -530,13 +525,13 @@ with istr.base(16):
     a = istr('7fff')
     print(int(a))
 
-    b = istr(15)
+    b = istr(127)
     print(repr(b))
 ```
 This will result in
 ```
 32767
-istr('F')
+istr('7F')
 ```
 All calculations are done in the decimal 10 system.
 
@@ -559,7 +554,7 @@ will result in `10`.
 
 #### Changing the format of the string
 
-When an  istr is initialized with a string the istr will be just stored as such.
+When an  istr is initialized with a string the istr will be always stored as such.
 
 ```
 repr('4')) ==> istr('4')
@@ -573,7 +568,7 @@ For initializing with an int (or other numeric) value, the string is by default
 repr(4)) ==> istr('4')
 ```
 
- With the `istr.int_format()` context manager this behavior can be changed.
+With the `istr.int_format()` context manager this behavior can be changed.
 If the format specifier is a number, most likely a single digit, that
 will be the minimum number of characters in the string:
 
@@ -606,24 +601,10 @@ istr('012')
 istr('123')
 istr('1234')
 ```
-> > [!NOTE]
-> >
-> > if a string is used to initialize an istr AND that string can be interpreted as an int. the string will reformatted:
-> >
-> > ```
-> > with istr.int_format('03'):
-> >    print(repr(istr(12)))
-> > ```
-> >
-> > will result in
-> >
-> > ```
-> > istr('0012')
-> > ```
+
+##### Note
 >
-> > [!NOTE]
-> >
-> > For bases other than 10, the string will never be reformatted!
+> For bases other than 10, the string will never be reformatted!
 
 ### Overview of operations
 
@@ -663,6 +644,8 @@ There's an extensive pytest script in the `\tests` directory.
 
 This script also shows clearly the ways istr can be used, including several edge cases. Highly recommended to have a look at.
 
+
+
 ### Badges
 ![PyPI](https://img.shields.io/pypi/v/istr-python) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/istr-python) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/istr-python)
 

{istr_python-1.0.1 → istr_python-1.0.2}/pyproject.toml

@@ -8,7 +8,7 @@ authors = [
     {name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com"}
 ]
 description = "istr - strings you can count on"
-version = "1.0.1"
+version = "1.0.2"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = [