istr-python 0.0.0__py3-none-any.whl

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,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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,7 @@
+istr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+istr/install istr.py,sha256=MnVdIOGm7z1Gf6xX95sfEFGDQ2Q3Mh37M27EjeogEPo,7734
+istr/istr.py,sha256=7W9yT5t_mI7OTwhsOGYH3yP1psPG-wFawyW4j3WqRtg,10714
+istr_python-0.0.0.dist-info/METADATA,sha256=733e1TJoFqx_x6w3o2I_5kTWNa0AasTu0fih19JOcyc,2732
+istr_python-0.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+istr_python-0.0.0.dist-info/top_level.txt,sha256=WpBHA-t036vALUt_W4rIOw-f-gydb8hs-Ahwn2IqIE8,5
+istr_python-0.0.0.dist-info/RECORD,,

istr_python-0.0.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.0.0.dist-info/top_level.txt

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