| import types |
|
|
| from pure_eval.utils import of_type, CannotEval |
|
|
| _sentinel = object() |
|
|
|
|
| def _static_getmro(klass): |
| return type.__dict__['__mro__'].__get__(klass) |
|
|
|
|
| def _check_instance(obj, attr): |
| instance_dict = {} |
| try: |
| instance_dict = object.__getattribute__(obj, "__dict__") |
| except AttributeError: |
| pass |
| return dict.get(instance_dict, attr, _sentinel) |
|
|
|
|
| def _check_class(klass, attr): |
| for entry in _static_getmro(klass): |
| if _shadowed_dict(type(entry)) is _sentinel: |
| try: |
| return entry.__dict__[attr] |
| except KeyError: |
| pass |
| else: |
| break |
| return _sentinel |
|
|
|
|
| def _is_type(obj): |
| try: |
| _static_getmro(obj) |
| except TypeError: |
| return False |
| return True |
|
|
|
|
| def _shadowed_dict(klass): |
| dict_attr = type.__dict__["__dict__"] |
| for entry in _static_getmro(klass): |
| try: |
| class_dict = dict_attr.__get__(entry)["__dict__"] |
| except KeyError: |
| pass |
| else: |
| if not (type(class_dict) is types.GetSetDescriptorType and |
| class_dict.__name__ == "__dict__" and |
| class_dict.__objclass__ is entry): |
| return class_dict |
| return _sentinel |
|
|
|
|
| def getattr_static(obj, attr): |
| """Retrieve attributes without triggering dynamic lookup via the |
| descriptor protocol, __getattr__ or __getattribute__. |
| |
| Note: this function may not be able to retrieve all attributes |
| that getattr can fetch (like dynamically created attributes) |
| and may find attributes that getattr can't (like descriptors |
| that raise AttributeError). It can also return descriptor objects |
| instead of instance members in some cases. See the |
| documentation for details. |
| """ |
| instance_result = _sentinel |
| if not _is_type(obj): |
| klass = type(obj) |
| dict_attr = _shadowed_dict(klass) |
| if (dict_attr is _sentinel or |
| type(dict_attr) is types.MemberDescriptorType): |
| instance_result = _check_instance(obj, attr) |
| else: |
| raise CannotEval |
| else: |
| klass = obj |
|
|
| klass_result = _check_class(klass, attr) |
|
|
| if instance_result is not _sentinel and klass_result is not _sentinel: |
| if _check_class(type(klass_result), "__get__") is not _sentinel and ( |
| _check_class(type(klass_result), "__set__") is not _sentinel |
| or _check_class(type(klass_result), "__delete__") is not _sentinel |
| ): |
| return _resolve_descriptor(klass_result, obj, klass) |
|
|
| if instance_result is not _sentinel: |
| return instance_result |
| if klass_result is not _sentinel: |
| get = _check_class(type(klass_result), '__get__') |
| if get is _sentinel: |
| return klass_result |
| else: |
| if obj is klass: |
| instance = None |
| else: |
| instance = obj |
| return _resolve_descriptor(klass_result, instance, klass) |
|
|
| if obj is klass: |
| |
| for entry in _static_getmro(type(klass)): |
| if _shadowed_dict(type(entry)) is _sentinel: |
| try: |
| result = entry.__dict__[attr] |
| get = _check_class(type(result), '__get__') |
| if get is not _sentinel: |
| raise CannotEval |
| return result |
| except KeyError: |
| pass |
| raise CannotEval |
|
|
|
|
| class _foo: |
| __slots__ = ['foo'] |
| method = lambda: 0 |
|
|
|
|
| slot_descriptor = _foo.foo |
| wrapper_descriptor = str.__dict__['__add__'] |
| method_descriptor = str.__dict__['startswith'] |
| user_method_descriptor = _foo.__dict__['method'] |
|
|
| safe_descriptors_raw = [ |
| slot_descriptor, |
| wrapper_descriptor, |
| method_descriptor, |
| user_method_descriptor, |
| ] |
|
|
| safe_descriptor_types = list(map(type, safe_descriptors_raw)) |
|
|
|
|
| def _resolve_descriptor(d, instance, owner): |
| try: |
| return type(of_type(d, *safe_descriptor_types)).__get__(d, instance, owner) |
| except AttributeError as e: |
| raise CannotEval from e |
|
|
