Source Code for Module advene.model.cam.group

  1  from advene.model.cam.consts import CAMSYS_TYPE 
  2  from advene.model.core.element import LIST, TAG, ElementCollection 
  3  from advene.model.core.group import GroupMixin 
  4   
  5  from itertools import chain 
  6   
  7 -class CamGroupMixin(GroupMixin): 
  8 -    def __iter__(self): 
  9          return chain(*( 
 10              self.iter_schemas(), 
 11              self.iter_annotation_types(), 
 12              self.iter_relation_types(), 
 13              self.iter_medias(), 
 14              self.iter_annotations(), 
 15              self.iter_relations(), 
 16              self.iter_user_lists(), 
 17              self.iter_user_tags(), 
 18              self.iter_views(), 
 19              self.iter_queries(), 
 20              self.iter_resources(), 
 21              self.iter_imports(), 
 22          )) 
 23   
 24 -    def iter_user_tags(self): 
 25          for t in self.iter_tags(): 
 26              if t.get_meta(CAMSYS_TYPE, None) is None: 
 27                  yield t 
 28   
 29 -    def iter_annotation_types(self): 
 30          for t in self.iter_tags(): 
 31              if t.get_meta(CAMSYS_TYPE, None) == "annotation-type": 
 32                  yield t 
 33   
 34 -    def iter_relation_types(self): 
 35          for t in self.iter_tags(): 
 36              if t.get_meta(CAMSYS_TYPE, None) == "relation-type": 
 37                  yield t 
 38   
 39 -    def iter_user_lists(self): 
 40          for t in self.iter_lists(): 
 41              if t.get_meta(CAMSYS_TYPE, None) is None: 
 42                  yield t 
 43   
 44 -    def iter_schemas(self): 
 45          for t in self.iter_lists(): 
 46              if t.get_meta(CAMSYS_TYPE, None) == "schema": 
 47                  yield t 
 48   
 49 -    def count_user_tags(self): 
 50          return len(list(self.iter_user_tags())) 
 51   
 52 -    def count_annotation_types(self): 
 53          return len(list(self.iter_annotation_types())) 
 54   
 55 -    def count_relation_types(self): 
 56          return len(list(self.iter_relation_types())) 
 57   
 58 -    def count_user_lists(self): 
 59          return len(list(self.iter_user_lists())) 
 60   
 61 -    def count_schemas(self): 
 62          return len(list(self.iter_schemas())) 
 63   
 64      @property 
 65 -    def user_tags(group): 
 66          class GroupUserTags(ElementCollection): 
 67              __iter__ = group.iter_user_tags 
 68              __len__ = group.count_user_tags 
 69              def __contains__(self, e): 
 70                  return getattr(e, "ADVENE_TYPE", None) == TAG \ 
 71                         and e.get_meta(CAMSYS_TYPE, None) is None \ 
 72                         and e in group 
 73          return GroupUserTags(group.owner) 
 74   
 75      @property 
 76 -    def annotation_types(group): 
 77          class GroupAnnotationTypes(ElementCollection): 
 78              __iter__ = group.iter_annotation_types 
 79              __len__ = group.count_annotation_types 
 80              def __contains__(self, e): 
 81                  return getattr(e, "ADVENE_TYPE", None) == TAG \ 
 82                         and e.get_meta(CAMSYS_TYPE, None) \ 
 83                             == "annotation-type" \ 
 84                         and e in group 
 85          return GroupAnnotationTypes(group.owner) 
 86   
 87      @property 
 88 -    def relation_types(group): 
 89          class GroupRelationTypes(ElementCollection): 
 90              __iter__ = group.iter_relation_types 
 91              __len__ = group.count_relation_types 
 92              def __contains__(self, e): 
 93                  return getattr(e, "ADVENE_TYPE", None) == TAG \ 
 94                         and e.get_meta(CAMSYS_TYPE, None) \ 
 95                             == "relation-type" \ 
 96                         and e in group 
 97          return GroupRelationTypes(group.owner) 
 98   
 99      @property 
100 -    def user_lists(group): 
101          class GroupUserLists(ElementCollection): 
102              __iter__ = group.iter_user_lists 
103              __len__ = group.count_user_lists 
104              def __contains__(self, e): 
105                  return getattr(e, "ADVENE_TYPE", None) == LIST \ 
106                         and e.get_meta(CAMSYS_TYPE, None) is None \ 
107                         and e in group 
108          return GroupUserLists(group.owner) 
109   
110      @property 
111 -    def schemas(group): 
112          class GroupSchemas(ElementCollection): 
113              __iter__ = group.iter_schemas 
114              __len__ = group.count_schemas 
115              def __contains__(self, e): 
116                  return getattr(e, "ADVENE_TYPE", None) == LIST \ 
117                         and e.get_meta(CAMSYS_TYPE, None) == "schema" \ 
118                         and e in group 
119          return GroupSchemas(group.owner) 
120