Source Code for Module advene.model.core.own_group

  1  """ 
  2  I define the class OwnGroup. 
  3   
  4  This class is intended to be used only inside class Package. 
  5  """ 
  6   
  7  from advene.model.core.group import GroupMixin 
  8  from advene.util.autoproperty import autoproperty 
  9   
 10 -class OwnGroup(GroupMixin, object): 
 11   
 12      # TODO filtering parameters in iter_X and count_X have not been all added 
 13      # because of a lack of time, not for some good reason. 
 14      # So they shall be added whenever needed, or systematically when someone 
 15      # get the time to do it 
 16   
 17 -    def __init__(self, owner): 
 18          self._owner = owner 
 19   
 20      @autoproperty 
 21 -    def _get_owner(self): 
 22          return self._owner 
 23   
 24 -    def __contains__(self, element): 
 25          # the element is constructed, so if it belongs to the package, it must 
 26          # be present in its _elements attribute 
 27          return getattr(element, "_owner", None) is self._owner \ 
 28             and element._id in self._owner._elements 
 29   
 30 -    def iter_medias(self): 
 31          o = self._owner 
 32          for i in o._backend.iter_medias((o._id,)): 
 33              yield o.get_element(i) 
 34   
 35 -    def iter_annotations(self, media=None, 
 36                                 begin=None, begin_min=None, begin_max=None, 
 37                                 end=None, end_min=None, end_max=None, 
 38                                 at=None): 
 39          if hasattr(media, '_get_uriref'): 
 40              media = media._get_uriref() 
 41          elif media is not None: 
 42              # It should be a sequence/iterator of medias 
 43              media = (m._get_uriref() for m in media) 
 44          if at is not None: 
 45              begin_max = end_min = at 
 46          o = self._owner 
 47          for i in o._backend.iter_annotations((o._id,), None, 
 48                                                media, 
 49                                                begin, begin_min, begin_max, 
 50                                                end, end_min, end_max): 
 51              yield o.get_element(i) 
 52   
 53 -    def iter_relations(self, member=None, position=None): 
 54          assert position is None or member is not None 
 55          if member: 
 56              member = member._get_uriref() 
 57          o = self._owner 
 58          for i in o._backend.iter_relations((o._id,), None, member, position): 
 59              yield o.get_element(i) 
 60   
 61 -    def iter_views(self): 
 62          o = self._owner 
 63          for i in o._backend.iter_views((o._id,)): 
 64              yield o.get_element(i) 
 65   
 66 -    def iter_resources(self): 
 67          o = self._owner 
 68          for i in o._backend.iter_resources((o._id,)): 
 69              yield o.get_element(i) 
 70   
 71 -    def iter_tags(self, meta=None): 
 72          if meta: meta = _prepare_meta(meta) 
 73          o = self._owner 
 74          for i in o._backend.iter_tags((o._id,), None, meta): 
 75              yield o.get_element(i) 
 76   
 77 -    def iter_lists(self, item=None, position=None, meta=None): 
 78          assert position is None or item is not None 
 79          if item: item = item._get_uriref() 
 80          if meta: meta = _prepare_meta(meta) 
 81          o = self._owner 
 82          for i in o._backend.iter_lists((o._id,), None, item, position, meta): 
 83              yield o.get_element(i) 
 84   
 85 -    def iter_queries(self): 
 86          o = self._owner 
 87          for i in o._backend.iter_queries((o._id,)): 
 88              yield o.get_element(i) 
 89   
 90 -    def iter_imports(self, url=None, uri=None): 
 91          o = self._owner 
 92          for i in o._backend.iter_imports((o._id,), None, url, uri): 
 93              yield o.get_element(i) 
 94   
 95 -    def count_medias(self): 
 96          o = self._owner 
 97          return o._backend.count_medias((o._id,)) 
 98   
 99 -    def count_annotations(self, media=None, 
100                                  begin=None, begin_min=None, begin_max=None, 
101                                  end=None, end_min=None, end_max=None, 
102                                  at=None): 
103          if hasattr(media, '_get_uriref'): 
104              media = media._get_uriref() 
105          elif media is not None: 
106              # It should be a sequence/iterator of medias 
107              media = (m._get_uriref() for m in media) 
108          if at is not None: 
109              begin_max = end_min = at 
110          o = self._owner 
111          return o._backend.count_annotations((o._id,), None, 
112                                             media, 
113                                             begin, begin_min, begin_max,) 
114   
115 -    def count_relations(self, member=None, position=None): 
116          assert position is None or member is not None 
117          if member: 
118              member = member._get_uriref() 
119          o = self._owner 
120          return o._backend.count_relations((o._id,), None, member, position) 
121   
122 -    def count_views(self): 
123          o = self._owner 
124          return o._backend.count_views((o._id,)) 
125   
126 -    def count_resources(self): 
127          o = self._owner 
128          return o._backend.count_resources((o._id,)) 
129   
130 -    def count_tags(self, meta=None): 
131          o = self._owner 
132          if meta: meta = _prepare_meta(meta) 
133          return o._backend.count_tags((o._id,), None, meta) 
134   
135 -    def count_lists(self, item=None, position=None, meta=None): 
136          assert position is None or item is not None 
137          if item: item = item._get_uriref() 
138          if meta: meta = _prepare_meta(meta) 
139          o = self._owner 
140          return o._backend.count_lists((o._id,), None, item, position, meta) 
141   
142 -    def count_queries(self): 
143          o = self._owner 
144          return o._backend.count_queries((o._id,)) 
145   
146 -    def count_imports(self, url=None, uri=None): 
147          o = self._owner 
148          return o._backend.count_imports((o._id,), url, uri) 
149   
150 -def _prepare_meta(meta): 
151      """ 
152      Convert parameter meta as expected by the backend. 
153   
154      The input is a list of pairs (key, value) where value is either None, a 
155      unicode or an instance of PackageElement. 
156   
157      The outpur is a list of 3-uples as expected by the backend. 
158      """ 
159      assert meta is not None 
160      r = [] 
161      for k,v in meta: 
162          if v is None: 
163              r.append((k, None, None)) 
164          elif hasattr(v, "_get_uriref"): 
165              r.append((k, v._get_uriref(), True)) 
166          else: 
167              r.append((k, unicode(v), False)) 
168      return r 
169  # 
170