franceculture: comparison web/ldt/ldt_utils/projectserializer.py

equal deleted inserted replaced

-:66f6aff5c382
+:c9460033138f
-import lxml.etree
-import uuid
 from datetime import datetime
 from django.utils.datastructures import SortedDict
 from ldt.ldt_utils.models import Content, Project
+import logging
+import lxml.etree
+import uuid
 DATE_FORMATS = ["%d/%m/%Y","%Y-%m-%d"]
 """
 Serialize a project object to a cinelab compatible array
 def __init__(self, project, from_contents=True, from_display=True):
 self.project = project
 self.parsed = False
 self.ldt_doc = None
-self.medias = []
-self.medias_by_id = {}
 self.medias_dict = SortedDict()
-self.annotations = []
-self.annotations_by_annotation_type = {}
 self.annotations_dict = SortedDict()
 self.tags = {}
-self.tags_by_id = {}
+self.tags_dict = SortedDict()
-self.annotation_types = []
-self.annotation_types_by_id = {}
 self.annotation_types_dict = SortedDict()
-self.views = []
+self.views_dict = SortedDict()
-self.lists = []
-self.lists_by_id = {}
 self.lists_dict = SortedDict()
 self.serialize_contents = from_contents
 self.from_display = from_display
+self.display_contents_list = []
+self.display_cuttings_list = []
+self.display_ensemble_list = []
+def __parse_views(self, display_node_list):
+for display_node in display_node_list:
+display_id = display_node.get(u"id", None)
+if not display_id:
+continue
+content_list = []
+cuttings_list = []
+new_display = {
+"id": display_id,
+"contents": content_list,
+"annotation_types": cuttings_list,
+}
+for content_node in display_node.xpath("content"):
+content_id = content_node.get("id")
+if content_id not in content_list:
+content_list.append(content_id)
+if content_id not in self.display_contents_list:
+self.display_contents_list.append(content_id)
+for cutting_node  in content_node.xpath("decoupage"):
+cutting_id = cutting_node.get("id")
+if cutting_id not in cuttings_list:
+cuttings_list.append(cutting_id)
+if cutting_id not in self.display_cuttings_list:
+self.display_cuttings_list.append(cutting_id)
+ensemble_id = cutting_node.get("idens")
+if ensemble_id not in self.display_ensemble_list:
+self.display_ensemble_list.append(ensemble_id)
+self.views_dict[display_id] = new_display
 def __parse_ensemble(self, ensemble_node, content):
 ensemble_id = ensemble_node.attrib[u"id"]
 for decoupage_node in ensemble_node:
 if decoupage_node.tag != "decoupage" :
 continue
 decoupage_id = decoupage_node.attrib[ u"id"]
+if self.from_display and decoupage_id not in self.display_cuttings_list:
+continue
 decoupage_creator = decoupage_node.attrib[u"author"]
 if not decoupage_creator:
 decoupage_creator = "IRI"
 decoupage_contributor = decoupage_creator
 date_str = decoupage_node.get(u"date")
 decoupage_title += txtRes
 decoupage_description = ""
 for txtRes in decoupage_node.xpath("abstract/text()", smart_strings=False):
 decoupage_description += txtRes
 list_items.append({"id-ref":decoupage_id})
 new_annotation_types = {
 "dc:modified":decoupage_modified,
 "dc:title":decoupage_title,
 "dc:description":decoupage_description
 }
-self.annotation_types.append(new_annotation_types)
+self.annotation_types_dict[decoupage_id] = new_annotation_types
-self.annotation_types_by_id[decoupage_id] = new_annotation_types
-annotations_list = []
-self.annotations_by_annotation_type[decoupage_id] = annotations_list
 res = decoupage_node.xpath("elements/element")
 for element_node in res:
 element_id = element_node.attrib[u"id"]
 "dc:modified": tag_date,
 "dc:title":tag_title
 }
 }
 self.tags[tag_title] = new_tag
-self.tags_by_id[tag_id] = new_tag
+self.tags_dict[tag_id] = new_tag
 element_tags.append({"id-ref":tag_id})
 if not element_tags:
 element_tags = None
 "dc:created": decoupage_created,
 "dc:modified": decoupage_modified
 }
 }
-self.annotations.append(new_annotation)
+self.annotations_dict[element_id] = new_annotation
-annotations_list.append(new_annotation)
 if not list_items:
 new_list["items"] = None
-self.lists.append(new_list)
+self.lists_dict[ensemble_id] = new_list
-self.lists_by_id[ensemble_id] = new_list
 def __parse_ldt(self):
 self.ldt_doc = lxml.etree.fromstring(self.project.ldt.encode("utf-8"))
+if self.from_display:
+xpath_str = "/iri/displays/display[position()=1]"
+if isinstance(self.from_display, basestring):
+xpath_str = "/iri/displays/display[@id='%s']" % self.from_display
+logging.debug("xpath_str " + xpath_str)
+self.__parse_views(self.ldt_doc.xpath(xpath_str))
+logging.debug("xpath_str " + repr(self.views_dict))
 res = self.ldt_doc.xpath("/iri/medias/media")
 for mediaNode in res:
 iri_id = mediaNode.attrib[u"id"]
+if self.from_display and iri_id not in self.display_contents_list:
+continue
 content = Content.objects.get(iri_id=iri_id)
 self.__parse_content(content)
 res = self.ldt_doc.xpath("/iri/annotations/content")
 for content_node in res:
 content_id = content_node.attrib[u"id"]
+if self.from_display and content_id not in self.display_contents_list:
+continue
 content = Content.objects.get(iri_id=content_id)
 for ensemble_node in content_node:
 if ensemble_node.tag != "ensemble" :
 continue
+ensemble_id = ensemble_node.get("id")
+if self.from_display and ensemble_id not in self.display_ensemble_list:
+continue
 self.__parse_ensemble(ensemble_node, content)
-if self.from_display :
-annotations = []
-annotation_types = []
-ensembles = []
-medias = []
-tags = []
-xpath_str = "/iri/displays/display[position()=1]/content"
-if isinstance(self.from_display, basestring):
-xpath_str = "/iri/displays/display[id='%s']/content" % self.from_display
-for content_node in self.ldt_doc.xpath(xpath_str):
-content_id = content_node.get("id")
-if content_id not in medias:
-medias.append(content_id)
-for node in content_node.xpath("decoupage"):
-annotation_type_id = node.get('id')
-ensemble_id = node.get('idens')
-if annotation_type_id in self.annotations_by_annotation_type:
-annot_list = self.annotations_by_annotation_type[annotation_type_id]
-annotations.extend(annot_list)
-for annot in annot_list:
-if annot['tags']:
-for tag in annot['tags']:
-tag_id = tag['id-ref']
-if tag_id not in tags:
-tags.append(tag_id)
-if annotation_type_id not in annotation_types:
-annotation_types.append(annotation_type_id)
-if ensemble_id not in ensembles:
-ensembles.append(ensemble_id)
-self.annotations = annotations
-self.annotation_types = map(lambda id: self.annotation_types_by_id[id], annotation_types)
-self.lists = map(lambda id: self.lists_by_id[id], ensembles)
-self.medias = map(lambda id: self.medias_by_id[id], medias)
-self.tags = {}
-for tag_id in tags:
-tag_inst = self.tags_by_id[tag_id]
-self.tags[tag_inst['meta']['dc:title']] = tag_inst
 self.parsed = True
 def __parse_content(self, content):
 "value": content.videopath.rstrip('/') + "/"
 },
 }
 }
-self.medias.append(new_media)
-self.medias_by_id[content.iri_id] = new_media
 self.medias_dict[content.iri_id] = new_media
 if self.serialize_contents:
 res = doc.xpath("/iri/body/ensembles/ensemble")
 for ensemble_node in res:
 res = {}
 if not self.parsed:
 self.__parse_ldt()
 project_main_media = ""
-if len(self.medias) > 0:
+if len(self.medias_dict) > 0:
-project_main_media = self.medias[0]["id"]
+project_main_media = self.medias_dict.value_for_index(0)["id"]
 res['meta'] = {
 'id': self.project.ldt_id,
 'dc:created':self.project.creation_date.isoformat(),
 'dc:modified':self.project.modification_date.isoformat(),
 'dc:creator':self.project.created_by,
 'dc:title':self.project.title,
 'dc:description':self.project.get_description(self.ldt_doc), # get from doc, parse ldt
 'main_media': {"id-ref":project_main_media}
 }
-if not self.medias:
-self.medias = None
+res['medias'] =  self.medias_dict.values() if len(self.medias_dict) > 0 else None
+res['annotation-types'] = self.annotation_types_dict.values() if len(self.annotation_types_dict) > 0 else None
-if not self.annotation_types:
+res['annotations'] = self.annotations_dict.values() if len(self.annotations_dict) > 0 else None
-self.annotation_types = None
+res['lists'] = self.lists_dict.values() if len(self.lists_dict) > 0 else None
+res['tags'] = self.tags.values() if len(self.tags) > 0 else None
-if len(self.tags) == 0:
+res['views'] = self.views_dict.values() if len(self.views_dict) > 0 else None
-tags = None
-else:
-tags = self.tags.values()
-if not self.lists:
-self.lists = None
-if not self.views:
-self.views = None
-if not self.annotations:
-self.annotations = None
-res['medias'] =  self.medias
-res['annotation-types'] = self.annotation_types
-res['annotations'] = self.annotations
-res['lists'] = self.lists
-res['tags'] = tags
-res['views'] = self.views # ignored for the moment
 return res
 def getAnnotations(self, first_cutting=True):
 if not self.parsed:
 annotations = []
 current_cutting = None
 uri = None
-for annot in self.annotations:
+for annot in self.annotations_dict.values():
 if first_cutting and current_cutting and current_cuttings != annot['meta']['id-ref'] :
 break
 current_cuttings = annot['meta']['id-ref']
 content_id = annot['media']
 content = Content.objects.get(iri_id=content_id)
 if annot['tags']:
-tags_list = map(lambda tag_entry: self.tags_by_id[tag_entry['id-ref']]['meta']['dc:title'],annot['tags'])
+tags_list = map(lambda tag_entry: self.tags_dict[tag_entry['id-ref']]['meta']['dc:title'],annot['tags'])
 else:
 tags_list = []
 begin = int(annot['begin'])
 duration = int(annot['end'])-begin
 if content.media_obj and content.media_obj.external_publication_url:

changeset 98	c9460033138f
parent 97	66f6aff5c382
child 99	0fb4b009c6eb