advene.model.core.all

1 """I define class AllGroup. 2 """ 3 4 from advene.model.core.group import GroupMixin 5 from advene.model.core.own_group import _prepare_meta 6 from advene.util.autoproperty import autoproperty 7 from advene.util.itertools import interclass

8 9 -class AllGroup(GroupMixin, object):

10 """FIXME: missing docstring. 11 """ 12 13 # TODO filtering parameters in iter_X and count_X have not been all added 14 # because of a lack of time, not for some good reason. 15 # So they shall be added whenever needed, or systematically when someone 16 # get the time to do it. 17

18 - def __init__(self, owner):

19 self._owner = owner

20 21 @autoproperty

22 - def _get_owner(self):

23 return self._owner

24

25 - def __contains__(self, element):

26 if not hasattr(element, "ADVENE_TYPE"): 27 return False 28 eo = element._owner 29 so = self._owner 30 if so is eo: 31 return element._id in so._elements 32 else: 33 be = eo._backend 34 id = eo._id 35 ids = so._backends_dict.get(be) 36 if ids and id in ids: 37 assert be.has_element(element._id), "Internal error: %s is not in the backend." % element._id 38 # since the instance is there and working, 39 # it must be in the backend 40 return True 41 else: 42 return False

43

44 - def iter_medias(self):

45 o = self._owner 46 for be, pdict in o._backends_dict.items(): 47 for i in be.iter_medias(pdict): 48 yield pdict[i[1]].get_element(i)

49

50 - def iter_annotations(self, media=None, 51 begin=None, begin_min=None, begin_max=None, 52 end=None, end_min=None, end_max=None, 53 at=None):

54 """FIXME: missing docstring. 55 """ 56 o = self._owner 57 58 if hasattr(media, '_get_uriref'): 59 media = media._get_uriref() 60 elif media is not None: 61 # It should be a sequence/iterator of medias 62 media = (m._get_uriref() for m in media) 63 if at is not None: 64 begin_max = end_min = at 65 def annotation_iterator(be, pdict): 66 for i in be.iter_annotations(pdict, None, media, 67 begin, begin_min, begin_max, 68 end, end_min, end_max): 69 yield pdict[i[1]].get_element(i)

70 all_annotation_iterators = [ annotation_iterator(be, pdict) 71 for be, pdict 72 in o._backends_dict.items() ] 73 return interclass(*all_annotation_iterators)

74

75 - def iter_relations(self, member=None, position=None):

76 """FIXME: missing docstring. 77 """ 78 assert position is None or member is not None 79 if member: member = member._get_uriref() 80 o = self._owner 81 for be, pdict in o._backends_dict.items(): 82 for i in be.iter_relations(pdict, None, member, position): 83 yield pdict[i[1]].get_element(i)

84

85 - def iter_lists(self, item=None, position=None, meta=None):

86 """FIXME: missing docstring. 87 """ 88 assert position is None or item is not None 89 if item: item = item._get_uriref() 90 if meta: meta = _prepare_meta(meta) 91 o = self._owner 92 for be, pdict in o._backends_dict.items(): 93 for i in be.iter_lists(pdict, None, item, position, meta): 94 yield pdict[i[1]].get_element(i)

95

96 - def iter_tags(self, meta=None):

97 if meta: meta = _prepare_meta(meta) 98 o = self._owner 99 for be, pdict in o._backends_dict.items(): 100 for i in be.iter_tags(pdict, None, meta): 101 yield pdict[i[1]].get_element(i)

102

103 - def iter_imports(self, url=None, uri=None):

104 o = self._owner 105 for be, pdict in o._backends_dict.items(): 106 for i in be.iter_imports(pdict, None, url, uri): 107 yield pdict[i[1]].get_element(i)

108

109 - def iter_queries(self):

110 o = self._owner 111 for be, pdict in o._backends_dict.items(): 112 for i in be.iter_queries(pdict): 113 yield pdict[i[1]].get_element(i)

114

115 - def iter_views(self):

116 o = self._owner 117 for be, pdict in o._backends_dict.items(): 118 for i in be.iter_views(pdict): 119 yield pdict[i[1]].get_element(i)

120

121 - def iter_resources(self):

122 o = self._owner 123 for be, pdict in o._backends_dict.items(): 124 for i in be.iter_resources(pdict): 125 yield pdict[i[1]].get_element(i)

126

127 - def count_medias(self):

128 o = self._owner 129 return sum( be.count_medias(pdict) 130 for be, pdict in o._backends_dict.items() )

131

132 - def count_annotations(self, media=None, 133 begin=None, begin_min=None, begin_max=None, 134 end=None, end_min=None, end_max=None, 135 at=None):

136 o = self._owner 137 if hasattr(media, '_get_uriref'): 138 media = media._get_uriref() 139 elif media is not None: 140 # It should be a sequence/iterator of medias 141 media = (m._get_uriref() for m in media) 142 if at is not None: 143 begin_max = end_min = at 144 return sum( be.count_annotations(pdict, None, media, 145 begin, begin_min, begin_max, 146 end, end_min, end_max) 147 for be, pdict in o._backends_dict.items() )

148

149 - def count_relations(self, member=None, position=None):

150 assert position is None or member is not None 151 if member: member = member._get_uriref() 152 o = self._owner 153 return sum( be.count_relations(pdict, None, member, position) 154 for be, pdict in o._backends_dict.items() )

155

156 - def count_views(self):

157 o = self._owner 158 return sum( be.count_views(pdict) 159 for be, pdict in o._backends_dict.items() )

160

161 - def count_resources(self):

162 o = self._owner 163 return sum( be.count_resources(pdict) 164 for be, pdict in o._backends_dict.items() )

165

166 - def count_tags(self, meta=None):

167 if meta: meta = _prepare_meta(meta) 168 o = self._owner 169 return sum( be.count_tags(pdict, None, meta) 170 for be, pdict in o._backends_dict.items() )

171

172 - def count_lists(self, item=None, position=None, meta=None):

173 assert position is None or item is not None 174 if item: item = item._get_uriref() 175 if meta: meta = _prepare_meta(meta) 176 o = self._owner 177 return sum( be.count_lists(pdict, None, item, position, meta) 178 for be, pdict in o._backends_dict.items() )

179

180 - def count_queries(self):

181 o = self._owner 182 return sum( be.count_queries(pdict) 183 for be, pdict in o._backends_dict.items() )

184

185 - def count_imports(self, url=None, uri=None):

186 o = self._owner 187 return sum( be.count_imports(pdict, url, uri) 188 for be, pdict in o._backends_dict.items() )

189

Source Code for Module advene.model.core.all_group