Skip to content

setter

SetterAwareType

Bases: type

Metaclass for adding attributes used by :class:setter to __slots__.

Source code in src/robot/utils/setter.py 
84
85
86
87
88
89
90
91
92
93
94
class SetterAwareType(type):
    """Metaclass for adding attributes used by :class:`setter` to ``__slots__``."""

    def __new__(cls, name, bases, dct):
        if '__slots__' in dct:
            slots = list(dct['__slots__'])
            for item in dct.values():
                if isinstance(item, setter):
                    slots.append(item.attr_name)
            dct['__slots__'] = slots
        return type.__new__(cls, name, bases, dct)

setter

Bases: Generic[T, V, A]

Modify instance attributes only when they are set, not when they are get.

Usage::

1
2
3
@setter
def source(self, source: str|Path) -> Path:
    return source if isinstance(source, Path) else Path(source)

The setter method is called when the attribute is assigned like::

1
instance.source = 'example.txt'

and the returned value is stored in the instance in an attribute like _setter__source. When the attribute is accessed, the stored value is returned.

The above example is equivalent to using the standard property as follows. The main benefit of using setter is that it avoids a dummy getter method::

1
2
3
4
5
6
7
@property
def source(self) -> Path:
    return self._source

@source.setter
def source(self, source: src|Path):
    self._source = source if isinstance(source, Path) else Path(source)

When using setter with __slots__, the special _setter__xxx attributes needs to be added to __slots__ as well. The provided :class:SetterAwareType metaclass can take care of that automatically.

Source code in src/robot/utils/setter.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
class setter(Generic[T, V, A]):
    """Modify instance attributes only when they are set, not when they are get.

    Usage::

        @setter
        def source(self, source: str|Path) -> Path:
            return source if isinstance(source, Path) else Path(source)

    The setter method is called when the attribute is assigned like::

        instance.source = 'example.txt'

    and the returned value is stored in the instance in an attribute like
    ``_setter__source``. When the attribute is accessed, the stored value is
    returned.

    The above example is equivalent to using the standard ``property`` as
    follows. The main benefit of using ``setter`` is that it avoids a dummy
    getter method::

        @property
        def source(self) -> Path:
            return self._source

        @source.setter
        def source(self, source: src|Path):
            self._source = source if isinstance(source, Path) else Path(source)

    When using ``setter`` with ``__slots__``, the special ``_setter__xxx``
    attributes needs to be added to ``__slots__`` as well. The provided
    :class:`SetterAwareType` metaclass can take care of that automatically.
    """

    def __init__(self, method: Callable[[T, V], A]):
        self.method = method
        self.attr_name = '_setter__' + method.__name__
        self.__doc__ = method.__doc__

    @overload
    def __get__(self, instance: None, owner: Type[T]) -> 'setter':
        ...

    @overload
    def __get__(self, instance: T, owner: Type[T]) -> A:
        ...

    def __get__(self, instance: Union[T, None], owner: Type[T]) -> Union[A, 'setter']:
        if instance is None:
            return self
        try:
            return getattr(instance, self.attr_name)
        except AttributeError:
            raise AttributeError(self.method.__name__)

    def __set__(self, instance: T, value: V):
        if instance is not None:
            setattr(instance, self.attr_name, self.method(instance, value))