reslot 0.1__tar.gz → 0.7__tar.gz

reslot-0.7/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: reslot
+Version: 0.7
+Summary: Class decorator to enable @cached_property on classes with __slots__
+Author-email: Zachary Spector <public@zacharyspector.com>
+License-Expression: MIT
+Project-URL: Homepage, https://codeberg.org/clayote/reslot
+Project-URL: Bug tracker, https://codeberg.org/clayote/reslot/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Development Status :: 2 - Pre-Alpha
+Requires-Python: ~=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# reslot
+
+
+A class decorator that lets you use `@cached_property` on classes with `__slots__`.
+
+The decorated class needs a `__dict__` slot, but there won't exactly be a
+dictionary in it. Instead, `@reslot` will give it a custom `MutableMapping`
+with *its own* slots. `@cached_property` will keep its cache there.
+
+The custom `MutableMapping`'s slots will be exactly the slots needed to store
+the results of every `@cached_property` that was on the class at the time it
+was declared. This minimizes the memory footprint and makes lookup speedy.
+
+
+## Usage
+
+```python
+from functools import cached_property
+
+from reslot import reslot
+
+BEANED = False
+
+@reslot
+class Spam:
+    __slots__ = ("__dict__",)
+
+    @cached_property
+    def eggs(self):
+        return {"delicious": False}
+
+    @cached_property
+    def beans(self):
+        global BEANED
+        BEANED = True
+        return {"spam": 111000, "delicious": True}
+
+spam = Spam()
+print(spam.eggs)   # {"delicious": False}
+print(BEANED)      # False
+print(spam.beans)  # {"spam": 111000, "delicious": True}
+print(BEANED)      # True
+```

reslot-0.7/README.md

@@ -0,0 +1,43 @@
+# reslot
+
+
+A class decorator that lets you use `@cached_property` on classes with `__slots__`.
+
+The decorated class needs a `__dict__` slot, but there won't exactly be a
+dictionary in it. Instead, `@reslot` will give it a custom `MutableMapping`
+with *its own* slots. `@cached_property` will keep its cache there.
+
+The custom `MutableMapping`'s slots will be exactly the slots needed to store
+the results of every `@cached_property` that was on the class at the time it
+was declared. This minimizes the memory footprint and makes lookup speedy.
+
+
+## Usage
+
+```python
+from functools import cached_property
+
+from reslot import reslot
+
+BEANED = False
+
+@reslot
+class Spam:
+    __slots__ = ("__dict__",)
+
+    @cached_property
+    def eggs(self):
+        return {"delicious": False}
+
+    @cached_property
+    def beans(self):
+        global BEANED
+        BEANED = True
+        return {"spam": 111000, "delicious": True}
+
+spam = Spam()
+print(spam.eggs)   # {"delicious": False}
+print(BEANED)      # False
+print(spam.beans)  # {"spam": 111000, "delicious": True}
+print(BEANED)      # True
+```

{reslot-0.1 → reslot-0.7}/pyproject.toml

@@ -1,13 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "reslot"
-version = "0.1"
+version = "0.7"
 authors = [
     {name="Zachary Spector",email="public@zacharyspector.com"},
 ]
 description="Class decorator to enable @cached_property on classes with __slots__"
+readme = {file="README.md", content-type="text/markdown"}
 license = "MIT"
 license-files = ["LICENSE"]
-requires-python = "~=3.12"
+requires-python = "~=3.8"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",
@@ -17,4 +22,4 @@ classifiers = [
 
 [project.urls]
 "Homepage" = "https://codeberg.org/clayote/reslot"
-"Bug tracker" = "https://codeberg.org/clayote/reslot/issues"
+"Bug tracker" = "https://codeberg.org/clayote/reslot/issues"

reslot-0.7/reslot.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: reslot
+Version: 0.7
+Summary: Class decorator to enable @cached_property on classes with __slots__
+Author-email: Zachary Spector <public@zacharyspector.com>
+License-Expression: MIT
+Project-URL: Homepage, https://codeberg.org/clayote/reslot
+Project-URL: Bug tracker, https://codeberg.org/clayote/reslot/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Development Status :: 2 - Pre-Alpha
+Requires-Python: ~=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# reslot
+
+
+A class decorator that lets you use `@cached_property` on classes with `__slots__`.
+
+The decorated class needs a `__dict__` slot, but there won't exactly be a
+dictionary in it. Instead, `@reslot` will give it a custom `MutableMapping`
+with *its own* slots. `@cached_property` will keep its cache there.
+
+The custom `MutableMapping`'s slots will be exactly the slots needed to store
+the results of every `@cached_property` that was on the class at the time it
+was declared. This minimizes the memory footprint and makes lookup speedy.
+
+
+## Usage
+
+```python
+from functools import cached_property
+
+from reslot import reslot
+
+BEANED = False
+
+@reslot
+class Spam:
+    __slots__ = ("__dict__",)
+
+    @cached_property
+    def eggs(self):
+        return {"delicious": False}
+
+    @cached_property
+    def beans(self):
+        global BEANED
+        BEANED = True
+        return {"spam": 111000, "delicious": True}
+
+spam = Spam()
+print(spam.eggs)   # {"delicious": False}
+print(BEANED)      # False
+print(spam.beans)  # {"spam": 111000, "delicious": True}
+print(BEANED)      # True
+```

reslot-0.7/reslot.py

@@ -0,0 +1,109 @@
+import builtins
+from collections.abc import MutableMapping
+from functools import wraps, cached_property
+from inspect import getclasstree, getdoc
+from typing import TypeVar, Iterator, Type, Optional, Set, Tuple
+
+_UNSET = object()
+
+_T = TypeVar("_T")
+
+
+def collect_all_slots(cls) -> Set[str]:
+	def recurse(l):
+		if isinstance(l, type):
+			yield l
+		elif isinstance(l, tuple):
+			yield l[0]
+			yield from map(recurse, l[1])
+		else:
+			for ll in l:
+				yield from recurse(ll)
+
+	slots = set()
+	if hasattr(cls, "__slots__"):
+		slots.update(cls.__slots__)
+	for clls in recurse(getclasstree([cls])):
+		if hasattr(clls, "__slots__"):
+			slots.update(clls.__slots__)
+	return slots
+
+
+def iter_needed_slots(cls: Type) -> Iterator[Tuple[str, str]]:
+	for attr in dir(cls):
+		try:
+			val = getattr(cls, attr)
+		except AttributeError:
+			continue
+		if not isinstance(val, cached_property):
+			continue
+		if val.attrname is None:
+			raise TypeError("cached_property without name")
+		yield val.attrname, getdoc(val.func)
+
+def reslot(
+	cls: Optional[Type[_T]] = None,
+) -> Type[_T]:
+	"""Class decorator to enable ``@cached_property`` with ``__slots__``
+
+	The decorated class needs a ``__dict__`` slot, but we won't put an actual
+	dictionary in it. Instead, we'll put a mapping with the needed slots in it.
+	"""
+
+	def really_reslot(cls: Type[_T]) -> Type[_T]:
+		if not hasattr(cls, "__slots__"):
+			raise TypeError("Class doesn't have __slots__")
+		slots = collect_all_slots(cls)
+		if "__dict__" not in slots:
+			raise TypeError("Need __dict__ slot")
+
+		class SlotRedirector(MutableMapping, dict):
+			# I think inheriting from dict means we still have an empty
+			# dictionary floating in memory for each SlotRedirector instantiated.
+			# That's eighty bytes we don't need...but at least it doesn't grow.
+			__slots__ = dict(iter_needed_slots(cls))
+
+			def __setitem__(self, key, value, /):
+				try:
+					setattr(self, key, value)
+				except AttributeError:
+					raise KeyError("No such slot", key) from None
+
+			def __delitem__(self, key, /):
+				try:
+					delattr(self, key)
+				except AttributeError:
+					raise KeyError("Slot not set", key)
+
+			def __getitem__(self, key, /):
+				try:
+					return getattr(self, key)
+				except AttributeError:
+					raise KeyError("Slot not set", key)
+
+			def __len__(self):
+				return len(self.__slots__)
+
+			def __iter__(self):
+				return iter(self.__slots__)
+
+		if hasattr(cls, "__init__"):
+			core__init__ = cls.__init__
+
+			@wraps(core__init__)
+			def __init__(self, *args, **kwargs):
+				self.__dict__ = SlotRedirector()
+				core__init__(self, *args, **kwargs)
+
+			cls.__init__ = __init__
+		else:
+			def __init__(self, *args, **kwargs):
+				self.__dict__ = SlotRedirector()
+				super(cls, self).__init__(*args, **kwargs)
+
+			cls.__init__ = __init__
+		return cls
+
+	if cls is None:
+		return really_reslot
+	return really_reslot(cls)

reslot-0.1/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: reslot
-Version: 0.1
-Summary: Class decorator to enable @cached_property on classes with __slots__
-Author-email: Zachary Spector <public@zacharyspector.com>
-License-Expression: MIT
-Project-URL: Homepage, https://codeberg.org/clayote/reslot
-Project-URL: Bug tracker, https://codeberg.org/clayote/reslot/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Development Status :: 2 - Pre-Alpha
-Requires-Python: ~=3.12
-License-File: LICENSE
-Dynamic: license-file

reslot-0.1/README.md

@@ -1,9 +0,0 @@
-# reslot
-
-
-A class decorator that lets you use `@cached_property` on classes with `__slots__`.
-
-The decorated class needs a `__dict__` slot, but there won't exactly be a
-dictionary in it. Instead, `@reslot` will give it a custom `MutableMapping`
-with *its own* slots. `@cached_property` will keep its cache there.
-

reslot-0.1/reslot.egg-info/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: reslot
-Version: 0.1
-Summary: Class decorator to enable @cached_property on classes with __slots__
-Author-email: Zachary Spector <public@zacharyspector.com>
-License-Expression: MIT
-Project-URL: Homepage, https://codeberg.org/clayote/reslot
-Project-URL: Bug tracker, https://codeberg.org/clayote/reslot/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Development Status :: 2 - Pre-Alpha
-Requires-Python: ~=3.12
-License-File: LICENSE
-Dynamic: license-file

reslot-0.1/reslot.py

@@ -1,133 +0,0 @@
-from collections.abc import MutableMapping
-from functools import wraps, cached_property
-from inspect import getclasstree
-from typing import TypeVar
-
-_UNSET = object()
-
-_T = TypeVar("_T")
-
-
-def collect_all_slots(cls) -> set[str]:
-	def recurse(l: list[type | tuple[type, type] | list]):
-		if isinstance(l, type):
-			yield l
-		elif isinstance(l, tuple):
-			yield l[0]
-		else:
-			for ll in l:
-				yield from recurse(ll)
-
-	slots = set()
-	if hasattr(cls, "__slots__"):
-		slots.update(cls.__slots__)
-	for clls in recurse(getclasstree([cls])):
-		if hasattr(clls, "__slots__"):
-			slots.update(clls.__slots__)
-	return slots
-
-
-def surround_name(prefix: str | None, name: str, suffix: str | None) -> str:
-	if prefix is None:
-		if name.startswith("_"):
-			prefix = ""
-		else:
-			prefix = "_"
-	if suffix is None:
-		if prefix:
-			suffix = ""
-		else:
-			suffix = "_"
-	return prefix + name + suffix
-
-
-def reslot(
-	cls: type[_T] | None = None,
-	prefix: str | None = None,
-	suffix: str | None = None,
-) -> type[_T]:
-	"""Class decorator to enable ``@cached_property`` with ``__slots__``
-
-	The decorated class needs a ``__dict__`` slot, but we won't put an actual
-	dictionary in it. Instead, we'll put a mapping with the needed slots in it.
-
-	:param cls: The class to enable ``@cached_property`` on. If left ``None``,
-	    a partial function will be returned, which may then be used as a
-	    decorator.
-	:param prefix: String to put at the beginning of the slot name. Defaults
-	    to ``None``, in which case we'll prefix the slot name with an underscore
-	    unless it already starts with one. We won't default to a prefix then,
-	    because that would invoke name mangling.
-	:param suffix: String to put at the end of the slot name. Defaults to
-	    ``None``, in which case we won't use a suffix, unless ``prefix`` is
-	    also ``None`` or the empty string, in which case the default suffix is
-	    ``"_"``.
-
-	"""
-
-	def really_reslot(cls: type[_T]) -> type[_T]:
-		if not hasattr(cls, "__slots__"):
-			raise TypeError("Class doesn't have __slots__")
-		slots = collect_all_slots(cls)
-		if "__dict__" not in slots:
-			raise TypeError("Need __dict__ slot")
-		slots.remove("__dict__")
-
-		class SlotRedirector(MutableMapping):
-			__slots__ = slots
-
-			def __setitem__(self, key, value, /):
-				try:
-					setattr(self, key, value)
-				except AttributeError:
-					raise KeyError("No such slot", key) from None
-
-			def __delitem__(self, key, /):
-				try:
-					delattr(self, key)
-				except AttributeError:
-					raise KeyError("Slot not set", key)
-
-			def __getitem__(self, key, /):
-				try:
-					return getattr(self, key)
-				except AttributeError:
-					raise KeyError("Slot not set", key)
-
-			def __len__(self):
-				return len(self.__slots__)
-
-			def __iter__(self):
-				return iter(self.__slots__)
-
-		if hasattr(cls, "__getattr__"):
-			core_getattr = cls.__getattr__
-
-			@wraps(core_getattr)
-			def __getattr__(self: _T, attr: str):
-				if attr == "__dict__":
-					val = getattr(super(cls, self), "__dict__", _UNSET)
-					if val is _UNSET:
-						val = SlotRedirector()
-						setattr(self, "__dict__", val)
-					return val
-				return core_getattr(self, attr)
-
-			cls.__getattr__ = __getattr__
-		else:
-
-			def __getattr__(self: _T, attr: str):
-				if attr == "__dict__":
-					val = getattr(super(cls, self), "__dict__", _UNSET)
-					if val is _UNSET:
-						val = SlotRedirector()
-						setattr(self, "__dict__", val)
-					return val
-				return getattr(super(type(self), self), attr)
-
-			cls.__getattr__ = __getattr__
-		return cls
-
-	if cls is None:
-		return really_reslot
-	return really_reslot(cls)