mptt.utils: 60 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/mptt/utils.py

Stats: 0 executed, 56 missed, 4 excluded, 122 ignored

1. """
2. Utilities for working with lists of model instances which represent
3. trees.
4. """
5. import copy
6. import csv
7. import itertools
8. import sys
10. __all__ = ('previous_current_next', 'tree_item_iterator',
11. 'drilldown_tree_for_node')
14. def previous_current_next(items):
15. """
16. From http://www.wordaligned.org/articles/zippy-triples-served-with-python
18. Creates an iterator which returns (previous, current, next) triples,
19. with ``None`` filling in when there is no previous or next
20. available.
21. """
22. extend = itertools.chain([None], items, [None])
23. previous, current, next = itertools.tee(extend, 3)
24. try:
25. current.next()
26. next.next()
27. next.next()
28. except StopIteration:
29. pass
30. return itertools.izip(previous, current, next)
33. def tree_item_iterator(items, ancestors=False):
34. """
35. Given a list of tree items, iterates over the list, generating
36. two-tuples of the current tree item and a ``dict`` containing
37. information about the tree structure around the item, with the
38. following keys:
40. ``'new_level'``
41. ``True`` if the current item is the start of a new level in
42. the tree, ``False`` otherwise.
44. ``'closed_levels'``
45. A list of levels which end after the current item. This will
46. be an empty list if the next item is at the same level as the
47. current item.
49. If ``ancestors`` is ``True``, the following key will also be
50. available:
52. ``'ancestors'``
53. A list of unicode representations of the ancestors of the
54. current node, in descending order (root node first, immediate
55. parent last).
57. For example: given the sample tree below, the contents of the
58. list which would be available under the ``'ancestors'`` key
59. are given on the right::
61. Books -> []
62. Sci-fi -> [u'Books']
63. Dystopian Futures -> [u'Books', u'Sci-fi']
65. """
66. structure = {}
67. opts = None
68. first_item_level = 0
69. for previous, current, next in previous_current_next(items):
70. if opts is None:
71. opts = current._mptt_meta
73. current_level = getattr(current, opts.level_attr)
74. if previous:
75. structure['new_level'] = (getattr(previous,
76. opts.level_attr) < current_level)
77. if ancestors:
78. # If the previous node was the end of any number of
79. # levels, remove the appropriate number of ancestors
80. # from the list.
81. if structure['closed_levels']:
82. structure['ancestors'] = \
83. structure['ancestors'][:-len(structure['closed_levels'])]
84. # If the current node is the start of a new level, add its
85. # parent to the ancestors list.
86. if structure['new_level']:
87. structure['ancestors'].append(unicode(previous))
88. else:
89. structure['new_level'] = True
90. if ancestors:
91. # Set up the ancestors list on the first item
92. structure['ancestors'] = []
94. first_item_level = current_level
95. if next:
96. structure['closed_levels'] = range(current_level,
97. getattr(next,
98. opts.level_attr), -1)
99. else:
100. # All remaining levels need to be closed
101. structure['closed_levels'] = range(current_level, first_item_level - 1, -1)
103. # Return a deep copy of the structure dict so this function can
104. # be used in situations where the iterator is consumed
105. # immediately.
106. yield current, copy.deepcopy(structure)
109. def drilldown_tree_for_node(node, rel_cls=None, rel_field=None, count_attr=None,
110. cumulative=False):
111. """
112. Creates a drilldown tree for the given node. A drilldown tree
113. consists of a node's ancestors, itself and its immediate children,
114. all in tree order.
116. Optional arguments may be given to specify a ``Model`` class which
117. is related to the node's class, for the purpose of adding related
118. item counts to the node's children:
120. ``rel_cls``
121. A ``Model`` class which has a relation to the node's class.
123. ``rel_field``
124. The name of the field in ``rel_cls`` which holds the relation
125. to the node's class.
127. ``count_attr``
128. The name of an attribute which should be added to each child in
129. the drilldown tree, containing a count of how many instances
130. of ``rel_cls`` are related through ``rel_field``.
132. ``cumulative``
133. If ``True``, the count will be for each child and all of its
134. descendants, otherwise it will be for each child itself.
135. """
136. if rel_cls and rel_field and count_attr:
137. children = node._tree_manager.add_related_count(
138. node.get_children(), rel_cls, rel_field, count_attr, cumulative)
139. else:
140. children = node.get_children()
141. return itertools.chain(node.get_ancestors(), [node], children)
144. def print_debug_info(qs):
145. """
146. Given an mptt queryset, prints some debug information to stdout.
147. Use this when things go wrong.
148. Please include the output from this method when filing bug issues.
149. """
150. opts = qs.model._mptt_meta
151. writer = csv.writer(sys.stdout)
152. header = (
153. 'pk',
154. opts.level_attr,
155. '%s_id' % opts.parent_attr,
156. opts.tree_id_attr,
157. opts.left_attr,
158. opts.right_attr,
159. 'pretty',
160. )
161. writer.writerow(header)
162. for n in qs.order_by('tree_id', 'lft'):
163. level = getattr(n, opts.level_attr)
164. row = []
165. for field in header[:-1]:
166. row.append(getattr(n, field))
167. row.append('%s%s' % ('- ' * level, unicode(n).encode('utf-8')))
168. writer.writerow(row)
171. # NOTE we don't support django 1.1 anymore, so this stuff is likely to get removed soon
172. def _exists(qs):
173. """
174. For Django 1.1 compatibility. (QuerySet.exists() was added in 1.2)
176. This is not part of the supported mptt API, it may be removed without warning.
177. """
178. if hasattr(qs, 'exists'):
179. return qs.exists()
180. else:
181. qs = qs.extra(select={'_exists_check': '1'}).values_list('_exists_check', flat=True)[:1]
182. return bool(len(qs))