Repository navigation
Expand file tree
/
Copy pathfacade.py
More file actions
123 lines (98 loc) · 4.26 KB
/
Copy pathfacade.py
File metadata and controls
123 lines (98 loc) · 4.26 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
import functools
import inspect
class ProxyAttr:
"""
Descriptor class for wrapping attributes of the wrapped instance.
Used with the `Proxy` class, this class is used to set exposed attributes of the wrapped instance while providing
optional type casting.
"""
def __init__(self, cast=False):
self._cast__ = cast
def __set_name__(self, owner, name):
cast = self._cast__
if cast:
def getter(self):
value = getattr(self._wrapped__, name)
return cast(value) if value is not None else None
else:
def getter(self):
return getattr(self._wrapped__, name)
def setter(self, value):
return setattr(self._wrapped__, name, value)
setattr(owner, name, property(getter, setter))
class ProxyFunc:
"""
Descriptor class for wrapping functions of the wrapped instance.
Used with the `Proxy` class, this class is used to set exposed functions of the wrapped instance
while also allowing optional type casting on return values.
"""
def __init__(self, cast=False):
self._cast__ = cast
def __set_name__(self, owner, name):
func = getattr(owner._wrapped__, name)
descriptor = inspect.getattr_static(owner._wrapped__, name)
cast = self._cast__
if isinstance(descriptor, staticmethod):
if cast:
def wrap_func(*args, **kwargs):
result = func(*args, **kwargs)
return cast(result) if result is not None else None
elif cast is None:
def wrap_func(*args, **kwargs):
func(*args, **kwargs)
else:
def wrap_func(*args, **kwargs):
return func(*args, **kwargs)
functools.update_wrapper(wrap_func, func)
wrap_func = staticmethod(wrap_func)
elif isinstance(descriptor, classmethod):
if cast:
def wrap_func(cls, *args, **kwargs):
result = func(*args, **kwargs)
return cast(result) if result is not None else None
elif cast is None:
def wrap_func(cls, *args, **kwargs):
func(*args, **kwargs)
else:
def wrap_func(cls, *args, **kwargs):
return func(*args, **kwargs)
functools.update_wrapper(wrap_func, func)
wrap_func = classmethod(wrap_func)
else:
if cast:
def wrap_func(self, *args, **kwargs):
result = func(self._wrapped__, *args, **kwargs)
return cast(result) if result is not None else None
elif cast is None:
def wrap_func(self, *args, **kwargs):
func(self._wrapped__, *args, **kwargs)
else:
def wrap_func(self, *args, **kwargs):
return func(self._wrapped__, *args, **kwargs)
functools.update_wrapper(wrap_func, func)
setattr(owner, name, wrap_func)
class ProxyMeta(type):
def __new__(cls, clsname, bases, attrs):
attrs.update({func: ProxyFunc() for func in ("__repr__", "__str__") if func not in attrs})
proxy_class = super().__new__(cls, clsname, bases, attrs)
# To preserve the docstring, signature, code of the wrapped class
# `updated` to an emtpy list so it doesn't copy the `__dict__`
# See `functools.WRAPPER_ASSIGNMENTS` and `functools.WRAPPER_UPDATES`
functools.update_wrapper(proxy_class, proxy_class._wrapped__, updated=[])
return proxy_class
class Proxy(metaclass=ProxyMeta):
"""
A proxy class implementing the Facade pattern.
This class delegates to an underlying instance while exposing a curated subset of its attributes and methods.
Useful for controlling access, simplifying interfaces, or adding cross-cutting concerns.
"""
_wrapped__ = object
def __init__(self, instance):
"""
Initializes the proxy by setting the wrapped instance.
:param instance: The instance of the class to be wrapped.
"""
object.__setattr__(self, "_wrapped__", instance)
@property
def __class__(self):
return type(self)._wrapped__