namedtuple_with_abc.py 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249
  1. # http://code.activestate.com/recipes/577629-namedtupleabc-abstract-base-class-mix-in-for-named/
  2. # Copyright (c) 2011 Jan Kaliszewski (zuo). Available under the MIT License.
  3. #
  4. # SPDX-License-Identifier: MIT
  5. #
  6. """
  7. namedtuple_with_abc.py:
  8. * named tuple mix-in + ABC (abstract base class) recipe,
  9. * works under Python 2.6, 2.7 as well as 3.x.
  10. Import this module to patch collections.namedtuple() factory function
  11. -- enriching it with the 'abc' attribute (an abstract base class + mix-in
  12. for named tuples) and decorating it with a wrapper that registers each
  13. newly created named tuple as a subclass of namedtuple.abc.
  14. How to import:
  15. import collections, namedtuple_with_abc
  16. or:
  17. import namedtuple_with_abc
  18. from collections import namedtuple
  19. # ^ in this variant you must import namedtuple function
  20. # *after* importing namedtuple_with_abc module
  21. or simply:
  22. from namedtuple_with_abc import namedtuple
  23. Simple usage example:
  24. class Credentials(namedtuple.abc):
  25. _fields = 'username password'
  26. def __str__(self):
  27. return ('{0.__class__.__name__}'
  28. '(username={0.username}, password=...)'.format(self))
  29. print(Credentials("alice", "Alice's password"))
  30. For more advanced examples -- see below the "if __name__ == '__main__':".
  31. """
  32. import collections
  33. from abc import ABCMeta, abstractproperty
  34. from functools import wraps
  35. from sys import version_info
  36. __all__ = ('namedtuple',)
  37. _namedtuple = collections.namedtuple
  38. class _NamedTupleABCMeta(ABCMeta):
  39. '''The metaclass for the abstract base class + mix-in for named tuples.'''
  40. def __new__(mcls, name, bases, namespace):
  41. fields = namespace.get('_fields')
  42. for base in bases:
  43. if fields is not None:
  44. break
  45. fields = getattr(base, '_fields', None)
  46. if not isinstance(fields, abstractproperty):
  47. basetuple = _namedtuple(name, fields)
  48. bases = (basetuple,) + bases
  49. namespace.pop('_fields', None)
  50. namespace.setdefault('__doc__', basetuple.__doc__)
  51. namespace.setdefault('__slots__', ())
  52. return ABCMeta.__new__(mcls, name, bases, namespace)
  53. class _NamedTupleABC(metaclass=_NamedTupleABCMeta):
  54. '''The abstract base class + mix-in for named tuples.'''
  55. _fields = abstractproperty()
  56. _namedtuple.abc = _NamedTupleABC
  57. #_NamedTupleABC.register(type(version_info)) # (and similar, in the future...)
  58. @wraps(_namedtuple)
  59. def namedtuple(*args, **kwargs):
  60. '''Named tuple factory with namedtuple.abc subclass registration.'''
  61. cls = _namedtuple(*args, **kwargs)
  62. _NamedTupleABC.register(cls)
  63. return cls
  64. collections.namedtuple = namedtuple
  65. if __name__ == '__main__':
  66. '''Examples and explanations'''
  67. # Simple usage
  68. class MyRecord(namedtuple.abc):
  69. _fields = 'x y z' # such form will be transformed into ('x', 'y', 'z')
  70. def _my_custom_method(self):
  71. return list(self._asdict().items())
  72. # (the '_fields' attribute belongs to the named tuple public API anyway)
  73. rec = MyRecord(1, 2, 3)
  74. print(rec)
  75. print(rec._my_custom_method())
  76. print(rec._replace(y=222))
  77. print(rec._replace(y=222)._my_custom_method())
  78. # Custom abstract classes...
  79. class MyAbstractRecord(namedtuple.abc):
  80. def _my_custom_method(self):
  81. return list(self._asdict().items())
  82. try:
  83. MyAbstractRecord() # (abstract classes cannot be instantiated)
  84. except TypeError as exc:
  85. print(exc)
  86. class AnotherAbstractRecord(MyAbstractRecord):
  87. def __str__(self):
  88. return '<<<{0}>>>'.format(super(AnotherAbstractRecord,
  89. self).__str__())
  90. # ...and their non-abstract subclasses
  91. class MyRecord2(MyAbstractRecord):
  92. _fields = 'a, b'
  93. class MyRecord3(AnotherAbstractRecord):
  94. _fields = 'p', 'q', 'r'
  95. rec2 = MyRecord2('foo', 'bar')
  96. print(rec2)
  97. print(rec2._my_custom_method())
  98. print(rec2._replace(b=222))
  99. print(rec2._replace(b=222)._my_custom_method())
  100. rec3 = MyRecord3('foo', 'bar', 'baz')
  101. print(rec3)
  102. print(rec3._my_custom_method())
  103. print(rec3._replace(q=222))
  104. print(rec3._replace(q=222)._my_custom_method())
  105. # You can also subclass non-abstract ones...
  106. class MyRecord33(MyRecord3):
  107. def __str__(self):
  108. return '< {0!r}, ..., {0!r} >'.format(self.p, self.r)
  109. rec33 = MyRecord33('foo', 'bar', 'baz')
  110. print(rec33)
  111. print(rec33._my_custom_method())
  112. print(rec33._replace(q=222))
  113. print(rec33._replace(q=222)._my_custom_method())
  114. # ...and even override the magic '_fields' attribute again
  115. class MyRecord345(MyRecord3):
  116. _fields = 'e f g h i j k'
  117. rec345 = MyRecord345(1, 2, 3, 4, 3, 2, 1)
  118. print(rec345)
  119. print(rec345._my_custom_method())
  120. print(rec345._replace(f=222))
  121. print(rec345._replace(f=222)._my_custom_method())
  122. # Mixing-in some other classes is also possible:
  123. class MyMixIn(object):
  124. def method(self):
  125. return "MyMixIn.method() called"
  126. def _my_custom_method(self):
  127. return "MyMixIn._my_custom_method() called"
  128. def count(self, item):
  129. return "MyMixIn.count({0}) called".format(item)
  130. def _asdict(self): # (cannot override a namedtuple method, see below)
  131. return "MyMixIn._asdict() called"
  132. class MyRecord4(MyRecord33, MyMixIn): # mix-in on the right
  133. _fields = 'j k l x'
  134. class MyRecord5(MyMixIn, MyRecord33): # mix-in on the left
  135. _fields = 'j k l x y'
  136. rec4 = MyRecord4(1, 2, 3, 2)
  137. print(rec4)
  138. print(rec4.method())
  139. print(rec4._my_custom_method()) # MyRecord33's
  140. print(rec4.count(2)) # tuple's
  141. print(rec4._replace(k=222))
  142. print(rec4._replace(k=222).method())
  143. print(rec4._replace(k=222)._my_custom_method()) # MyRecord33's
  144. print(rec4._replace(k=222).count(8)) # tuple's
  145. rec5 = MyRecord5(1, 2, 3, 2, 1)
  146. print(rec5)
  147. print(rec5.method())
  148. print(rec5._my_custom_method()) # MyMixIn's
  149. print(rec5.count(2)) # MyMixIn's
  150. print(rec5._replace(k=222))
  151. print(rec5._replace(k=222).method())
  152. print(rec5._replace(k=222)._my_custom_method()) # MyMixIn's
  153. print(rec5._replace(k=222).count(2)) # MyMixIn's
  154. # Note that behavior: the standard namedtuple methods cannot be
  155. # overridden by a foreign mix-in -- even if the mix-in is declared
  156. # as the leftmost base class (but, obviously, you can override them
  157. # in the defined class or its subclasses):
  158. print(rec4._asdict()) # (returns a dict, not "MyMixIn._asdict() called")
  159. print(rec5._asdict()) # (returns a dict, not "MyMixIn._asdict() called")
  160. class MyRecord6(MyRecord33):
  161. _fields = 'j k l x y z'
  162. def _asdict(self):
  163. return "MyRecord6._asdict() called"
  164. rec6 = MyRecord6(1, 2, 3, 1, 2, 3)
  165. print(rec6._asdict()) # (this returns "MyRecord6._asdict() called")
  166. # All that record classes are real subclasses of namedtuple.abc:
  167. assert issubclass(MyRecord, namedtuple.abc)
  168. assert issubclass(MyAbstractRecord, namedtuple.abc)
  169. assert issubclass(AnotherAbstractRecord, namedtuple.abc)
  170. assert issubclass(MyRecord2, namedtuple.abc)
  171. assert issubclass(MyRecord3, namedtuple.abc)
  172. assert issubclass(MyRecord33, namedtuple.abc)
  173. assert issubclass(MyRecord345, namedtuple.abc)
  174. assert issubclass(MyRecord4, namedtuple.abc)
  175. assert issubclass(MyRecord5, namedtuple.abc)
  176. assert issubclass(MyRecord6, namedtuple.abc)
  177. # ...but abstract ones are not subclasses of tuple
  178. # (and this is what you probably want):
  179. assert not issubclass(MyAbstractRecord, tuple)
  180. assert not issubclass(AnotherAbstractRecord, tuple)
  181. assert issubclass(MyRecord, tuple)
  182. assert issubclass(MyRecord2, tuple)
  183. assert issubclass(MyRecord3, tuple)
  184. assert issubclass(MyRecord33, tuple)
  185. assert issubclass(MyRecord345, tuple)
  186. assert issubclass(MyRecord4, tuple)
  187. assert issubclass(MyRecord5, tuple)
  188. assert issubclass(MyRecord6, tuple)
  189. # Named tuple classes created with namedtuple() factory function
  190. # (in the "traditional" way) are registered as "virtual" subclasses
  191. # of namedtuple.abc:
  192. MyTuple = namedtuple('MyTuple', 'a b c')
  193. mt = MyTuple(1, 2, 3)
  194. assert issubclass(MyTuple, namedtuple.abc)
  195. assert isinstance(mt, namedtuple.abc)