istr-python 0.1.3__0-py3-none-any.whl

istr/__init__.py

@@ -0,0 +1,2 @@
+from .istr import *
+from .istr import __version__

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/istr.py

@@ -0,0 +1,584 @@
+import functools
+import math
+
+#     _       _
+#    (_) ___ | |_  _ __
+#    | |/ __|| __|| '__|
+#    | |\__ \| |_ | |
+#    |_||___/ \__||_|
+# strings you can count on
+
+__version__ = "0.1.3.0"
+import functools
+import math
+
+"""
+changelog
+
+version 0.1.2  2024-04-26  
+-------------------------
+Added all relevant string methods to return istrs or data structures with istrs.
+Added corresponding tests.
+
+version 0.1.0  2024-04-22  
+-------------------------
+Changed the way istr.range is implemennted.
+
+Changed the context manager istr.format() to be used directly without the with statement.
+Also, noww istr.format() works without any argument and then returns the current format.
+
+istr class now uses __slots__
+
+All internal values and methods now start with an underscore.
+
+Introduced istr.repr_mode()
+
+Introduced istr.base()
+
+Extended tests for new functionality
+
+
+version 0.0.8  2024-04-18  
+-------------------------
+initial version with changelog
+"""
+
+
+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")
+
+
+class istr(str):
+    """
+    istr object
+
+    Parameters
+    ----------
+    value : any
+        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")"""
+
+    __slots__ = ("_as_int", "_as_repr")
+
+    _format = ""
+    _mode = "istr"
+    _base = 10
+
+    @staticmethod
+    def _to_base(number, base):
+        if number < 0:
+            raise ValueError(f"negative numbers are not allowed for base {base}")
+        result = ""
+        while number:
+            result += "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[number % base]
+            number //= base
+        return result[::-1] or "0"
+
+    @classmethod
+    def _to_int(cls, value):
+        try:
+            if cls._base != 10 and isinstance(value, str):
+                return int(value, cls._base)
+            else:
+                return int(value)
+        except (ValueError, TypeError):
+            raise ValueError(f"unable to convert {repr(value)} to int (base {cls._base})")
+
+    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 isinstance(value, _range):
+            return value
+        if isinstance(value, cls):
+            return value
+        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__"):
+                return map(functools.partial(cls), value)
+            return type(value)(map(functools.partial(cls), value))
+        if value == "":
+            as_str = ""
+            as_int = 0
+        else:
+            as_int = cls._to_int(value)
+            if (cls._format == "" or cls._base != 10) and not isinstance(value, istr):
+                if isinstance(value, str):
+                    as_str = value
+                else:
+                    if cls._base == 10:
+                        as_str = str(as_int)
+                    else:
+                        as_str = istr._to_base(as_int, cls._base)
+            else:
+                as_str = f"{as_int:{cls._format}}"
+
+        self = super().__new__(cls, as_str)
+        self._as_int = as_int
+        if self._mode == "istr":
+            self._as_repr = f"{cls.__name__}({repr(as_str)})"
+        elif self._mode == "int":
+            self._as_repr = repr(as_int)
+        else:
+            self._as_repr = repr(as_str)
+        return self
+
+    def __hash__(self):
+        return hash((self.__class__, str(self)))
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self._as_int == other._as_int
+        if isinstance(other, str):
+            return super().__eq__(other)
+        try:
+            return self._as_int == self._to_int(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 self._as_repr
+
+    def __le__(self, other):
+        return self._as_int <= self._to_int(other)
+
+    def __lt__(self, other):
+        return self._as_int < self._to_int(other)
+
+    def __ge__(self, other):
+        return self._as_int >= self._to_int(other)
+
+    def __gt__(self, other):
+        return self._as_int > self._to_int(other)
+
+    def __bool__(self):
+        return bool(self._as_int)
+
+    def __add__(self, other):
+        return self.__class__(self._as_int + self._to_int(other))
+
+    def __sub__(self, other):
+        return self.__class__(self._as_int - self._to_int(other))
+
+    def __mul__(self, other):
+        return self.__class__(self._as_int * self._to_int(other))
+
+    def __floordiv__(self, other):
+        return self.__class__(self._as_int // self._to_int(other))
+
+    def __rfloordiv__(self, other):
+        return self.__class__(self._to_int(other) // self._as_int)
+
+    def __truediv__(self, other):
+        return self.__class__(self._as_int // self._to_int(other))
+
+    def __rtruediv__(self, other):
+        return self.__class__(self._to_int(other) // self._as_int)
+
+    def __pow__(self, other):
+        return self.__class__(self._as_int ** self._to_int(other))
+
+    def __rpow__(self, other):
+        return self.__class__(self._to_int(other) ** self._as_int)
+
+    def __radd__(self, other):
+        return self.__class__(self._to_int(other) + self._as_int)
+
+    def __rsub__(self, other):
+        return self.__class__(self._to_int(other) - self._as_int)
+
+    def __rmul__(self, other):
+        return self.__class__(self._to_int(other) * self._as_int)
+
+    def __mod__(self, other):
+        return self.__class__(self._as_int % self._to_int(other))
+
+    def __rmod__(self, other):
+        return self.__class__(self._to_int(other) % self._as_int)
+
+    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._as_int)
+
+    def __round__(self):
+        return self.__class__(round(self._as_int))
+
+    def __trunc__(self):
+        return self.__class__(math.trunc(self._as_int))
+
+    def __floor__(self):
+        return self.__class__(math.floor(self._as_int))
+
+    def __ceil__(self):
+        return self.__class__(math.ceil(self._as_int))
+
+    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._as_int, self._to_int(other)))
+
+    def __rdivmod__(self, other):
+        return self.__class__(divmod(self._to_int(other), self._as_int))
+
+    def __neg__(self):
+        return self.__class__(-self._as_int)
+
+    def __pos__(self):
+        return self
+
+    def __abs__(self):
+        return self.__class__(abs(self._as_int))
+
+    def is_even(self):
+        return self._as_int % 2 == 0
+
+    def is_odd(self):
+        return self._as_int % 2 == 1
+
+    def reversed(self):
+        return self[::-1]
+
+    def __getitem__(self, key):
+        return self.__class__(super().__getitem__(key))
+
+    @classmethod
+    def concat(cls, iterable):
+        return map(lambda x: istr("").join(x), istr(iterable))
+
+    @classmethod
+    def enumerate(cls, iterable, start=0):
+        for i, value in enumerate(iterable, start):
+            yield cls(i), value
+
+    @classmethod
+    class format:
+        def __new__(cls, cls_format, format=None):
+            if format is None:
+                return cls_format._format
+            return super().__new__(cls)
+
+        def __init__(self, cls, format):
+            self.saved_format = cls._format
+            self.saved_cls = cls
+            if not (isinstance(format, str) and all(x in "0123456789" for x in format)):
+                raise ValueError(f"{repr(format)} is incorrect format")
+
+            cls._format = format
+
+        def __enter__(self):
+            ...
+
+        def __exit__(self, exc_type, exc_value, exc_tb):
+            self.saved_cls._format = self.saved_format
+
+    @classmethod
+    class repr_mode:
+        def __new__(cls, cls_mode, mode=None):
+            if mode is None:
+                return cls_mode._mode
+            if mode in ("istr", "str", "int"):
+                return super().__new__(cls)
+            raise TypeError(f"mode not 'istr', 'str' or 'int', but {repr(mode)}")
+
+        def __init__(self, cls, mode):
+            self.saved_mode = cls._mode
+            self.saved_cls = cls
+            cls._mode = mode
+
+        def __enter__(self):
+            ...
+
+        def __exit__(self, exc_type, exc_value, exc_tb):
+            self.saved_cls._mode = self.saved_mode
+
+    @classmethod
+    class base:
+        def __new__(cls, cls_base, base=None):
+            if base is None:
+                return cls_base._base
+            if 2 <= base <= 36:
+                return super().__new__(cls)
+            raise ValueError(f"base not between 2 and 36, but {base}")
+
+        def __init__(self, cls, base):
+            self.saved_base = cls._base
+            self.saved_cls = cls
+            cls._base = base
+
+        def __enter__(self):
+            ...
+
+        def __exit__(self, exc_type, exc_value, exc_tb):
+            self.saved_cls._base = self.saved_base
+
+    @classmethod
+    def range(cls, start, stop=None, step=1):
+        return _range(cls, start, stop, step)
+
+    def capitalize1(self, *args, **kwargs):
+        return self.__class__(super().capitalize(*args, **kwargs))
+
+    def casefold(self, *args, **kwargs):
+        return self.__class__(super().casefold(*args, **kwargs))
+
+    def center(self, *args, **kwargs):
+        return self.__class__(super().center(*args, **kwargs))
+
+    def expandtabs(self, *args, **kwargs):
+        return self.__class__(super().expandtabs(*args, **kwargs))
+
+    def join(self, *args, **kwargs):
+        return self.__class__(super().join(*args, **kwargs))
+
+    def ljust(self, *args, **kwargs):
+        return self.__class__(super().ljust(*args, **kwargs))
+
+    def lower(self, *args, **kwargs):
+        return self.__class__(super().lower(*args, **kwargs))
+
+    def lstrip(self, *args, **kwargs):
+        return self.__class__(super().lstrip(*args, **kwargs))
+
+    def partition(self, *args, **kwargs):
+        return self.__class__(super().partition(*args, **kwargs))
+
+    def removeprefix(self, *args, **kwargs):
+        return self.__class__(super().removeprefix(*args, **kwargs))
+
+    def removesuffix(self, *args, **kwargs):
+        return self.__class__(super().removesuffix(*args, **kwargs))
+
+    def replace(self, *args, **kwargs):
+        return self.__class__(super().replace(*args, **kwargs))
+
+    def rjust(self, *args, **kwargs):
+        return self.__class__(super().rjust(*args, **kwargs))
+
+    def rpartition(self, *args, **kwargs):
+        return self.__class__(super().rpartition(*args, **kwargs))
+
+    def rsplit(self, *args, **kwargs):
+        return self.__class__(super().rsplit(*args, **kwargs))
+
+    def rstrip(self, *args, **kwargs):
+        return self.__class__(super().rstrip(*args, **kwargs))
+
+    def split(self, *args, **kwargs):
+        return self.__class__(super().split(*args, **kwargs))
+
+    def strip(self, *args, **kwargs):
+        return self.__class__(super().strip(*args, **kwargs))
+
+    def swapcase(self, *args, **kwargs):
+        return self.__class__(super().swapcase(*args, **kwargs))
+
+    def title(self, *args, **kwargs):
+        return self.__class__(super().title(*args, **kwargs))
+
+    def translate(self, *args, **kwargs):
+        return self.__class__(super().translate(*args, **kwargs))
+
+    def upper(self, *args, **kwargs):
+        return self.__class__(super().upper(*args, **kwargs))
+
+    def zfill(self, *args, **kwargs):
+        return self.__class__(super().zfill(*args, **kwargs))
+
+    f = "capitalize"
+    exec(
+        f"""
+def {f}(self, *args, **kwargs):
+        return self.__class__(super(istr,self).{f}(*args, **kwargs)) 
+""",
+        globals(),
+        locals(),
+    )
+
+
+def main():
+    a = istr("123123")
+    print(repr(a.capitalize()))
+
+
+if __name__ == "__main__":
+    main()
+

istr_python-0.1.3.0.dist-info/METADATA

@@ -0,0 +1,421 @@
+Metadata-Version: 2.1
+Name: istr-python
+Version: 0.1.3.0
+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
+Project-URL: Repository, https://github.com/salabim/istr
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+<img src="https://www.salabim.org/istr_logo.png" width=500>
+
+# Introduction
+
+The istr module has exactly one class: istr.
+
+With this it is possible to interpret strings 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")
+```
+Then 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 istrs 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.
+
+Please note that `four` and `five` could have also be initialized with
+```
+four = istr(4)
+five = istr(5)
+```
+or even
+```
+four, five = istr(4, 5)
+```
+
+But 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 repeat a string in the usual sense, you cannot use `3 * four`, as that woud be `12`. 
+
+We use the matrix multiplication operator (@) for this. So `3 @ four` is `444`. As is `four @ 3`.
+
+Also allowed are
+```
+abs(four)
+-four 
+```
+
+The bool operator works on the integer value of an istr. So
+`bool("0")` ==> `False`
+`bool("1")` ==> `True`
+The code
+```
+if istr("0"):
+    print("True")
+else:
+    print("False")
+```
+will print `False`
+
+For the in operator, an 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)"`, resulting in `istr("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 numeric value or str
+Apart from with simple 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 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`
+
+- if an istr.range instance, the same istr.range will be returned
+
+# More than one parameter for istr
+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 unpack multiple values, e.g.
+
+`a, b, c = istr(5, 6, 7)` ==> `a=istr("5") , b=istr("6"), c=istr("7")`
+
+# 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.
+
+# reverse an istr
+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")
+```
+The same can -of course- be achieved with
+```
+print(repr(istr(456)[::-1]))
+print(repr(istr("0456")[::-1]))
+```
+Note that is impossible to reverse a negative istr.
+
+# enumerate with istrs
+
+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}")
+```
+prints
+```
+istr('0') a
+istr('1') b
+istr('2') c
+```
+
+# concatenate an iterable
+
+The `istr.concat1 method can be useful to map all items of an iterable
+to `istr` and then concatenate these.
+
+`list(istr.concat(((1,2),(3,4)))` ==> `istr([12,34])`
+
+`list(istr.concat(itertools.permutations(range(3),2)))` ==> `[istr('01'), istr('02'), istr('10'), istr('12'), istr('20'), istr('21')]` 
+
+# Subclassing istr
+When a class is derived from istr, all methods will return that newly derived class. 
+
+E.g.
+```
+class jstr(istr):
+    ...
+    
+print(repr(jstr(4) * jstr(5)))
+```
+will print `jstr('20')`
+
+# Changing the way repr works
+
+It is possible to control the way an `istr` instance will be repr'ed.
+
+By default, the `istr('5')` is represented as `istr('5')`.
+
+With the istr.repr_mode() context manager, that can be changed:
+```
+with istr.repr_mode("str"):
+    five = istr('5')
+    print(repr(five))
+with istr.repr_mode("int"):
+    five = istr('5')
+    print(repr(five))
+with istr.repr_mode("istr"):
+    five = istr('5')
+    print(repr(five))
+```
+This will print
+```
+'5'
+5
+istr('5')
+```
+Note that the way an `istr` is represented is determined at initialization.
+
+It is also possible to set the repr mode without a context manager:
+
+```
+istr.repr_mode("str")
+five = istr('5')
+print(repr(five))
+```
+This will print
+```
+'5'
+```
+Finally, the current repr mode can be queried with `istr.repr_mode()`. So upon start:
+```
+print(repr(istr.repr_mode()))
+```
+will output `istr`.
+
+# Changing the base system
+
+By default, `istr` works in base 10. However it is possible to change the base system with the `istr.base()` context manager / method.
+
+Any base between 2 and 36 may be used.
+
+Note that the integer is always stored in base 10 mode, but the string
+representation will reflect the chosen base (at time of initialization).
+
+Some examples:
+```
+with istr.base(16):
+    a = istr("7fff")
+    print(int(a))
+
+    b = istr(15)
+    print(repr(b))
+```
+This will result in
+```
+32767
+istr('F')
+```
+All calculations are done in the decimal 10 system.
+
+Note that the way an `istr` is interpreted is determined at initialization.
+
+It is also possible to set the repr mode without a context manager:
+```
+istr.base(16)
+print(int(istr("7fff")))
+```
+This will print
+```
+32767
+```
+Finally, the current base can be queried with `istr.base()`, so upon start:
+```
+print(istr.base())
+```
+will result in `10`.
+
+# Changing the format of the string
+
+By default, `istr` does not change the way an istr is stored when a str is to initialize:
+
+`repr('4'))` ==> `istr('4')`
+
+`repr(' 4'))` ==> `istr(' 4')`
+
+`repr('4  '))` ==> `istr('4  ')`
+
+For initializing with an int (or other numeric) value, the string is simply the str representation
+
+`repr(4))` ==> `istr('4')`
+
+With the `istr.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:
+```
+with istr.format("3"):
+    print(repr(istr(1)))
+    print(repr(istr(12)))
+    print(repr(istr(123)))
+    print(repr(istr(1234)))
+```
+will print
+```
+istr('  1')
+istr(' 12')
+istr('123')
+istr('1234')
+```
+If the string starts with a `0`, the string will be zero filled:
+```
+with istr.format("03"):
+    print(repr(istr(1)))
+    print(repr(istr(12)))
+    print(repr(istr(123)))
+    print(repr(istr(1234)))
+```
+will print
+```
+istr('001')
+istr('012')
+istr('123')
+istr('1234')
+```
+Note that if a format other than the default `''` is used, the string will reformatted even if the `istr` is specified with a string:
+```
+with istr.format("03"):
+    print(repr(istr("  12 ")))
+```
+will result in `istr('0012')`
+
+Remark: For bases other than 10, the string will never be reformatted!
+
+# Test script
+There's an extensive pytest script in the `\tests` directory.
+
+This script also shows clearly the ways istr can be used.

istr_python-0.1.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+istr/__init__.py,sha256=xeAK58Bnq1NPGZDQY_l1JXHK243tJHPicwXjjbt6E7k,50
+istr/install istr.py,sha256=MnVdIOGm7z1Gf6xX95sfEFGDQ2Q3Mh37M27EjeogEPo,7734
+istr/istr.py,sha256=aQY_NL7vl3K49j6Oa0-2ErWx0liOSYXYWtAn8l9JqPM,18174
+istr_python-0.1.3.0.dist-info/METADATA,sha256=_nrTUw1gom9jItbyV5DM_VrspAPV-WcUkWpN0By5IO8,10340
+istr_python-0.1.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+istr_python-0.1.3.0.dist-info/top_level.txt,sha256=WpBHA-t036vALUt_W4rIOw-f-gydb8hs-Ahwn2IqIE8,5
+istr_python-0.1.3.0.dist-info/RECORD,,

istr_python-0.1.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

istr_python-0.1.3.0.dist-info/top_level.txt

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