typemore 0.1.0__py3-none-any.whl

typemore/_PackageTools.py

@@ -0,0 +1,12 @@
+import sys
+
+def private(func):
+    def wrapper(*args, **kwargs):
+        caller_qualname = sys._getframe(1).f_code.co_qualname
+        method_qualname = func.__qualname__
+        parent = method_qualname[:method_qualname.rfind('.')]
+
+        if not caller_qualname.startswith(parent):
+            raise RuntimeError(f"{method_qualname} is private")
+        return func(*args, **kwargs)
+    return wrapper

typemore/__init__.py

@@ -0,0 +1,36 @@
+from .types.range import Range
+from .types.point2D import Point2D
+from .types.point3D import Point3D
+from .types.pointAnyD import PointAnyD
+from .types.auto import Auto
+from .types.debug import Debug
+from .types.strictFloat import StrictFloat
+from .types.interval import Interval
+from .types.chainNode import ChainNode
+from .types.infiniteIterator import InfiniteIterator
+from .types.readOnlyBox import ReadOnlyBox
+from .types.displayProxy import DisplayProxy
+from .types.lenLimit import LenLimit, LenLimitError
+from .types.timeLimit import TimeLimit, TimeLimitError
+from .types.memLimit import MemLimit, MemLimitError
+
+__version__ = "0.1.0"
+__author__ = "maoshen"
+__all__ = ["Range",
+           "Point2D",
+           "Point3D",
+           "PointAnyD",
+           "Auto",
+           "Debug",
+           "StrictFloat",
+           "Interval",
+           "ChainNode",
+           "InfiniteIterator",
+           "ReadOnlyBox",
+           "DisplayProxy",
+           "LenLimit",
+           "LenLimitError",
+           "TimeLimit",
+           "TimeLimitError",
+           "MemLimit",
+           "MemLimitError"]

typemore/types/auto.py

@@ -0,0 +1,119 @@
+class Auto:
+    """
+    This class is compatible with most commonly used type-conversion functions.
+    It prevents exceptions for conversion operations that would normally raise them.
+    """
+    _cache = {}
+    _hash = None
+
+    def __new__(cls, auto):
+        base = type(auto)
+        if base not in cls._cache:
+            if base in (bool, type(None)):
+                bases = (cls,)
+            else:
+                bases = (cls, base)
+            cls._cache[base] = type(
+                f"{cls.__name__}[{base.__name__}]",
+                bases,
+                {}
+            )
+        new_cls = cls._cache[base]
+
+        if auto is None or base is bool:
+            instance = super().__new__(new_cls)
+        elif issubclass(base, (int, float, complex, str, tuple, frozenset, bytes)):
+            instance = base.__new__(new_cls, auto)
+        elif issubclass(base, (list, dict, set, bytearray)):
+            instance = base.__new__(new_cls)
+            base.__init__(instance, auto)
+        else:
+            instance = base.__new__(new_cls)
+        return instance
+
+    def __init__(self, auto):
+        self.auto = self
+        self._hash = None
+        try:
+            hash(auto)
+            self._hash = True
+        except TypeError:
+            self._hash = False
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}:{super().__repr__()}"
+
+    def __getattr__(self, name):
+        raise AttributeError(name)
+
+    def __dir__(self):
+        return list(set(dir(self.__class__) + dir(self.__class__.__mro__[1]) + ['auto']))
+
+    def __int__(self):
+        if not self._hash:
+            return len(self)
+        if isinstance(self, bool):
+            return 1 if bool.__bool__(self) else 0
+        if isinstance(self, int):
+            return int.__int__(self)
+        if isinstance(self, float):
+            return int(float.__int__(self))
+        if isinstance(self, complex):
+            return int(self.real)
+        if isinstance(self, str):
+            try:
+                return int(str.__str__(self))
+            except ValueError:
+                return 1 if str.__len__(self) else 0
+        return 0
+
+    def __float__(self) -> float:
+        return float(self.__int__())
+
+    def __complex__(self) -> complex:
+        if self._hash:
+            if isinstance(self.auto, complex):
+                return complex(self.real, self.imag)
+            elif isinstance(self.auto, int | float):
+                return complex(self.auto, 0j)
+            elif isinstance(self.auto, bool):
+                if self.auto:
+                    real = 1
+                else:
+                    real = 0
+                return complex(real, 0j)
+            elif isinstance(self.auto, str):
+                try:
+                    return complex(self.auto)
+                except ValueError:
+                    if self.auto.strip() == '':
+                        return 0
+                    else:
+                        return 1
+            return complex(0)
+        else:
+            return complex(self.__int__(), 0j)
+
+    def __index__(self) -> int:
+        if self._hash:
+            if isinstance(self.auto, int | float | bool):
+                return int(self.auto)
+            elif isinstance(self.auto, str):
+                try:
+                    return int(self.auto)
+                except ValueError:
+                    if self.auto.strip() == '':
+                        return 0
+                    else:
+                        return 1
+            elif isinstance(self.auto, complex):
+                return int(self.auto.real)
+            return 0
+        else:
+            return self.__int__()
+
+    def __iter__(self):
+        auto = self.auto
+        if isinstance(auto, (int, float, complex, bool, bytes)):
+            return iter([auto])
+        return iter(auto)

typemore/types/chainNode.py

@@ -0,0 +1,293 @@
+from __future__ import  annotations
+
+class PointerNone:
+    pass
+
+point_none = PointerNone()
+
+class ChainNode:
+    """
+    A singly linked list node whose class also inherits from type(value).
+
+        Each instance stores a value and a pointer to the next node. The class
+        of an instance is generated dynamically based on the type of value, so
+        a node can also use the methods and operators of its underlying type.
+        For example, ChainNode(5) inherits from int, and ChainNode("a") inherits
+        from str.
+
+        The end of a chain is marked by point_none, a sentinel instance of
+        PointerNone. Use "pointer is point_none" to test for the end.
+        """
+    _cache = {}
+
+    def __new__(cls, value, pointer = point_none):
+        base = type(value)
+        if base not in cls._cache:
+            if base in (bool, type(None)):
+                bases = (cls,)
+            else:
+                bases = (cls, base)
+            cls._cache[base] = type(
+                f"{cls.__name__}[{base.__name__}]",
+                bases,
+                {}
+            )
+        new_cls = cls._cache[base]
+        if value is None or base is bool:
+            instance = super().__new__(new_cls)
+            return instance
+        elif issubclass(base, (int, float, str, tuple, frozenset, bytes)):
+            instance= base.__new__(new_cls, value)
+            return instance
+        else:
+            instance = base.__new__(new_cls)
+        return instance
+
+    def __init__(self, value, pointer = point_none):
+        self.value = value
+        self.pointer = pointer
+
+    def __repr__(self) -> str:
+        return f"Pointer({self.value}, {self.pointer if self.pointer is not point_none else ''})"
+
+    def __str__(self) -> str:
+        return f"({self.value}, {self.pointer if self.pointer is not point_none else ''})"
+
+    def getvalue_number(self, number: int):
+        """
+        Return the value of the node at index number, where 0 is self.
+
+        Raises ValueError if number is not a non-negative int, and IndexError
+        if the chain ends before reaching that index.
+        """
+        if not isinstance(number, int) or number < 0:
+            raise ValueError("index out of range")
+        node = self
+        for _ in range(number):
+            if not isinstance(node.pointer, ChainNode):
+                raise IndexError("index out of range")
+            node = node.pointer
+        return node.value
+
+    def getpointer_number(self, number: int):
+        """
+        Return the node at index number, where 0 is self.
+
+        Raises ValueError if number is not a non-negative int, and IndexError
+        if the chain ends before reaching that index.
+        """
+        if not isinstance(number, int) or number < 0:
+            raise ValueError("index out of range")
+        node = self
+        for _ in range(number):
+            if not isinstance(node.pointer, ChainNode):
+                raise IndexError("index out of range")
+            node = node.pointer
+        return node
+
+    def getpointer_value(self, value):
+        """
+        Return the pointer of the first node whose value equals value.
+
+        Raises ValueError if no such node exists.
+        """
+        node = self._find_node(value)
+        if node is None:
+            raise ValueError("value not found in chain")
+        return node.pointer
+
+    def setpointer_number(self, number: int, pointer) -> None:
+        """
+        Set the pointer of the node at index number, where 0 is self.
+
+        Raises ValueError if number is not a non-negative int, and IndexError
+        if the chain ends before reaching that index.
+        """
+        if not isinstance(number, int) or number < 0:
+            raise ValueError("index out of range")
+        node = self
+        for _ in range(number):
+            if not isinstance(node, ChainNode):
+                raise IndexError("index out of range")
+            node = node.pointer
+        if not isinstance(node, ChainNode):
+            raise IndexError("index out of range")
+        node.pointer = pointer
+
+    def setpointer_value(self, value, pointer) -> None:
+        """
+        Set the pointer of the first node whose value equals value.
+
+        Raises ValueError if no such node exists.
+        """
+        node = self._find_node(value)
+        if node is None:
+            raise ValueError("value not found in chain")
+        node.pointer = pointer
+
+    def setvalue_number(self, number: int, value) -> None:
+        """
+        Set the value attribute of the node at index number, where 0 is self.
+
+        For immutable subclasses such as ChainNode[int], the instance's own
+        numeric value does not change; only the value attribute is updated.
+        Raises ValueError if number is not a non-negative int, and IndexError
+        if the chain ends before reaching that index.
+        """
+        if not isinstance(number, int) or number < 0:
+            raise ValueError("index out of range")
+        node = self
+        for _ in range(number):
+            if not isinstance(node, ChainNode):
+                raise IndexError("index out of range")
+            node = node.pointer
+        if not isinstance(node, ChainNode):
+            raise IndexError("index out of range")
+        node.value = value
+
+    def delete_number(self, number: int):
+        """
+        Delete the node at index number.
+
+        If number is 0, return the next node as the new head. Otherwise, return
+        self. Raises ValueError if number is not a non-negative int, and
+        IndexError if the chain ends before reaching that index.
+        """
+        if not isinstance(number, int) or number < 0:
+            raise ValueError("index out of range")
+
+        if number == 0:
+            if not isinstance(self.pointer, ChainNode):
+                raise IndexError("index out of range")
+            return self.pointer
+
+        prev = self
+        for _ in range(number - 1):
+            if not isinstance(prev.pointer, ChainNode):
+                raise IndexError("index out of range")
+            prev = prev.pointer
+
+        target = prev.pointer
+        if not isinstance(target, ChainNode):
+            raise IndexError("index out of range")
+        prev.pointer = target.pointer
+        return self
+
+    def delete_value(self, value):
+        """
+        Delete the first node whose value equals value.
+
+        Return the new head. When the deleted node is the head, the successor
+        becomes the new head. Raises ValueError if no such node exists.
+        """
+        if self.value == value:
+            if not isinstance(self.pointer, ChainNode):
+                raise ValueError("value not found in chain")
+            return self.pointer
+
+        prev = self
+        cur = self.pointer
+        while isinstance(cur, ChainNode):
+            if cur.value == value:
+                prev.pointer = cur.pointer
+                return self
+            prev = cur
+            cur = cur.pointer
+        raise ValueError("value not found in chain")
+
+    def node_search(self, value) -> int:
+        """
+        Return the index of the first node whose value equals value.
+
+        Index 0 is self. Raises ValueError if no such node exists.
+        """
+        if self.value == value:
+            return 0
+        pointer_save = self
+        pointer_now = self.pointer
+        i = 1
+        while True:
+            if not isinstance(pointer_now, ChainNode):
+                if pointer_now == value and pointer_now == pointer_save.value:
+                    return i
+                else:
+                    raise ValueError(f"{value} not found in chain")
+            if pointer_now.value == value:
+                return i
+            pointer_now = pointer_now.pointer
+            pointer_save = pointer_save.pointer
+            i += 1
+
+    def _find_node(self, value):
+        """Return the first node whose value equals value, or None."""
+        node = self
+        while isinstance(node, ChainNode):
+            if node.value == value:
+                return node
+            node = node.pointer
+        return None
+
+    def node_len(self, value=point_none, pointer=point_none) -> int:
+        """
+        Return the number of nodes starting after a given position.
+
+        With no argument, count nodes after self. With pointer=xxx, count
+        starting at xxx (inclusive). With value=xxx, count starting after the
+        node holding xxx. The two keyword arguments are mutually exclusive.
+        """
+        if pointer is not point_none and value is not point_none:
+            raise ValueError("pointer and value are mutually exclusive")
+
+        if value is not point_none:
+            node = self._find_node(value)
+            if node is None:
+                raise ValueError(f"value {value} not found in chain")
+            start = node.pointer
+        elif pointer is not point_none:
+            start = pointer
+        else:
+            start = self.pointer
+
+        i = 0
+        while isinstance(start, ChainNode):
+            start = start.pointer
+            i += 1
+        return i
+
+    def deep_len(self, value=point_none, pointer=point_none) -> int:
+        """
+        Return the depth of a node relative to self.
+
+        Positive if the node comes after self, 0 if it is self, negative if it
+        comes before self. The two keyword arguments are mutually exclusive.
+        Raises ValueError if the node is not on the same chain.
+        """
+        if pointer is not point_none and value is not point_none:
+            raise ValueError("pointer and value are mutually exclusive")
+
+        if value is not point_none:
+            node = self._find_node(value)
+            if node is None:
+                raise ValueError(f"value {value} not found in chain")
+        elif pointer is not point_none:
+            node = pointer
+        else:
+            raise ValueError("either pointer or value is required")
+
+        cur = self
+        depth = 0
+        while isinstance(cur, ChainNode):
+            if cur is node:
+                return depth
+            cur = cur.pointer
+            depth += 1
+
+        cur = node
+        depth = 0
+        while isinstance(cur, ChainNode):
+            if cur is self:
+                return -depth
+            cur = cur.pointer
+            depth += 1
+
+        raise ValueError("the two nodes are not in the same chain")