Source Code for Module advene.model.core.group

  1  """I define `GroupMixin`, a helper class to implement groups.""" 
  2   
  3  from itertools import chain 
  4   
  5  from advene.model.core.element import MEDIA, ANNOTATION, RELATION, LIST, \ 
  6                                        TAG, VIEW, QUERY, RESOURCE, IMPORT, \ 
  7                                        ElementCollection 
  8   
  9 -class GroupMixin(object): 
 10      """I provide default implementation for all methods of the Group interface. 
 11   
 12      Note that at least __iter__ or all the iter_* methods must be implemented 
 13      by subclasses, for in this implementation, they depend on each other. 
 14      """ 
 15   
 16 -    def __iter__(self): 
 17          return chain(*( 
 18              self.iter_medias(), 
 19              self.iter_annotations(), 
 20              self.iter_relations(), 
 21              self.iter_lists(), 
 22              self.iter_tags(), 
 23              self.iter_views(), 
 24              self.iter_queries(), 
 25              self.iter_resources(), 
 26              self.iter_imports(), 
 27          )) 
 28   
 29 -    def iter_medias(self): 
 30          for i in self: 
 31              if i.ADVENE_TYPE == MEDIA: 
 32                  yield i 
 33   
 34 -    def iter_annotations(self): 
 35          for i in self: 
 36              if i.ADVENE_TYPE == ANNOTATION: 
 37                  yield i 
 38   
 39 -    def iter_relations(self): 
 40          for i in self: 
 41              if i.ADVENE_TYPE == RELATION: 
 42                  yield i 
 43   
 44 -    def iter_lists(self): 
 45          for i in self: 
 46              if i.ADVENE_TYPE == LIST: 
 47                  yield i 
 48   
 49 -    def iter_tags(self): 
 50          for i in self: 
 51              if i.ADVENE_TYPE == TAG: 
 52                  yield i 
 53   
 54 -    def iter_views(self): 
 55          for i in self: 
 56              if i.ADVENE_TYPE == VIEW: 
 57                  yield i 
 58   
 59 -    def iter_queries(self): 
 60          for i in self: 
 61              if i.ADVENE_TYPE == QUERY: 
 62                  yield i 
 63   
 64 -    def iter_resources(self): 
 65          for i in self: 
 66              if i.ADVENE_TYPE == RESOURCE: 
 67                  yield i 
 68   
 69 -    def iter_imports(self): 
 70          for i in self: 
 71              if i.ADVENE_TYPE == IMPORT: 
 72                  yield i 
 73   
 74   
 75 -    def count_medias(self): 
 76          return len(list(self.iter_medias())) 
 77   
 78 -    def count_annotations(self): 
 79          return len(list(self.iter_annotations())) 
 80   
 81 -    def count_relations(self): 
 82          return len(list(self.iter_relations())) 
 83   
 84 -    def count_lists(self): 
 85          return len(list(self.iter_lists())) 
 86   
 87 -    def count_tags(self): 
 88          return len(list(self.iter_tags())) 
 89   
 90 -    def count_views(self): 
 91          return len(list(self.iter_views())) 
 92   
 93 -    def count_queries(self): 
 94          return len(list(self.iter_queries())) 
 95   
 96 -    def count_resources(self): 
 97          return len(list(self.iter_resources())) 
 98   
 99 -    def count_imports(self): 
100          return len(list(self.iter_imports())) 
101   
102      @property 
103 -    def medias(group): 
104          class GroupMedias(ElementCollection): 
105              __iter__ = group.iter_medias 
106              __len__ = group.count_medias 
107              def __contains__(self, e): 
108                  return getattr(e, "ADVENE_TYPE", None) == MEDIA and e in group 
109          return GroupMedias(group.owner) 
110   
111      @property 
112 -    def annotations(group): 
113          class GroupAnnotations(ElementCollection): 
114              __iter__ = group.iter_annotations 
115              __len__ = group.count_annotations 
116              def __contains__(self, e): 
117                  return getattr(e, "ADVENE_TYPE", None) == ANNOTATION \ 
118                     and e in group 
119          return GroupAnnotations(group.owner) 
120   
121      @property 
122 -    def relations(group): 
123          class GroupRelations(ElementCollection): 
124              __iter__ = group.iter_relations 
125              __len__ = group.count_relations 
126              def __contains__(self, e): 
127                  return getattr(e, "ADVENE_TYPE", None) == RELATION \ 
128                     and e in group 
129          return GroupRelations(group.owner) 
130   
131      @property 
132 -    def views(group): 
133          class GroupViews(ElementCollection): 
134              __iter__ = group.iter_views 
135              __len__ = group.count_views 
136              def __contains__(self, e): 
137                  return getattr(e, "ADVENE_TYPE", None) == VIEW and e in group 
138          return GroupViews(group.owner) 
139   
140      @property 
141 -    def resources(group): 
142          class GroupResources(ElementCollection): 
143              __iter__ = group.iter_resources 
144              __len__ = group.count_resources 
145              def __contains__(self, e): 
146                  return getattr(e, "ADVENE_TYPE", None) == RESOURCE \ 
147                     and e in group 
148          return GroupResources(group.owner) 
149   
150      @property 
151 -    def tags(group): 
152          class GroupTags(ElementCollection): 
153              __iter__ = group.iter_tags 
154              __len__ = group.count_tags 
155              def __contains__(self, e): 
156                  return getattr(e, "ADVENE_TYPE", None) == TAG and e in group 
157          return GroupTags(group.owner) 
158   
159      @property 
160 -    def lists(group): 
161          class GroupLists(ElementCollection): 
162              __iter__ = group.iter_lists 
163              __len__ = group.count_lists 
164              def __contains__(self, e): 
165                  return getattr(e, "ADVENE_TYPE", None) == LIST and e in group 
166          return GroupLists(group.owner) 
167   
168      @property 
169 -    def queries(group): 
170          class GroupQueries(ElementCollection): 
171              __iter__ = group.iter_queries 
172              __len__ = group.count_queries 
173              def __contains__(self, e): 
174                  return getattr(e, "ADVENE_TYPE", None) == QUERY and e in group 
175          return GroupQueries(group.owner) 
176   
177      @property 
178 -    def imports(group): 
179          class GroupImports(ElementCollection): 
180              __iter__ = group.iter_imports 
181              __len__ = group.count_imports 
182              def __contains__(self, e): 
183                  return getattr(e, "ADVENE_TYPE", None) == IMPORT and e in group 
184          return GroupImports(group.owner) 
185