Merge pull request #1 from TheArtur128/development for 1.0.1 version

Code for 1.0.1 version

Author: emptybutton

Diff for: sculpting/core.py

@@ -1,15 +1,18 @@
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Final, Tuple, Iterable, Any, Callable, TypeVar, Generic
+from typing import Final, Tuple, Iterable, Any, Callable, TypeVar, Generic, Optional, Union
 
-from pyhandling import returnly, by, documenting_by, mergely, take, close, post_partial, event_as, raise_, then
+from pyannotating import AnnotationTemplate, input_annotation
+from pyhandling import returnly, by, documenting_by, mergely, take, close, post_partial, event_as, raise_, then, to, next_action_decorator_of
 from pyhandling.annotations import dirty, reformer_of, handler
 
-from sculpting.annotations import attribute_getter_of, attribute_setter_of, attribute_getter, attribute_setter
+from sculpting.annotations import attribute_getter_of, attribute_setter_of, attribute_getter
 from sculpting.tools import setting_of_attr
 
 
 __all__ = (
     "Sculpture",
+    "material_of",
     "AttributeMap",
     "attribute_map_for",
     "read_only_attribute_map_as",
@@ -133,82 +136,133 @@ def changing_attribute_map_for(attribute_name: str, changer: reformer_of[Any]) -
     )
 
 
-OriginalT = TypeVar("OriginalT")
+_attribute_resource_for = (AnnotationTemplate |to| Union)([
+    str,
+    AnnotationTemplate(AttributeMap, [input_annotation]),
+    AnnotationTemplate(attribute_getter_of, [input_annotation])
+])
 
 
-@_method_proxies_to_attribute("__original", set(_MAGIC_METHODS_NAMES) - {"__repr__", "__str__"})
-class Sculpture(Generic[OriginalT]):
+def _attribute_map_from(
+    attribute_resource: _attribute_resource_for[AttributeOwnerT]
+) -> AttributeMap[AttributeOwnerT]:
+    """
+    Function to cast an unstructured attribute resource into a map of that
+    attribute.
     """
-    Virtual attribute mapping class for a real object.
 
-    Virtual attribute names are given keyword arguments as keys.
-    Values can be either the name of a real attribute of the original object, an
-    AttributeMap, or a function to get the value of this attribute from the
-    original object (in which case the attribute cannot be changed).
+    if isinstance(attribute_resource, AttributeMap):
+        return attribute_resource
+    elif callable(attribute_resource):
+        return read_only_attribute_map_as(attribute_resource)
+    else:
+        return attribute_map_for(attribute_resource)
+
+
+class _DynamicAttributeKepper(Generic[AttributeOwnerT], ABC):
+    """
+    Class for managing attributes by delegating these responsibilities to
+    functions.
     """
 
     def __init__(
         self,
-        original: OriginalT,
-        **virtual_attribute_resource_by_virtual_attribute_name: str | AttributeMap[OriginalT] | attribute_getter_of[OriginalT]
+        *,
+        _default_attribute_resource_factory: Optional[Callable[[str], _attribute_resource_for[AttributeOwnerT]]] = None,
+        **attribute_resource_by_attribute_name: _attribute_resource_for[AttributeOwnerT],
     ):
-        self.__original = original
-        self.__attribute_map_by_virtual_attribute_name = _dict_value_map(
-            self.__convert_virtual_attribute_resource_to_attribute_map,
-            virtual_attribute_resource_by_virtual_attribute_name
+        self._attribute_map_by_attribute_name = _dict_value_map(
+            _attribute_map_from,
+            attribute_resource_by_attribute_name
         )
 
-    def __repr__(self) -> str:
-        return f"Sculpture from {self.__original}"
+        self._default_attribute_map_for = (
+            _default_attribute_resource_factory |then>> _attribute_map_from
+            if _default_attribute_resource_factory is not None
+            else "Attribute \"{}\" is not allowed in {{}}".format |then>> mergely(
+                take(AttributeMap),
+                (getattr |by| "format") |then>> next_action_decorator_of(AttributeError |then>> raise_),
+                close(lambda template, obj, _: raise_(AttributeError(template.format(obj.__repr__()))))
+            )
+        )
 
     def __getattr__(self, attribute_name: str) -> Any:
-        if attribute_name[:1] == '_':
-            return object.__getattribute__(self, attribute_name)
-
-        self.__validate_availability_for(attribute_name)
-
-        return self.__attribute_map_by_virtual_attribute_name[attribute_name].getter(
-            self.__original
+        return (
+            object.__getattribute__(self, attribute_name)
+            if attribute_name[:1] == '_'
+            else self._attribute_value_for(
+                attribute_name,
+                self.__attribute_map_for(attribute_name)
+            )
         )
 
     def __setattr__(self, attribute_name: str, attribute_value: Any) -> Any:
-        if attribute_name[:1] == '_':
+        return (
             super().__setattr__(attribute_name, attribute_value)
-            return
+            if attribute_name[:1] == '_'
+            else self._set_attribute_value_for(
+                attribute_name,
+                attribute_value,
+                self.__attribute_map_for(attribute_name)
+            )
+        )
+
+    @abstractmethod
+    def _attribute_value_for(self, attribute_name: str, attribute_map: AttributeMap[AttributeOwnerT]) -> Any:
+        """Method for getting the value for an attribute by its map."""
 
-        self.__validate_availability_for(attribute_name)
+    @abstractmethod
+    def _set_attribute_value_for(self, attribute_name: str, attribute_value: Any, attribute_map: AttributeMap[AttributeOwnerT]) -> Any:
+        """Method for setting a value for an attribute by its map."""
 
-        return self.__attribute_map_by_virtual_attribute_name[attribute_name].setter(
-            self.__original,
-            attribute_value
+    def __attribute_map_for(self, attribute_name: str) -> AttributeMap[AttributeOwnerT]:
+        return (
+            self._attribute_map_by_attribute_name[attribute_name]
+            if attribute_name in self._attribute_map_by_attribute_name.keys()
+            else self._default_attribute_map_for(attribute_name)
         )
 
-    def __validate_availability_for(self, attribute_name: str) -> None:
-        """
-        Method of validation and possible subsequent error about the absence
-        of such a virtual attribute.
-        """
 
-        if attribute_name not in self.__attribute_map_by_virtual_attribute_name.keys():
-            raise AttributeError(
-                f"Attribute \"{attribute_name}\" is not allowed in {self.__repr__()}"
-            )
+OriginalT = TypeVar("OriginalT")
 
-    @staticmethod
-    def __convert_virtual_attribute_resource_to_attribute_map(
-        virtual_attribute_resource: str | AttributeMap[OriginalT] | attribute_getter_of[OriginalT]
-    ) -> AttributeMap[OriginalT]:
-        """
-        Function to cast an unstructured virtual attribute resource into a map
-        of that virtual attribute.
 
-        Implements casting according to the rules defined in the Sculpture
-        documentation.
-        """
+@_method_proxies_to_attribute("__original", set(_MAGIC_METHODS_NAMES) - {"__repr__", "__str__"})
+class Sculpture(_DynamicAttributeKepper, Generic[OriginalT]):
+    """
+    Virtual attribute mapping class for a real object.
+
+    Virtual attribute names are given keyword arguments as keys.
+    Values can be either the name of a real attribute of the original object, an
+    AttributeMap, or a function to get the value of this attribute from the
+    original object (in which case the attribute cannot be changed).
+    """
+
+    def __init__(
+        self,
+        original: OriginalT,
+        *,
+        _default_attribute_resource_factory: Optional[Callable[[str], _attribute_resource_for[AttributeOwnerT]]] = None,
+        **attribute_resource_by_attribute_name: _attribute_resource_for[OriginalT],
+    ):
+        super().__init__(
+            _default_attribute_resource_factory=_default_attribute_resource_factory,
+            **attribute_resource_by_attribute_name
+        )
 
-        if isinstance(virtual_attribute_resource, AttributeMap):
-            return virtual_attribute_resource
-        elif callable(virtual_attribute_resource):
-            return read_only_attribute_map_as(virtual_attribute_resource)
-        else:
-            return attribute_map_for(virtual_attribute_resource)
+        self.__original = original
+
+    def __repr__(self) -> str:
+        return f"Sculpture from {self.__original}"
+
+    def _attribute_value_for(self, attribute_name: str, attribute_map: AttributeMap[OriginalT]) -> Any:
+        return attribute_map.getter(self.__original)
+
+    def _set_attribute_value_for(self, attribute_name: str, attribute_value: Any, attribute_map: AttributeMap[OriginalT]) -> Any:
+        return attribute_map.setter(self.__original, attribute_value)
+
+
+material_of: Callable[[Sculpture[OriginalT]], OriginalT] = documenting_by(
+    """Function to get the object on which the input sculpture is based."""
+)(
+    getattr |by| "_Sculpture__original"
+)

Diff for: tests.py

@@ -1,6 +1,6 @@
 from typing import Any, Type
 
-from pyhandling import times, by, then, operation_by, execute_operation, to, ArgumentPack
+from pyhandling import times, by, then, operation_by, execute_operation, to, ArgumentPack, event_as, raise_
 from pytest import mark, raises
 
 from sculpting.annotations import attribute_getter, attribute_setter
@@ -134,6 +134,14 @@ def test_attribute_setter(
             "_",
             AttributeError
         ),
+        (
+            (Sculpture |to| AttributeKeeper())(
+                _default_attribute_resource_factory=TypeError |then>> (event_as |to| raise_)
+            ),
+            setting_of_attr("non_existent_attribute"),
+            "_",
+            TypeError
+        )
     ]
 )
 def test_attribute_setter_error_raising(
@@ -161,4 +169,9 @@ def test_sculpture_attribute_mapping(
 
     setattr(sculpture, virtual_attribute_name, new_attribute_value)
 
-    assert getattr(sculpture, virtual_attribute_name) == getattr(mapped, original_attribute_name)
+    assert getattr(sculpture, virtual_attribute_name) == getattr(mapped, original_attribute_name)
+
+
+@mark.parametrize("obj", [(AttributeKeeper(value=42), 42, None)])
+def test_original_from(obj: object):
+    assert material_of(Sculpture(obj)) is obj