namedtuple_with_abc.py 8.6 KB

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