Source Code for Module advene.model.cam.element

  1  from advene.model.consts import DC_NS_PREFIX, RDFS_NS_PREFIX 
  2  from advene.model.cam.consts import CAM_TYPE, CAMSYS_TYPE 
  3  from advene.model.cam.exceptions import SemanticError, UnsafeUseWarning 
  4  import advene.model.cam.util.bookkeeping as bk 
  5  from advene.model.core.content import WithContentMixin 
  6  from advene.model.core.element import PackageElement, ElementCollection 
  7  from advene.model.tales import tales_property, tales_use_as_context 
  8   
  9  from warnings import warn 
 10   
 11 -class CamElementMixin(PackageElement): 
 12      """ 
 13      This mixin class implement the behaviour specific to the Cinelab 
 14      Application Model. 
 15      It must necessarily be mixed in a subclass of PackageElement. To ensure 
 16      correct MRO, it explicitly inherit PackageElement, but it is indeed a mixin 
 17      class (having no implication in instance creation). 
 18      """ 
 19   
 20      @classmethod 
 21 -    def instantiate(cls, *args): 
 22          r = super(CamElementMixin, cls).instantiate(*args) 
 23          r._self_connect("renamed", bk.update_element) 
 24          r._self_connect("deleted", bk.update_owner) 
 25          r._self_connect("modified", bk.update_element) 
 26          r._self_connect("modified-meta", bk.update_element) 
 27          if isinstance(r, WithContentMixin): 
 28              r._self_connect("modified-content-data", bk.update_element) 
 29          return r 
 30   
 31 -    def set_meta(self, key, value, val_is_idref=False): 
 32          if key == CAMSYS_TYPE: 
 33              raise SemanticError("cam:system-type can not be modified") 
 34          return super(CamElementMixin, self).set_meta(key, value, val_is_idref) 
 35   
 36 -    def _set_camsys_type(self, value, val_is_idref=False): 
 37          return super(CamElementMixin, self) \ 
 38                  .set_meta(CAMSYS_TYPE, value, val_is_idref) 
 39   
 40 -    def del_meta(self, key): 
 41          if key == CAMSYS_TYPE: 
 42              raise SemanticError("cam:system-type can not be modified") 
 43          return super(CamElementMixin, self).del_meta(key) 
 44   
 45 -    def iter_my_tags(self, package=None, inherited=True): 
 46          """ 
 47          This method is inherited from core.Package but is unsafe on 
 48          cam.Package. Use instead `iter_my_user_tags`. 
 49          """ 
 50          warn("use iter_my_user_tags instead", UnsafeUseWarning, 2) 
 51          return super(CamElementMixin, self).iter_my_tags(package, inherited) 
 52   
 53 -    def _iter_my_tags_nowarn(self, package=None, inherited=True): 
 54          """ 
 55          Allows to call iter_my_tags internally without raising a warning. 
 56          """ 
 57          return super(CamElementMixin, self).iter_my_tags(package, inherited) 
 58   
 59 -    def iter_my_user_tags(self, package=None, inherited=True): 
 60          for t in super(CamElementMixin, self).iter_my_tags(package, inherited): 
 61              if t.get_meta(CAMSYS_TYPE, None) is None: 
 62                  yield t 
 63   
 64 -    def iter_my_tag_ids(self, package=None, inherited=True): 
 65          """ 
 66          This method is inherited from core.Package but is unsafe on 
 67          cam.Package. Use instead `iter_my_user_tag_ids`. 
 68          """ 
 69          warn("use iter_my_user_tag_ids instead", UnsafeUseWarning, 2) 
 70          return super(CamElementMixin, self).iter_my_tag_ids(package, inherited) 
 71   
 72 -    def _iter_my_tag_ids_nowarn(self, package=None, inherited=True): 
 73          """ 
 74          Allows to call iter_my_tag_ids internally without raising a warning. 
 75          """ 
 76          return super(CamElementMixin, self).iter_my_tag_ids(package, inherited) 
 77   
 78 -    def iter_my_user_tag_ids(self, package=None, inherited=True): 
 79          """ 
 80          FIXME: missing docstring 
 81          """ 
 82          # NB: the following is not general: it assumes that the only 
 83          # non-user tag is the cam:type. 
 84          # It has been chosen because it is very efficient, not requiring to 
 85          # check tags metadata cam:system-type to decide that they are 
 86          # user-tags. 
 87          type = self.get_meta(CAM_TYPE, None) 
 88          all = super(CamElementMixin, self).iter_my_tag_ids(package, inherited) 
 89          if type is None: 
 90              return all 
 91          else: 
 92              type_id = type.make_id_in(package) 
 93              return ( i for i in all if i != type_id ) 
 94   
 95      @tales_property 
 96      @tales_use_as_context("package") 
 97 -    def _tales_my_tags(self, context_package): 
 98          """ 
 99          Iter over all the user-tags of this element in the context of the 
100          reference package. 
101   
102          NB: This TAL function is overridden with a quite different semantics 
103          from the inherited version (only user-tags are iterated, instead of 
104          all tags). Since TAL is mostly user-oriented, this semantic shift is 
105          not considered harmful. 
106          """ 
107          class TagCollection(ElementCollection): 
108              __iter__ = lambda s: self.iter_my_user_tags(context_package) 
109          return TagCollection(self._owner) 
110   
111   
112  _make_meta = CamElementMixin.make_metadata_property 
113   
114  _make_meta(bk.CREATOR, default="") 
115  _make_meta(bk.CONTRIBUTOR, default="") 
116  _make_meta(bk.CREATED, default="") 
117  _make_meta(bk.MODIFIED, default="") 
118   
119  _make_meta(DC_NS_PREFIX + "title", default="") 
120  _make_meta(DC_NS_PREFIX + "description", default="") 
121   
122  _make_meta(RDFS_NS_PREFIX + "seeAlso", default=None) 
123