istr-python 0.0.0__tar.gz

istr-python-0.0.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: istr-python
+Version: 0.0.0
+Summary: istr description
+Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Introduction
+
+The istrlib 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.
+
+# Installation
+Installing istrlib with pip is easy.
+```
+$ pip install istrlib
+```
+or when you want to upgrade,
+```
+$ pip install istrlib --upgrade
+```
+
+Alternatively, istrlib.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istrlib).
+
+No dependencies!
+
+# Usage
+Just start with
+
+```
+from istrlib 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("40")`
+
+And now we can do
+```
+print(x == 40)
+print(x == "40")
+```
+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 < 50)
+print(x >= "30")
+```
+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'`
+

istr-python-0.0.0/README.md

@@ -0,0 +1,115 @@
+# Introduction
+
+The istrlib 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.
+
+# Installation
+Installing istrlib with pip is easy.
+```
+$ pip install istrlib
+```
+or when you want to upgrade,
+```
+$ pip install istrlib --upgrade
+```
+
+Alternatively, istrlib.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istrlib).
+
+No dependencies!
+
+# Usage
+Just start with
+
+```
+from istrlib 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("40")`
+
+And now we can do
+```
+print(x == 40)
+print(x == "40")
+```
+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 < 50)
+print(x >= "30")
+```
+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'`
+

istr-python-0.0.0/istr/install istr.py

@@ -0,0 +1,219 @@
+from __future__ import print_function
+
+import sys
+import site
+import shutil
+import hashlib
+import base64
+from pathlib import Path
+import configparser
+import six
+from six.moves import urllib
+
+# import urllib.request
+# import urllib.error
+
+
+def _install(files, url=None):
+    """
+    install one file package from GitHub or current directory
+
+    Parameters
+    ----------
+    files : list
+        files to be installed
+        the first item (files[0]) will be used as the name of the package''
+        optional files should be preceded with an exclamation mark (!)
+
+    url : str
+        url of the location of the GitHub repository
+        this will start usually with https://raw.githubusercontent.com/ and end with /master/
+        if omitted, the files will be copied from the current directory (not GitHub)
+
+
+    Returns
+    -------
+    info : Info instance
+        info.package : name of the package installed
+        info.path : name where the package is installed in the site-packages
+        info.version : version of the package (obtained from <package>.py)
+        info.files_copied : list of copied files
+
+    Notes
+    -----
+    The program automatically makes the required __init__.py file (unless given in files) and
+    <package><version>.dist-info folder with the usual files METADATA, INSTALLER and RECORDS.
+    As the setup.py is not run, the METADATA is very limited, i.e. is contains just name and version.
+
+    If a __init__.py is in files that file will be used.
+    Otherwise, an __init__/py file will be generated. In thet case, if a __version__ = statement
+    is found in the source file, the __version__ will be included in that __init__.py file.
+
+    Version history
+    ---------------
+    version 1.0.5  2020-06-24
+        Bug with removing the dist-info of packages starting with the same name fixed.
+
+    version 1.0.4  2020-03-29
+        Linux and ios versions now search in sys.path for site-packages,
+        whereas other platforms now use site.getsitepackages().
+        This is to avoid installation in a roaming directory on Windows.
+
+    version 1.0.2  2020-03-07
+        modified several open calls to be compatible with Python < 3.6
+        multipe installation for Pythonista removed. Now installs only in site-packages
+
+    version 1.0.1  2020-03-06
+        now uses urllib instead of requests to avoid non standard libraries
+        installation for Pythonista improved
+
+    version 1.0.0  2020-03-04
+        initial version
+
+    (c)2020 Ruud van der Ham - www.salabim.org
+    """
+
+    class Info:
+        version = "?"
+        package = "?"
+        path = "?"
+        files_copied = []
+
+    info = Info()
+    Pythonista = sys.platform == "ios"
+    if not files:
+        raise ValueError("no files specified")
+    if files[0][0] == "!":
+        raise ValueError("first item in files (sourcefile) may not be optional")
+    package = Path(files[0]).stem
+    sourcefile = files[0]
+
+    file_contents = {}
+    for file in files:
+        optional = file[0] == "!"
+        if optional:
+            file = file[1:]
+
+        if url:
+            try:
+                with urllib.request.urlopen(url + file) as response:
+                    page = response.read()
+
+                file_contents[file] = page
+                exists = True
+            except urllib.error.URLError:
+                exists = False
+
+        else:
+            exists = Path(file).is_file()
+            if exists:
+                with open(file, "rb") as f:
+                    file_contents[file] = f.read()
+
+        if (not exists) and (not optional):
+            raise FileNotFoundError(file + " not found. Nothing installed.")
+
+    version = "unknown"
+    for line in file_contents[sourcefile].decode("utf-8").split("\n"):
+        line_split = line.split("__version__ =")
+        if len(line_split) > 1:
+            raw_version = line_split[-1].strip(" '\"")
+            version = ""
+            for c in raw_version:
+                if c in "0123456789-.":
+                    version += c
+                else:
+                    break
+            break
+
+    info.files_copied = list(file_contents.keys())
+    info.package = package
+    info.version = version
+
+    file = "__init__.py"
+    if file not in file_contents:
+        file_contents[file] = ("from ." + package + " import *\n").encode()
+        if version != "unknown":
+            file_contents[file] += ("from ." + package + " import __version__\n").encode()
+    if sys.platform.startswith("linux") or (sys.platform == "ios"):
+        search_in = sys.path
+    else:
+        search_in = site.getsitepackages()
+
+    for f in search_in:
+        sitepackages_path = Path(f)
+        if sitepackages_path.name == "site-packages" and sitepackages_path.is_dir():
+            break
+    else:
+        raise ModuleNotFoundError("can't find the site-packages folder")
+
+    path = sitepackages_path / package
+    info.path = str(path)
+
+    if path.is_file():
+        path.unlink()
+
+    if not path.is_dir():
+        path.mkdir()
+
+    for file, contents in file_contents.items():
+        with (path / file).open("wb") as f:
+            f.write(contents)
+
+    if Pythonista:
+        pypi_packages = sitepackages_path / ".pypi_packages"
+        config = configparser.ConfigParser()
+        config.read(pypi_packages)
+        config[package] = {}
+        config[package]["url"] = "pypi"
+        config[package]["version"] = version
+        config[package]["summary"] = ""
+        config[package]["files"] = path.as_posix()
+        config[package]["dependency"] = ""
+        with pypi_packages.open("w") as f:
+            config.write(f)
+    else:
+        for entry in sitepackages_path.glob("*"):
+            if entry.is_dir():
+                if entry.stem.startswith(package + "-") and entry.suffix == ".dist-info":
+                    shutil.rmtree(str(entry))
+        path_distinfo = Path(str(path) + "-" + version + ".dist-info")
+        if not path_distinfo.is_dir():
+            path_distinfo.mkdir()
+        with open(str(path_distinfo / "METADATA"), "w") as f:  # make a dummy METADATA file
+            f.write("Name: " + package + "\n")
+            f.write("Version: " + version + "\n")
+
+        with open(str(path_distinfo / "INSTALLER"), "w") as f:  # make a dummy METADATA file
+            f.write("github\n")
+        with open(str(path_distinfo / "RECORD"), "w") as f:
+            pass  # just to create the file to be recorded
+
+        with open(str(path_distinfo / "RECORD"), "w") as record_file:
+            for p in (path, path_distinfo):
+                for file in p.glob("**/*"):
+                    if file.is_file():
+                        name = file.relative_to(sitepackages_path).as_posix()  # make sure we have slashes
+                        record_file.write(name + ",")
+
+                        if (file.stem == "RECORD" and p == path_distinfo) or ("__pycache__" in name.lower()):
+                            record_file.write(",")
+                        else:
+                            with file.open("rb") as f:
+                                file_contents = f.read()
+                                hash = "sha256=" + base64.urlsafe_b64encode(hashlib.sha256(file_contents).digest()).decode("latin1").rstrip("=")
+                                # hash calculation derived from wheel.py in pip
+
+                                length = str(len(file_contents))
+                                record_file.write(hash + "," + length)
+
+                        record_file.write("\n")
+
+    return info
+
+
+if __name__ == "__main__":
+    info = _install(files="istr.py !changelog.txt".split())
+    print(info.package + " " + info.version + " successfully installed in " + info.path)
+    print("files copied: ", ", ".join(info.files_copied))
+

istr-python-0.0.0/istr/istr.py

@@ -0,0 +1,352 @@
+from functools import partial
+import math
+import contextlib
+
+
+class istr(str):
+    """
+    istr object
+
+    Parameters
+    ----------
+    value : any
+        value to store
+
+
+    """
+
+    _format = ""
+
+    @classmethod
+    def toint(cls, value):
+        if isinstance(value, cls):
+            return value.asint
+        if isinstance(value, str):
+            if value == "":
+                return 0
+        return int(value)
+
+    @classmethod
+    def check_format(cls, format):
+        if format is None:
+            return cls._format
+        if not (isinstance(format, str) and all(x in "0123456789" for x in format)):
+            raise ValueError(f"{repr(format)} is incorrect format")
+        return format
+
+    def __new__(cls, value=""):
+        if isinstance(value, range):
+            return cls.range(value.start, value.stop, value.step)
+        if not isinstance(value, str) 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))
+        else:
+            return super().__new__(cls, f"{cls.toint(value):{cls._format}}")
+
+    def __init__(self, value=""):
+        self.asint = self.toint(value)
+        super().__init__()
+
+    def __hash__(self):
+        return hash((self.__class__, self.asint))
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.asint == other.asint
+        if isinstance(other, str):
+            return super().__eq__(other)
+        try:
+            return self.asint == self.toint(other)
+        except Exception:
+            return False
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __contains__(self, other):
+        return super().__contains__(str(other))
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+    def __le__(self, other):
+        return self.asint <= self.toint(other)
+
+    def __lt__(self, other):
+        return self.asint < self.toint(other)
+
+    def __ge__(self, other):
+        return self.asint >= self.toint(other)
+
+    def __gt__(self, other):
+        return self.asint > self.toint(other)
+
+    def __add__(self, other):
+        return self.__class__(self.asint + self.toint(other))
+
+    def __sub__(self, other):
+        return self.__class__(self.asint - self.toint(other))
+
+    def __mul__(self, other):
+        return self.__class__(self.asint * self.toint(other))
+
+    def __floordiv__(self, other):
+        return self.__class__(self.asint // self.toint(other))
+
+    def __rfloordiv__(self, other):
+        return self.__class__(self.toint(other) // self.asint)
+
+    def __truediv__(self, other):
+        return self.__class__(self.asint // self.toint(other))
+
+    def __rtruediv__(self, other):
+        return self.__class__(self.toint(other) // self.asint)
+
+    def __pow__(self, other):
+        return self.__class__(self.asint ** self.toint(other))
+
+    def __rpow__(self, other):
+        return self.__class__(self.toint(other) ** self.asint)
+
+    def __radd__(self, other):
+        return self.__class__(self.toint(other) + self.asint)
+
+    def __rsub__(self, other):
+        return self.__class__(self.toint(other) - self.asint)
+
+    def __rmul__(self, other):
+        return self.__class__(self.toint(other) * self.asint)
+
+    def __mod__(self, other):
+        return self.__class__(self.asint % self.toint(other))
+
+    def __rmod__(self, other):
+        return self.__class__(self.toint(other) % self.asint)
+
+    def __or__(self, other):
+        return self.__class__("".join((self, self.__class__(other))))
+
+    def __ror__(self, other):
+        return self.__class__("".join((self.__class__(other), self)))
+
+    def __int__(self):
+        return int(self.asint)
+
+    def __round__(self):
+        return self.__class__(round(self.asint))
+
+    def __trunc__(self):
+        return self.__class__(math.trunc(self.asint))
+
+    def __floor__(self):
+        return self.__class__(math.floor(self.asint))
+
+    def __ceil__(self):
+        return self.__class__(math.ceil(self.asint))
+
+    def __matmul__(self, other):
+        return self.__class__(super().__mul__(other))
+
+    def __rmatmul__(self, other):
+        return self.__class__(super().__rmul__(other))
+
+    def __divmod__(self, other):
+        return self.__class__(divmod(self.asint, self.toint(other)))
+
+    def __rdivmod__(self, other):
+        return self.__class__(divmod(self.toint(other), self.asint))
+
+    def __neg__(self):
+        return self.__class__(-self.asint)
+
+    def __pos__(self):
+        return self
+
+    def __abs__(self):
+        return self.__class__(abs(self.asint))
+
+    def is_even(self):
+        return self.asint % 2 == 0
+
+    def is_odd(self):
+        return self.asint % 2 == 1
+
+    def join(self, iterable):
+        s = super().join(iterable)
+        return self.__class__(s)
+
+    @classmethod
+    def enumerate(cls, iterable, start=0):
+        for i, value in enumerate(iterable, start):
+            yield cls(i), value
+
+    @classmethod
+    @contextlib.contextmanager
+    def format(cls, format):
+        saved_format = cls._format
+        cls._format = cls.check_format(format)
+        yield
+        cls._format = saved_format
+
+    @classmethod
+    def default_format(cls, format=None):
+        if format is not None:
+            cls._format = cls.check_format(format)
+        return cls._format
+
+    @classmethod
+    class range:
+        """
+        based on https://codereview.stackexchange.com/questions/229073/pure-python-range-implementation
+        """
+
+        def __init__(self, cls, start, stop=None, step=1):
+            if stop is None:
+                start, stop = 0, start
+            self.start, self.stop, self.step = (int(obj) for obj in (start, stop, step))
+            if step == 0:
+                raise ValueError("range() arg 3 must not be zero")
+            if self.step < 0:
+                step_sign = -1
+            else:
+                step_sign = 1
+            self._len = max(1 + (self.stop - self.start - step_sign) // self.step, 0)
+            self.parent_cls = cls
+
+        def __contains__(self, value):
+            if isinstance(value, int):
+                return self._index(value) != -1
+            return any(n == value for n in self)
+
+        def __eq__(self, other):
+            if not isinstance(other, type(self)):
+                return False
+            if self._len != len(other):
+                return False
+            if self._len == 0:
+                return True
+            if self.start != other.start:
+                return False
+            if self[-1] == other[-1]:
+                return True
+            return False
+
+        def __getitem__(self, index):
+            def adjust_indices(length, start, stop, step):
+                if step is None:
+                    step = 1
+                else:
+                    step = int(step)
+
+                if start is None:
+                    start = length - 1 if step < 0 else 0
+                else:
+                    start = int(start)
+                    if start < 0:
+                        start += length
+                        if start < 0:
+                            start = -1 if step < 0 else 0
+                    elif start >= length:
+                        start = length - 1 if step < 0 else length
+
+                if stop is None:
+                    stop = -1 if step < 0 else length
+                else:
+                    stop = int(stop)
+                    if stop < 0:
+                        stop += length
+                        if stop < 0:
+                            stop = -1 if step < 0 else 0
+                    elif stop >= length:
+                        stop = length - 1 if step < 0 else length
+
+                return start, stop, step
+
+            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)
+            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)
+
+        def __hash__(self):
+            if self._len == 0:
+                return id(self.parent_cls.range)
+            return hash((self._len, self.start, int(self[-1])))
+
+        def __iter__(self):
+            value = self.start
+            if self.step > 0:
+                while value < self.stop:
+                    yield self.parent_cls(value)
+                    value += self.step
+            else:
+                while value > self.stop:
+                    yield self.parent_cls(value)
+                    value += self.step
+
+        def __len__(self):
+            return self._len
+
+        def __repr__(self):
+            if self.step == 1:
+                return f"{self.parent_cls.__name__}.range({self.start}, {self.stop})"
+            return f"{self.parent_cls.__name__}.range({self.start}, {self.stop}, {self.step})"
+
+        def __reversed__(self):
+            return iter(self[::-1])
+
+        def _index(self, value):
+            index_mul_step = value - self.start
+            if index_mul_step % self.step:
+                return -1
+            index = index_mul_step // self.step
+            if 0 <= index < self._len:
+                return index
+            return -1
+
+        def count(self, value):
+            """
+            Rangeobject.count(value) -> integer
+            Return number of occurrences of value.
+            """
+            return sum(1 for n in self if int(n) == int(value))
+
+        def index(self, value, start=0, stop=None):
+            if start < 0:
+                start = max(self._len + start, 0)
+            if stop is None:
+                stop = self._len
+            if stop < 0:
+                stop += self._len
+
+            if isinstance(value, int):
+                index = self._index(value)
+                if start <= index < stop:
+                    return index
+                raise ValueError(f"{value} is not in range")
+
+            i = start
+            n = self.start + self.step * i
+            while i < stop:
+                if n == int(value):
+                    return i
+                i += 1
+                n += self.step
+            raise ValueError(f"{value} is not in range")
+
+
+def main():
+    print(repr(istr("").join(istr.range(5))))
+
+
+if __name__ == "__main__":
+    main()
+

istr-python-0.0.0/istr_python.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: istr-python
+Version: 0.0.0
+Summary: istr description
+Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Introduction
+
+The istrlib 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.
+
+# Installation
+Installing istrlib with pip is easy.
+```
+$ pip install istrlib
+```
+or when you want to upgrade,
+```
+$ pip install istrlib --upgrade
+```
+
+Alternatively, istrlib.py can be just copied into you current work directory from GitHub (https://github.com/salabim/istrlib).
+
+No dependencies!
+
+# Usage
+Just start with
+
+```
+from istrlib 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("40")`
+
+And now we can do
+```
+print(x == 40)
+print(x == "40")
+```
+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 < 50)
+print(x >= "30")
+```
+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'`
+

istr-python-0.0.0/istr_python.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+istr/__init__.py
+istr/install istr.py
+istr/istr.py
+istr_python.egg-info/PKG-INFO
+istr_python.egg-info/SOURCES.txt
+istr_python.egg-info/dependency_links.txt
+istr_python.egg-info/top_level.txt
+test/test_istrlib.py

istr-python-0.0.0/istr_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

istr-python-0.0.0/istr_python.egg-info/top_level.txt

@@ -0,0 +1 @@
+istr

istr-python-0.0.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "istr-python"
+authors = [
+    {name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com"}
+]
+description = "istr description"
+version = "0.0.0"
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+]

istr-python-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

istr-python-0.0.0/test/test_istrlib.py

@@ -0,0 +1,362 @@
+from __future__ import print_function
+from __future__ import division
+from istrlib import istr
+import math
+
+import pytest
+
+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)
+
+
+def test_arithmetic():
+    assert two + three == "5"
+    assert two + three == five
+    assert 2 + three == five
+    assert two + 3 == five
+
+    assert two - three == "-1"
+    assert two - three == minus_one
+    assert 2 - three == minus_one
+    assert two - 3 == minus_one
+
+    assert two * three == "6"
+    assert two * three == six
+    assert 2 * three == six
+    assert two * 3 == six
+
+    assert twelve // three == "4"
+    assert twelve // three == four
+    assert 12 // three == four
+    assert twelve // 3 == four
+
+    assert twelve / three == "4"
+    assert twelve / three == four
+    assert 12 / three == four
+    assert twelve / 3 == four
+
+    assert thirteen / three == "4"
+    assert thirteen / three == four
+    assert 13 / three == four
+    assert thirteen / 3 == four
+
+    assert twelve % five == 2
+    assert twelve % 5 == 2
+    assert 12 % five == 2
+
+    assert twelve % five == "2"
+    assert twelve % 5 == "2"
+    assert 12 % five == "2"
+
+    assert two**three == "8"
+    assert two**3 == "8"
+    assert 2**three == "8"
+
+
+def test_lt():
+    assert two < three
+    assert 2 < three
+    assert two < 3
+
+    assert not three < two
+    assert not 3 < two
+    assert not three < 2
+
+    assert not two < two
+    assert not 2 < two
+    assert not two < 2
+
+
+def test_le():
+    assert two <= three
+    assert 2 <= three
+    assert two <= 3
+
+    assert two <= two
+    assert 2 <= two
+    assert two <= two
+
+
+def test_gt():
+    assert three > two
+    assert 3 > two
+    assert three > 2
+
+    assert not two > three
+    assert not 2 > three
+    assert not two > 3
+
+    assert not three > three
+    assert not 3 > three
+    assert not three > 3
+
+
+def test_ge():
+    assert three >= two
+    assert 3 >= two
+    assert three >= 2
+
+    assert three >= three
+    assert 3 >= three
+    assert three >= three
+
+
+def test_eq():
+    assert two == istr("2")
+    assert two == 2
+    assert two == "2"
+    assert 2 == two
+    assert "2" == two
+
+    assert not two == "ab"
+    assert not two == istr
+
+
+def test_ne():
+    assert not two != istr("2")
+    assert not two != 2
+    assert not two != "2"
+    assert not 2 != two
+    assert not "2" != two
+
+    assert two != "ab"
+    assert two != istr
+
+
+def test_order():
+    assert " ".join(sorted(istr.range(1, 13))) == "1 2 3 4 5 6 7 8 9 10 11 12"
+    assert " ".join(sorted(map(istr, range(1, 13)))) == "1 2 3 4 5 6 7 8 9 10 11 12"
+
+
+def test_range():
+    assert one_to_twelve == istr.range("1", "13")
+    assert one_to_twelve == istr.range(one, thirteen, one)
+    assert one_to_twelve == istr(range(1, 13))
+
+    assert len(one_to_twelve) == 12
+    assert 2 in one_to_twelve
+    assert "2" in one_to_twelve
+    assert two in one_to_twelve
+
+    assert 13 not in one_to_twelve
+    assert "13" not in one_to_twelve
+    assert thirteen not in one_to_twelve
+
+    assert one_to_twelve[2] == 3
+    assert one_to_twelve[2] == "3"
+    assert one_to_twelve[2] == three
+
+    assert one_to_twelve[2:4] == istr.range(3, 5)
+
+    with pytest.raises(IndexError):
+        a = one_to_twelve[12]
+
+
+def test_misc():
+    assert istr("") == ""
+    assert istr("") == 0
+    with pytest.raises(ValueError):
+        istr(" ")
+    assert istr(istr(6)) == "6"
+    assert istr(" 12 ") == " 12 "
+    with istr.format("03"):
+        assert istr(" 12 ") == "012"
+        assert istr("")==""
+
+
+def test_divmod():
+    assert divmod(eleven, three) == (istr(3), istr(2))
+    assert divmod(11, three) == (istr(3), istr(2))
+    assert divmod(eleven, 3) == (istr(3), istr(2))
+    assert divmod(11, 3) == (3, 2)
+
+
+def test_iter():
+    assert [x for x in istr.range(3)] == [istr(0), istr(1), istr(2)]
+
+
+def test_reversed():
+    assert [x for x in reversed(istr.range(3))] == [istr(2), istr(1), istr(0)]
+
+
+def test_lazy():
+    for x in istr.range(10000000000000000000000000):
+        if x == four:
+            break
+    assert x == 4
+
+    for x in istr(range(10000000000000000000)):
+        if x == four:
+            break
+    assert x == 4
+
+
+def test_str_repr():
+    assert repr(one) == "istr('1')"
+    assert str(one) == "1"
+    assert f"{one}" == "1"
+    assert repr(one_to_twelve) == "istr.range(1, 13)"
+    assert repr(istr.range(10)) == "istr.range(0, 10)"
+    assert repr(istr.range(one, two, three)) == "istr.range(1, 2, 3)"
+
+    assert str(one_to_twelve) == "istr.range(1, 13)"
+    assert str(istr.range(10)) == "istr.range(0, 10)"
+    assert str(istr.range(one, two, three)) == "istr.range(1, 2, 3)"
+
+
+def test_index():
+    assert (one_to_twelve.index(2)) == 1
+    assert (one_to_twelve.index(two)) == 1
+    assert (one_to_twelve.index("2")) == 1
+    with pytest.raises(ValueError):
+        one_to_twelve.index(13)
+    with pytest.raises(ValueError):
+        one_to_twelve.index(thirteen)
+    with pytest.raises(ValueError):
+        one_to_twelve.index("13")
+
+
+def test_count():
+    assert one_to_twelve.count(2) == 1
+    assert one_to_twelve.count(two) == 1
+    assert one_to_twelve.count("2") == 1
+    assert one_to_twelve.count(13) == 0
+    assert one_to_twelve.count(thirteen) == 0
+    assert one_to_twelve.count("13") == 0
+
+
+def test_hash():
+    assert hash(istr.range(1, 13)) == hash(one_to_twelve)
+    assert hash(istr.range(1, 12)) != hash(one_to_twelve)
+
+
+def test_format():
+    assert istr(" 1 ") == " 1 "
+    with istr.format("0"):
+        assert istr(" 1 ") == "1"
+    with istr.format("03"):
+        assert istr(1) == "001"
+        assert istr(1234) == "1234"
+    with istr.format("3"):
+        assert istr(1) == "  1"
+        assert istr(1234) == "1234"
+    with istr.format(""):
+        assert istr(1234) == "1234"
+    with istr.format("003"):
+        assert istr(1) == "001"
+    with pytest.raises(ValueError):
+        with istr.format(" 1"):
+            ...
+    with pytest.raises(ValueError):
+        with istr.format("1 "):
+            ...
+    with pytest.raises(ValueError):
+        with istr.format("a"):
+            ...
+    with pytest.raises(ValueError):
+        with istr.format(1):
+            ...
+    with istr.format("0"):
+        assert istr(" 3 ") == "3"
+    assert istr.default_format() == ""
+    istr.default_format("03")
+    assert istr.default_format() == "03"
+    assert istr("  8 ") == "008"
+    istr.default_format("")
+    assert istr(" 8 ") == " 8 "
+
+
+def test_range_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.format("02"):
+        assert " ".join(r) == "00 01 02 03 04 05 06 07 08 09 10"
+
+
+def test_even_odd():
+    assert istr(1).is_odd()
+    assert not istr(1).is_even()
+
+    assert istr(12345678).is_even()
+    assert not istr(12345678).is_odd()
+
+
+def test_join():
+    s = "".join(istr(("4", "5", "6")))
+    assert s == "456"
+    assert type(s) == str
+
+    s = istr("").join(("4", "5", "6"))
+    assert s == "456"
+    assert s == 456
+    assert type(s) == istr
+
+    s = istr("").join(istr(("4", "5", "6")))
+    assert s == "456"
+    assert s == 456
+    assert type(s) == istr
+
+    s = istr("").join(istr(("", "", "6")))
+    assert s == "6"
+    assert s == 6
+    assert type(s) == istr
+
+
+def test_matmul():
+    assert five @ 3 == "555"
+    assert five @ 3 == 555
+
+    assert 3 @ five == "555"
+    assert 3 @ five == 555
+
+    with pytest.raises(TypeError):
+        three @ five
+    with pytest.raises(TypeError):
+        three @ "5"
+    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')"
+
+
+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 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 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_edge_cases():
+    with pytest.raises(ValueError):
+        istr("ab")
+    with pytest.raises(TypeError):
+        istr(istr)
+    assert repr(istr(istr(one))) == "istr('1')"
+
+
+if __name__ == "__main__":
+    pytest.main(["-vv", "-s", "-x", __file__])
+