我们从Python开源项目中，提取了以下23个代码示例，用于说明如何使用types.DynamicClassAttribute()。
def test_property___isabstractmethod__descriptor(self): for val in (True, False, [], [1], '', '1'): class C(object): def foo(self): pass foo.__isabstractmethod__ = val foo = DynamicClassAttribute(foo) self.assertIs(C.__dict__['foo'].__isabstractmethod__, bool(val)) # check that the DynamicClassAttribute's __isabstractmethod__ descriptor does the # right thing when presented with a value that fails truth testing: class NotBool(object): def __bool__(self): raise ValueError() __len__ = __bool__ with self.assertRaises(ValueError): class C(object): def foo(self): pass foo.__isabstractmethod__ = NotBool() foo = DynamicClassAttribute(foo)
def test_property___isabstractmethod__descriptor(self): for val in (True, False, [], [1], '', '1'): class C(object): def foo(self): pass foo.__isabstractmethod__ = val foo = DynamicClassAttribute(foo) self.assertIs(C.__dict__['foo'].__isabstractmethod__, bool(val)) # check that the DynamicClassAttribute's __isabstractmethod__ descriptor does the # right thing when presented with a value that fails truth testing: class NotBool(object): def __nonzero__(self): raise ValueError() __len__ = __nonzero__ with self.assertRaises(ValueError): class C(object): def foo(self): pass foo.__isabstractmethod__ = NotBool() foo = DynamicClassAttribute(foo)
def __reduce_ex__(self, proto): return self.__class__, (self._value_, ) # DynamicClassAttribute is used to provide access to the `name` and # `value` properties of enum members while keeping some measure of # protection from modification, while still allowing for an enumeration # to have members named `name` and `value`. This works because enumeration # members are not set directly on the enum class -- __getattr__ is # used to look them up.
def test_abstract_virtual(self): self.assertRaises(TypeError, ClassWithAbstractVirtualProperty) self.assertRaises(TypeError, ClassWithPropertyAbstractVirtual) class APV(ClassWithPropertyAbstractVirtual): pass self.assertRaises(TypeError, APV) class AVP(ClassWithAbstractVirtualProperty): pass self.assertRaises(TypeError, AVP) class Okay1(ClassWithAbstractVirtualProperty): @DynamicClassAttribute def color(self): return self._color def __init__(self): self._color = 'cyan' with self.assertRaises(AttributeError): Okay1.color self.assertEqual(Okay1().color, 'cyan') class Okay2(ClassWithAbstractVirtualProperty): @DynamicClassAttribute def color(self): return self._color def __init__(self): self._color = 'magenta' with self.assertRaises(AttributeError): Okay2.color self.assertEqual(Okay2().color, 'magenta') # Issue 5890: subclasses of DynamicClassAttribute do not preserve method __doc__ strings
def test_docstring_copy(self): class Foo(object): @PropertySub def spam(self): """spam wrapped in DynamicClassAttribute subclass""" return 1 self.assertEqual( Foo.__dict__['spam'].__doc__, "spam wrapped in DynamicClassAttribute subclass")
def test_property_setter_copies_getter_docstring(self): class Foo(object): def __init__(self): self._spam = 1 @PropertySub def spam(self): """spam wrapped in DynamicClassAttribute subclass""" return self._spam @spam.setter def spam(self, value): """this docstring is ignored""" self._spam = value foo = Foo() self.assertEqual(foo.spam, 1) foo.spam = 2 self.assertEqual(foo.spam, 2) self.assertEqual( Foo.__dict__['spam'].__doc__, "spam wrapped in DynamicClassAttribute subclass") class FooSub(Foo): spam = Foo.__dict__['spam'] @spam.setter def spam(self, value): """another ignored docstring""" self._spam = 'eggs' foosub = FooSub() self.assertEqual(foosub.spam, 1) foosub.spam = 7 self.assertEqual(foosub.spam, 'eggs') self.assertEqual( FooSub.__dict__['spam'].__doc__, "spam wrapped in DynamicClassAttribute subclass")
def test_classify_DynamicClassAttribute(self): class Meta(type): def __getattr__(self, name): if name == 'ham': return 'spam' return super().__getattr__(name) class VA(metaclass=Meta): @types.DynamicClassAttribute def ham(self): return 'eggs' should_find_dca = inspect.Attribute('ham', 'data', VA, VA.__dict__['ham']) self.assertIn(should_find_dca, inspect.classify_class_attrs(VA)) should_find_ga = inspect.Attribute('ham', 'data', Meta, 'spam') self.assertIn(should_find_ga, inspect.classify_class_attrs(VA))
def test_getmembers_VirtualAttribute(self): class M(type): def __getattr__(cls, name): if name == 'eggs': return 'scrambled' return super().__getattr__(name) class A(metaclass=M): @types.DynamicClassAttribute def eggs(self): return 'spam' self.assertIn(('eggs', 'scrambled'), inspect.getmembers(A)) self.assertIn(('eggs', 'spam'), inspect.getmembers(A()))
def test_classVirtualAttribute(self): class Thing(object): @types.DynamicClassAttribute def x(self): return self._x _x = object() self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.__dict__['x'])
def getmembers(object, predicate=None): """Return all members of an object as (name, value) pairs sorted by name. Optionally, only return members that satisfy a given predicate.""" if isclass(object): mro = (object,) + getmro(object) else: mro = () results = [] processed = set() names = dir(object) # :dd any DynamicClassAttributes to the list of names if object is a class; # this may result in duplicate entries if, for example, a virtual # attribute with the same name as a DynamicClassAttribute exists try: for base in object.__bases__: for k, v in base.__dict__.items(): if isinstance(v, types.DynamicClassAttribute): names.append(k) except AttributeError: pass for key in names: # First try to get the value via getattr. Some descriptors don't # like calling their __get__ (see bug #1785), so fall back to # looking in the __dict__. try: value = getattr(object, key) # handle the duplicate key if key in processed: raise AttributeError except AttributeError: for base in mro: if key in base.__dict__: value = base.__dict__[key] break else: # could be a (currently) missing slot member, or a buggy # __dir__; discard and move on continue if not predicate or predicate(value): results.append((key, value)) processed.add(key) results.sort(key=lambda pair: pair[0]) return results
