Modify srctemplatetab to use new Template data model

svn: r22698

gramps/gen/lib/srctemplate.py

@@ -230,8 +230,7 @@ class SrcTemplate(TableObject):
         self.template_element_list = template_element_list
 
     def add_template_element(self, template_element):
-        if template_element not in self.template_element_list:
+        self.template_element_list.append(template_element)
-            self.template_element_list.append(template_element)
 
     def add_structure_element(self, cite_type, slist):
         self.structure[cite_type] += slist
@@ -553,6 +552,13 @@ class TemplateElement(SecondaryObject):
        Names & SecondAuthorSurname, Given Names'. Like this Gramps can parse the
        name and shorten as needed."
 
+     - citation - True if this element appears in a citation (false for a source
+       element)
+       
+     - short - True if this element is an optional short element
+     
+     - short_alg - algorithm to shorten the field.
+     
      - list of Mappings - there would always be a GEDCOM mapping. Also we would
        expect a CSL mapping
 
@@ -567,12 +573,18 @@ class TemplateElement(SecondaryObject):
             self.display = source.display
             self.hint = source.hint
             self.tooltip = source.tooltip
+            self.citation = source.citation
+            self.short - source.short
+            self.short_alg = source.short_alg
             self.template_mapping_list = source.template_mapping_list
         else:
             self.name = ""
             self.display = ""
             self.hint = ""
             self.tooltip = ""
+            self.citation = False
+            self.short = False
+            self.short_alg = ""
             self.template_mapping_list = []
         
     def serialize(self):
@@ -668,6 +680,42 @@ class TemplateElement(SecondaryObject):
         """
         self.tooltip = tooltip
         
+    def get_citation(self):
+        """
+        Return the citation for the Template element.
+        """
+        return self.citation
+
+    def set_citation(self, citation):
+        """
+        Set the citation for the Template element according to the given argument.
+        """
+        self.citation = citation
+        
+    def get_short(self):
+        """
+        Return the short for the Template element.
+        """
+        return self.short
+
+    def set_short(self, short):
+        """
+        Set the short for the Template element according to the given argument.
+        """
+        self.short = short
+        
+    def get_short_alg(self):
+        """
+        Return the short_alg for the Template element.
+        """
+        return self.short_alg
+
+    def set_short_alg(self, short_alg):
+        """
+        Set the short_alg for the Template element according to the given argument.
+        """
+        self.short_alg = short_alg
+        
     def get_template_mapping_list(self):
         return self.template_mapping_list
     

gramps/gen/lib/srctemplatelist.py

@@ -54,7 +54,6 @@ class Singleton(type):
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:
             cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
-            LOG.debug("**** Singleton metaclass initialised")
         return cls._instances[cls]
 
 class SrcTemplateList(object):

gramps/gui/editors/displaytabs/srctemplatetab.py

@@ -208,6 +208,7 @@ class TemplateFields(object):
         if SrcTemplateList().template_defined(key):
             #a predefined template, 
             template = SrcTemplateList().get_template_from_name(key).get_structure()
+            telist = SrcTemplateList().get_template_from_name(key).get_template_element_list()
         else:
             return
         
@@ -226,24 +227,24 @@ class TemplateFields(object):
         self.btns = []
         row = 1
         # now add new fields
-        fieldsL = []
+        long_source_fields = [x for x in telist
-        for fielddef in template[REF_TYPE_L]:
+                              if not x.get_short() and not x.get_citation()]
-            hint = fielddef[9] or SrcAttributeType.get_default_hint(fielddef[1])
+        short_source_fields = [x for x in telist
-            
+                               if x.get_short() and not x.get_citation()]
-            fieldsL.append(fielddef[1])
+        long_citation_fields = [x for x in telist
-            if self.cite is None:
+                                if not x.get_short() and x.get_citation()]
-                #these are source fields
+        short_citation_fields = [x for x in telist
-                self._add_entry(row, fielddef[1], fielddef[2],
+                                 if x.get_short() and x.get_citation()]
-                    fielddef[9] or SrcAttributeType.get_default_hint(fielddef[1]),
+        
-                    fielddef[10] or SrcAttributeType.get_default_tooltip(fielddef[1]))
-                row += 1
-
-        tempsattrt = SrcAttributeType()
-        # now add optional short citation values
         if self.cite is None:
-            fieldsS = [fielddef for fielddef in template[REF_TYPE_S] 
+            # source long fileds
-                            if fielddef[1] in fieldsL and fielddef[7]==EMPTY]
+            for te in long_source_fields:
-            if fieldsS:
+                self._add_entry(row, te.get_name(), _(te.get_display()),
+                                _(te.get_hint()), _(te.get_tooltip()))
+                row += 1
+            
+            # now add short source fields (if any)
+            if short_source_fields:
                 self.gridfields.insert_row(row)
                 lbl = Gtk.Label('')
                 lbl.set_markup(_("<b>Optional Short Versions:</b>"))
@@ -251,36 +252,33 @@ class TemplateFields(object):
                 self.gridfields.attach(lbl, 0, row-1, 2, 1)
                 self.lbls.append(lbl)
                 row += 1
-            for fielddef in fieldsS:
+                for te in short_source_fields:
-                lblval = fielddef[2]
+                    self._add_entry(row, te.get_name(), _(te.get_display()),
-                if lblval:
+                                    _(te.get_hint()), _(te.get_tooltip()))
-                    lblval = _('%(normal_version_label)s (Short)') % {
+                    row += 1
-                                'normal_version_label': lblval}
+            
-                self._add_entry(row, tempsattrt.short_version(fielddef[1]), lblval)
+            # At source level add a header for the default citation values
+            if (long_citation_fields+short_citation_fields) and \
+                            show_default_cite_fields:
+                self.gridfields.insert_row(row)
+                lbl = Gtk.Label('')
+                lbl.set_markup(_("<b>Optional Default Citation Fields:</b>"))
+                lbl.set_halign(Gtk.Align.START)
+                self.gridfields.attach(lbl, 0, row-1, 2, 1)
+                self.lbls.append(lbl)
                 row += 1
-
+        
-        # now add citation values (optional on source level)
+        # Either show citation fields or at source level the default values
-        fieldsF = [fielddef for fielddef in template[REF_TYPE_F] 
-                                            if fielddef[1] not in fieldsL]
-        if fieldsF and show_default_cite_fields and self.cite is None:
-            self.gridfields.insert_row(row)
-            lbl = Gtk.Label('')
-            lbl.set_markup(_("<b>Optional Default Citation Fields:</b>"))
-            lbl.set_halign(Gtk.Align.START)
-            self.gridfields.attach(lbl, 0, row-1, 2, 1)
-            self.lbls.append(lbl)
-            row += 1
         if show_default_cite_fields or (not self.cite is None):
-            for fielddef in fieldsF:
+            for te in long_citation_fields:
-                self._add_entry(row, fielddef[1], fielddef[2],
+                self._add_entry(row, te.get_name(), _(te.get_display()),
-                        fielddef[9] or SrcAttributeType.get_default_hint(fielddef[1]),
+                                _(te.get_hint()), _(te.get_tooltip()))
-                        fielddef[10] or SrcAttributeType.get_default_tooltip(fielddef[1]))
                 row += 1
-        fieldsS = [fielddef for fielddef in template[REF_TYPE_S] 
+            
-                            if fielddef[1] not in fieldsL and fielddef[7]==EMPTY]
+        # Finally the short citation fields (if any)
         if not self.cite is None:
             #we indicate with a text these are the short versions
-            if fieldsS:
+            if short_citation_fields:
                 self.gridfields.insert_row(row)
                 lbl = Gtk.Label('')
                 lbl.set_markup(_("<b>Optional Short Versions:</b>"))
@@ -289,14 +287,11 @@ class TemplateFields(object):
                 self.lbls.append(lbl)
                 row += 1
         if show_default_cite_fields or (not self.cite is None):
-            for fielddef in fieldsS:
+            for te in short_citation_fields:
-                lblval = fielddef[2]
+                self._add_entry(row, te.get_name(), _(te.get_display()),
-                if lblval:
+                                _(te.get_hint()), _(te.get_tooltip()))
-                    lblval = _('%(normal_version_label)s (Short)') % {
-                                    'normal_version_label': lblval}
-                self._add_entry(row, tempsattrt.short_version(fielddef[1]), lblval)
                 row += 1
-
+        
         self.gridfields.show_all()
 
     def _add_entry(self, row, srcattrtype, alt_label, hint=None, tooltip=None):

gramps/gui/editors/editsource.py

@@ -86,10 +86,8 @@ class EditSource(EditPrimary):
         # FIXME: Is there a cleaner place to initially load the template data?
         global FIRST
         if FIRST:
-            LOG.debug("**** load csv data")
             from gramps.plugins.srctemplates.importcsv import load_srctemplates_data
             load_srctemplates_data()
-            LOG.debug("**** csv data loaded\n\n")
             FIRST = False
         self.srctemp = None
         self.citation = citation

gramps/plugins/srctemplates/importcsv.py

@@ -36,6 +36,7 @@ from __future__ import print_function
 from gramps.gen.const import GRAMPS_LOCALE as glocale
 _ = glocale.translation.gettext
 import csv
+import collections
 
 #-------------------------------------------------------------------------
 #
@@ -79,99 +80,98 @@ TOOLTIPCOL = 17
 UNKNOWN = 'UNKNOWN'
 DESCR = -10
 
-# the GEDCOM type is predefined and always present. Other templates will be
-# loaded via plugins
-TEMPLATES = {
-        'GEDCOM': {
-            REF_TYPE_L: [
-                ('', SrcAttributeType.AUTHOR, _(''), '.', EMPTY, False, False, EMPTY, GED_AUTHOR,
-                None, None),
-                ('', SrcAttributeType.TITLE, _(''), '.', STYLE_QUOTE, False, False, EMPTY, GED_TITLE,
-                None, None),
-                ('', SrcAttributeType.PUB_INFO, _(''), '', EMPTY, False, False, EMPTY, GED_PUBINF,
-                None, None),
-                ],
-            REF_TYPE_F: [
-                ('', SrcAttributeType.AUTHOR, _(''), ',', EMPTY, False, False, EMPTY, EMPTY,
-                None, None),
-                ('', SrcAttributeType.TITLE, _(''), ',', STYLE_QUOTE, False, False, EMPTY, EMPTY,
-                None, None),
-                ('', SrcAttributeType.PUB_INFO, _(''), '.', EMPTY, False, False, EMPTY, EMPTY,
-                None, None),
-                ('', SrcAttributeType.DATE, _(''), ' -', EMPTY, False, False, EMPTY, EMPTY,
-                None, None),
-                ('', SrcAttributeType.PAGE, _('Page(s)'), '.', EMPTY, False, False, EMPTY, EMPTY,
-                None, None),
-                ],
-            REF_TYPE_S: [
-                ('', SrcAttributeType.AUTHOR, _(''), ',', EMPTY, False, False, EMPTY, EMPTY,
-                None, None),
-                ('', SrcAttributeType.DATE, _(''), ' -', EMPTY, False, False, EMPTY, EMPTY,
-                None, None),
-                ('', SrcAttributeType.PAGE, _('Page(s)'), '.', EMPTY, False, False, EMPTY, EMPTY,
-                None, None),
-                ],
-            DESCR: '%(first)s - %(sec)s - %(third)s' % {  'first': _('Basic'), 'sec': _('GEDCOM Style'), 'third': _('')},
-            },
-        UNKNOWN: {
-            REF_TYPE_L: [
-                ],
-            REF_TYPE_F: [
-                ],
-            REF_TYPE_S: [
-                ],
-            DESCR: _("Unrecognized Template. Download it's definition."),
-            },
-        }
 
 def load_srctemplates_data():
     """
     Loads the srctemplates defined, and returns a dict with template data
     """
+    LOG.debug("**** load_srctemplate_data. Starting")
+    load_srctemplate_gedcom()
+    LOG.debug("**** load_srctemplate_data. GEDCOM and UNKNOWN loaded")
+    
+    
     from gramps.gen.plug import BasePluginManager
     bpmgr = BasePluginManager.get_instance()
     pdatas = bpmgr.get_reg_srctemplates()
-    templatemap = {}
     
     for plugin in pdatas:
         mod = bpmgr.load_plugin(plugin)
         if mod:
             csvfilename = mod.csvfile
+            LOG.debug("**** load_srctemplate_data. Loading csv from %s" % csvfilename)
             with open(csvfilename, 'rb') as csvfile:
-                templatemap.update(load_srctemplate_csv(csvfile))
+                load_srctemplate_csv(csvfile)
-    return templatemap
+            LOG.debug("**** load_srctemplate_data. csv data loaded")
 
-def load_srctemplate_csv(csvfile):
+def load_srctemplate_gedcom():
     """
-    Loads a template csvfile, and returns a dict with template data
+    Loads the GEDCOM and UNKNOWN templates which are always pre-defined
-    Note: csvfile could be a list containing strings!
     """
-    LOG.debug("**** importcsv.load_srctemplate_cvs called")
+    TEMPLATES = {
-    first = True
+            'GEDCOM': {
-    TYPE2CITEMAP = {}
+                REF_TYPE_L: [
-    TYPE2TEMPLATEMAP = {}
+                    ('', SrcAttributeType.AUTHOR, _(''), '.', EMPTY, False, False, EMPTY, GED_AUTHOR,
-    tlist = SrcTemplateList()
+                    None, None),
-    CITE_TYPES = {'F': REF_TYPE_F, 'L': REF_TYPE_L, 'S': REF_TYPE_S}
+                    ('', SrcAttributeType.TITLE, _(''), '.', STYLE_QUOTE, False, False, EMPTY, GED_TITLE,
-    GEDCOMFIELDS = {'A': GED_AUTHOR, 'T': GED_TITLE, 
+                    None, None),
-                'P': GED_PUBINF, 'D': GED_DATE}
+                    ('', SrcAttributeType.PUB_INFO, _(''), '', EMPTY, False, False, EMPTY, GED_PUBINF,
-    SHORTERALG = {'LOC': SHORTERALG_LOC, 'YEAR': SHORTERALG_YEAR,
+                    None, None),
-              'ETAL': SHORTERALG_ETAL, 'REV.': SHORTERALG_REVERT_TO_DOT}
+                    ],
-    STYLES = {'Quoted': STYLE_QUOTE, 'Italics': STYLE_EMPH,
+                REF_TYPE_F: [
-          'QuotedCont': STYLE_QUOTECONT, 'Bold': STYLE_BOLD}
+                    ('', SrcAttributeType.AUTHOR, _(''), ',', EMPTY, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ('', SrcAttributeType.TITLE, _(''), ',', STYLE_QUOTE, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ('', SrcAttributeType.PUB_INFO, _(''), '.', EMPTY, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ('', SrcAttributeType.DATE, _(''), ' -', EMPTY, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ('', SrcAttributeType.PAGE, _('Page(s)'), '.', EMPTY, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ],
+                REF_TYPE_S: [
+                    ('', SrcAttributeType.AUTHOR, _(''), ',', EMPTY, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ('', SrcAttributeType.DATE, _(''), ' -', EMPTY, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ('', SrcAttributeType.PAGE, _('Page(s)'), '.', EMPTY, False, False, EMPTY, EMPTY,
+                    None, None),
+                    ],
+                DESCR: '%(first)s - %(sec)s - %(third)s' % {  'first': _('Basic'), 'sec': _('GEDCOM Style'), 'third': _('')},
+                },
+            UNKNOWN: {
+                REF_TYPE_L: [
+                    ],
+                REF_TYPE_F: [
+                    ],
+                REF_TYPE_S: [
+                    ],
+                DESCR: _("Unrecognized Template. Download it's definition."),
+                },
+            }
 
     template = SrcTemplate()
     template.set_name('GEDCOM')
     template.set_descr('%(first)s - %(sec)s - %(third)s' % {  'first': _('Basic'), 'sec': _('GEDCOM Style'), 'third': _('')})
     handle = create_id()
     template.set_handle(handle)
-    TYPE2TEMPLATEMAP['GEDCOM'] = template
     tlist = SrcTemplateList()
     tlist.add_template(handle, template)
 
     for (cite_type, slist) in TEMPLATES['GEDCOM'].iteritems():
         if cite_type != DESCR:
             for struct in slist:
-                LOG.debug(struct)
+                if cite_type == REF_TYPE_L or cite_type == REF_TYPE_F:
+                    elem = [x for x in template.get_template_element_list()
+                                if x.get_name()==struct[1] and x.get_short()==False]
+                    if elem:
+                        te = elem[0]
+                    else:
+                        te = TemplateElement()
+                        template.add_template_element(te)
+                elif cite_type == REF_TYPE_S:
+                    te = TemplateElement()
+                    template.add_template_element(te)
                 ldel = struct[0]
                 field_type = struct[1]
                 field_label = struct[2]
@@ -183,28 +183,62 @@ def load_srctemplate_csv(csvfile):
                 gedcommap = struct[8]
                 hint = struct[9]
                 tooltip = struct[10]
-                te = TemplateElement()
                 te.set_name(field_type)
                 te.set_display(field_label)
                 te.set_hint(hint or SrcAttributeType.get_default_hint(field_type))
                 te.set_tooltip(tooltip or SrcAttributeType.get_default_tooltip(field_type))
-                template.add_template_element(te)
+                if cite_type == REF_TYPE_S:
+                    te.set_short(True)
+                    te.set_name(int(SrcAttributeType().short_version(te.get_name())))
+                if field_type == SrcAttributeType.PAGE or \
+                   field_type == SrcAttributeType.DATE:
+                    te.set_citation(True)
                 template.add_structure_element(cite_type, [(ldel, field_type, 
                                 field_label, rdel, style, private, optional, 
                                 shorteralg, gedcommap, hint, tooltip)])
 
+    for handle in SrcTemplateList().get_template_list():
+        template = SrcTemplateList().get_template_from_handle(handle)
+        LOG.debug("source_type: %s" % template.get_name())
+        for te in template.get_template_element_list():
+            LOG.debug("    name: %s; display: %s; hint: %s; tooltip: %s; citation %s; "
+                      "short %s; short_alg %s" %
+                      (SrcAttributeType(te.get_name()).xml_str(),
+                       te.get_display(), te.get_hint(),
+                       te.get_tooltip(), te.get_citation(),
+                       te.get_short(), te.get_short_alg()
+                      ))
+
+    # Now load the UNKNOWN template
     template = SrcTemplate()
     template.set_name(UNKNOWN)
     template.set_descr(_("Unrecognized Template. Download it's definition."))
     handle = create_id()
     template.set_handle(handle)
-    TYPE2TEMPLATEMAP[UNKNOWN] = template
     tlist = SrcTemplateList()
     tlist.add_template(handle, template)
     
     for cite_type in (REF_TYPE_F, REF_TYPE_L, REF_TYPE_S):
         template.add_structure_element(cite_type, [])
            
+def load_srctemplate_csv(csvfile):
+    """
+    Loads a template csvfile, and returns a dict with template data
+    Note: csvfile could be a list containing strings!
+    """
+    first = True
+    TYPE2CITEMAP = {}
+    TYPE2TEMPLATEMAP = {}
+    TYPE2FIELDS = collections.defaultdict(lambda: collections.defaultdict(list))
+    tlist = SrcTemplateList()
+    CITE_TYPES = {'F': REF_TYPE_F, 'L': REF_TYPE_L, 'S': REF_TYPE_S}
+    GEDCOMFIELDS = {'A': GED_AUTHOR, 'T': GED_TITLE, 
+                'P': GED_PUBINF, 'D': GED_DATE}
+    SHORTERALG = {'LOC': SHORTERALG_LOC, 'YEAR': SHORTERALG_YEAR,
+              'ETAL': SHORTERALG_ETAL, 'REV.': SHORTERALG_REVERT_TO_DOT}
+    STYLES = {'Quoted': STYLE_QUOTE, 'Italics': STYLE_EMPH,
+          'QuotedCont': STYLE_QUOTECONT, 'Bold': STYLE_BOLD}
+    
     reader = csv.reader(csvfile, delimiter=';')
     
     prevtempl = ''
@@ -286,13 +320,6 @@ def load_srctemplate_csv(csvfile):
         shorteralg = SHORTERALG.get(row[SHORTERCOL].strip()) or EMPTY
         gedcommap = GEDCOMFIELDS.get(row[GEDCOMCOL].strip()) or EMPTY
         style = STYLES.get(row[STYLECOL].strip()) or EMPTY
-        hint = row[HINTCOL]
-        tooltip = row[TOOLTIPCOL]
-        te = TemplateElement()
-        te.set_name(field_type)
-        te.set_display(_(field_label))
-        te.set_hint(_(hint) or SrcAttributeType.get_default_hint(field_type))
-        te.set_tooltip(_(tooltip) or SrcAttributeType.get_default_tooltip(field_type))
 
         if source_type in TYPE2TEMPLATEMAP:
             template = TYPE2TEMPLATEMAP[source_type]
@@ -302,13 +329,73 @@ def load_srctemplate_csv(csvfile):
             template.set_handle(handle)
             TYPE2TEMPLATEMAP[source_type] = template
             tlist.add_template(handle, template)
-        # FIXME: If the template element is already present, don't add it again
+        
-        template.add_template_element(te)
+        if cite_type == REF_TYPE_L or REF_TYPE_F:
+            elem = [x for x in template.get_template_element_list()
+                        if x.get_name()==field_type and x.get_short()==False]
+            if elem:
+                te = elem[0]
+            else:
+                te = TemplateElement()
+                template.add_template_element(te)
+            hint = row[HINTCOL]
+            tooltip = row[TOOLTIPCOL]
+            te.set_name(field_type)
+            te.set_display(field_label)
+            te.set_hint(hint or te.get_hint())
+            te.set_tooltip(tooltip or te.get_tooltip())
+            te.set_short_alg(shorteralg)
+        if cite_type == REF_TYPE_S:
+            te = TemplateElement()
+#            field_type = int(SrcAttributeType().short_version(field_type))
+            te.set_name(field_type)
+            te.set_short_alg(shorteralg)
+            te.set_short(True)
+            lblval = field_label
+            if lblval:
+                te.set_display(_('%(normal_version_label)s (Short)') % {
+                                    'normal_version_label': lblval})
+            template.add_template_element(te)
+        TYPE2FIELDS[source_type][cite_type].append(field_type)
         template.add_structure_element(cite_type, [(row[LDELCOL], field_type, 
                         _(field_label), row[RDELCOL], style, private, optional, 
                         shorteralg, gedcommap, _(hint), _(tooltip))])
         
-    LOG.debug(tlist.get_template_list())
+    # Now we adjust some fields that could not be changed till all the data had
-    for handle in tlist.get_template_list():
+    # been read in
-        LOG.debug(tlist.get_template_from_handle(handle).to_struct())
+    for source_type in TYPE2FIELDS:
-    return TYPE2CITEMAP
+        template = TYPE2TEMPLATEMAP[source_type]
+        LOG.debug("source_type: %s" % source_type)
+        # First we determine which are citation fields
+        cite_fields = [field for field in 
+                            TYPE2FIELDS[source_type][REF_TYPE_F] +
+                            TYPE2FIELDS[source_type][REF_TYPE_S]
+                       if field not in TYPE2FIELDS[source_type][REF_TYPE_L]]
+        for te in template.get_template_element_list():
+            # Set the boolean if this is a citation field
+            if te.get_name() in cite_fields:
+                te.set_citation(True)
+            
+            # Set the hint and tooltip to default if not already set
+            if not te.get_hint():
+                te.set_hint(SrcAttributeType.get_default_hint(te.get_name()))
+            if not te.get_tooltip():
+                te.set_tooltip(SrcAttributeType.get_default_tooltip(te.get_name()))
+            
+            # If this is a short version, set the name accordingly. This could
+            # not be done earlier because we needed to keep the old 'non-short'
+            # name to find which fields belonged to citations as opposed to
+            # sources
+            if te.get_short() == True:
+                te.set_name(int(SrcAttributeType().short_version(te.get_name())))
+            LOG.debug("    name: %s; display: %s; hint: %s; tooltip: %s; "
+                      "citation %s; short %s; short_alg %s" %
+                      (SrcAttributeType(te.get_name()).xml_str(),
+                       te.get_display(), te.get_hint(),
+                       te.get_tooltip(), te.get_citation(),
+                       te.get_short(), te.get_short_alg()
+                      ))
+    
+#    LOG.debug(tlist.get_template_list())
+#    for handle in tlist.get_template_list():
+#        LOG.debug(tlist.get_template_from_handle(handle).to_struct())