typemore 0.1.0__tar.gz

typemore-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 maoshen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

typemore-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.5
+Name: typemore
+Version: 0.1.0
+Summary: A collection of custom Python data types for specialized behavior.
+Author: maoshen
+Maintainer: maoshen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: Auto,ChainNode,Debug,DisplayProxy,InfiniteIterator,Interval,LenLimit,LenLimitError,MemLimit,MemLimitError,Point2D,Point3D,PointAnyD,Range,ReadOnlyBox,StrictFloat,TimeLimit,TimeLimitError,more,type,typemore
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: pympler>=1.0
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+## License
+
+MIT
+
+# typemore
+
+A collection of custom Python data types for specialized behavior.
+
+## Install
+
+pip install typemore
+
+## Usage
+
+from typemore import StrictFloat
+
+StrictFloat(0.1) + StrictFloat(0.2)  # StrictFloat:0.3

typemore-0.1.0/README.md

@@ -0,0 +1,17 @@
+## License
+
+MIT
+
+# typemore
+
+A collection of custom Python data types for specialized behavior.
+
+## Install
+
+pip install typemore
+
+## Usage
+
+from typemore import StrictFloat
+
+StrictFloat(0.1) + StrictFloat(0.2)  # StrictFloat:0.3

typemore-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "typemore"
+version = "0.1.0"
+description = "A collection of custom Python data types for specialized behavior."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "typemore",
+    "type",
+    "more",
+    "Range",
+    "Point2D",
+    "Point3D",
+    "PointAnyD",
+    "Auto",
+    "Debug",
+    "StrictFloat",
+    "Interval",
+    "ChainNode",
+    "InfiniteIterator",
+    "ReadOnlyBox",
+    "DisplayProxy",
+    "LenLimit",
+    "LenLimitError",
+    "TimeLimit",
+    "TimeLimitError",
+    "MemLimit",
+    "MemLimitError"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+authors = [
+    { name = "maoshen" }
+]
+maintainers = [
+    { name = "maoshen" }
+]
+dependencies = [
+    "pympler>=1.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "build",
+    "twine",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["typemore"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/typemore",
+    "/README.md",
+]

typemore-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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")