Source Code for Module advene.model.parsers.cinelab_xml

  1  """ 
  2  Cinelab parser implementation. 
  3  """ 
  4  from advene.model.cam.consts import CAM_XML 
  5  import advene.model.serializers.cinelab_xml as serializer 
  6  from advene.model.parsers.advene_xml import Parser as _AdveneXmlParser 
  7   
  8 -class Parser(_AdveneXmlParser): 
  9      NAME = serializer.NAME 
 10      EXTENSION = serializer.EXTENSION 
 11      MIMETYPE = serializer.MIMETYPE 
 12      SERIALIZER = serializer # may be None for some parsers 
 13   
 14      # this implementation tries to maximize the reusing of code from  
 15      # _AdveneXmlParser. It does so by "luring" it into using some methods 
 16      # of self.package instead of others. This is a bit of a hack, but works 
 17      # well... It assumes, however, that the parser is *not* multithreaded. 
 18   
 19      _NAMESPACE_URI = CAM_XML 
 20   
 21 -    def __init__(self, file_, package): 
 22          _AdveneXmlParser.__init__(self, file_, package) 
 23   
 24 -    def manage_package_subelements(self): 
 25          self.optional_sequence("imports") 
 26          self.optional_sequence("annotation-types") 
 27          self.optional_sequence("relation-types") 
 28          self.optional_sequence("tags") 
 29          self.optional_sequence("medias") 
 30          self.optional_sequence("resources") 
 31          self.optional_sequence("annotations") 
 32          self.optional_sequence("relations") 
 33          self.optional_sequence("views") 
 34          self.optional_sequence("queries", items_name="query") 
 35          self.optional_sequence("schemas") 
 36          self.optional_sequence("lists") 
 37          self.optional_sequence("external-tag-associations", 
 38                                 items_name="association") 
 39   
 40      # luring methods (cf. comment at top of that class) 
 41   
 42 -    def handle_annotation_type(self): 
 43          # lure `_AdveneXmlParser.handle_tag` into using 
 44          # `create_annotation_type` instead of `create_tag` 
 45          # by overridding method at instance level 
 46          self.package.create_tag = self.package.create_annotation_type 
 47          _AdveneXmlParser.handle_tag(self) 
 48          # restore class level method 
 49          del self.package.create_tag 
 50   
 51 -    def handle_relation_type(self): 
 52          # lure `_AdveneXmlParser.handle_tag` into using 
 53          # `create_relation_type` instead of `create_tag` 
 54          # by overridding method at instance level 
 55          self.package.create_tag = self.package.create_relation_type 
 56          _AdveneXmlParser.handle_tag(self) 
 57          # restore class level method 
 58          del self.package.create_tag 
 59   
 60 -    def handle_tag(self, element=None): 
 61          # lure `_AdveneXmlParser.handle_tag` into using 
 62          # `create_user_tag` instead of `create_tag` or 
 63          # `associate_user_tag` instead of `associate_tag` 
 64          # by overridding method at instance level 
 65          if element is None: 
 66              self.package.create_tag = self.package.create_user_tag 
 67          else: 
 68              self.package.associate_tag = self.package.associate_user_tag 
 69          _AdveneXmlParser.handle_tag(self, element) 
 70          # restore class level method 
 71          if element is None: 
 72              del self.package.create_tag 
 73          else: 
 74              del self.package.associate_tag 
 75   
 76 -    def handle_schema(self): 
 77          # lure `_AdveneXmlParser.handle_list` into using 
 78          # `create_schema` instead of `create_list` 
 79          # by overridding method at instance level 
 80          self.package.create_list = self.package.create_schema 
 81          _AdveneXmlParser.handle_list(self) 
 82          # restore class level method 
 83          del self.package.create_list 
 84   
 85 -    def handle_list(self): 
 86          # lure `_AdveneXmlParser.handle_list` into using 
 87          # `create_user_list` instead of `create_list` 
 88          # by overridding method at instance level 
 89          self.package.create_list = self.package.create_user_list 
 90          _AdveneXmlParser.handle_list(self) 
 91          # restore class level method 
 92          del self.package.create_list 
 93   
 94 -    def handle_element(self, advene_tag): 
 95          # lure `_AdveneXmlParser.handle_element` into using 
 96          # `associate_user_tag` instead of `associate_tag` 
 97          # by overridding method at instance level 
 98          self.package.associate_tag = self.package.associate_user_tag 
 99          _AdveneXmlParser.handle_element(self, advene_tag) 
100          # restore class level method 
101          del self.package.associate_tag 
102   
103 -    def handle_association(self): 
104          # lure `_AdveneXmlParser.handle_association` into using 
105          # `associate_user_tag` instead of `associate_tag` 
106          # by overridding method at instance level 
107          self.package.associate_tag = self.package.associate_user_tag 
108          _AdveneXmlParser.handle_association(self) 
109          # restore class level method 
110          del self.package.associate_tag 
111   
112  # 
113