reslot 0.1__tar.gz → 0.9__tar.gz

reslot-0.9/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: reslot
+Version: 0.9
+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 :: 3 - 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.9/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.9}/pyproject.toml

@@ -1,20 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "reslot"
-version = "0.1"
+version = "0.9"
 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",
 	"Topic :: Software Development :: Libraries",
-	"Development Status :: 2 - Pre-Alpha"
+	"Development Status :: 3 - Alpha"
 ]
 
 [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.9/reslot.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: reslot
+Version: 0.9
+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 :: 3 - 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.9/reslot.py

@@ -0,0 +1,109 @@
+from collections.abc import MutableMapping
+from functools import cached_property, partial, update_wrapper
+from inspect import getclasstree, getdoc
+from typing import (Callable, Dict, TypeVar, Iterator, Type, Optional, Set,
+                    Tuple, Union, List)
+
+_UNSET = object()
+
+_T = TypeVar("_T")
+
+walk_class_tree_hint = List[Union[Type, Tuple[Type, Type], "walk_class_tree_hint"]]
+
+def walk_class_tree(l: walk_class_tree_hint) -> Iterator[Type]:
+	if isinstance(l, type):
+		yield l
+	elif isinstance(l, tuple):
+		yield l[0]
+		if len(l) > 1:
+			yield from walk_class_tree(l[1])
+	else:
+		for ll in l:
+			yield from walk_class_tree(ll)
+
+def collect_all_slots(cls: Type) -> Set[str]:
+	slots = set()
+	if hasattr(cls, "__slots__"):
+		slots.update(cls.__slots__)
+	for clls in walk_class_tree(getclasstree([cls])):
+		if hasattr(clls, "__slots__"):
+			slots.update(clls.__slots__)
+	return slots
+
+
+def iter_needed_slots(cls: Type) -> Iterator[Tuple[str, Optional[str]]]:
+	for clls in walk_class_tree([cls]):
+		for attr in dir(clls):
+			try:
+				val = getattr(clls, 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 init(slot_dict: Dict[str, Optional[str]], core_init: Optional[Callable],
+         self, *args, **kwargs):
+	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__ = slot_dict
+
+		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__)
+	self.__dict__ = SlotRedirector()
+	if callable(core_init):
+		core_init(self, *args, **kwargs)
+	else:
+		super(type(self), self).__init__(*args, **kwargs)
+
+def reslot(cls: Type[_T]) -> 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.
+	"""
+	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")
+	slot_dict = dict(iter_needed_slots(cls))
+	if hasattr(cls, "__slots__"):
+		if isinstance(cls.__slots__, dict):
+			slot_dict.update(cls.__slots__)
+		else:
+			for slot in cls.__slots__:
+				slot_dict[slot] = None
+	if hasattr(cls, "__init__"):
+		part = partial(init, slot_dict, cls.__init__)
+		update_wrapper(part, cls.__init__)
+	else:
+		part = partial(init, slot_dict, None)
+	cls.__init__ = part
+	return 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)