I am building TiKZ files, one pdf for each image I have. The purpose is to add text to each separately. The images are legion, so I created a script to generate the text files instead of generating each TeX using copy/paste.

So I created a tree mapping the section to the images.


This map is in the form of a YAML file I read using python.

- ConfigurationAndOperation:
            - StartupParameters:
                    - GeneralSettings:
                            - SystemSettings: 
                                images: [90]
                            - FacilitySettings: 
                                images: [93]

And I iterate it and assemble the required information for each part in the following manner:

import ConversionLibrary.ConfigurationHandling as config
import collections

TexNode = collections.namedtuple('TexNode', "level name")
class TexElement(TexNode):
    __slots__ = ()
    def __str__(self):
        return str(self.level)+ " " + str(self.name)

class StubHandler(config.ConfigurationHandler):
    """ Handle the config file that indexes the images

    def __init__(self, config_file, filesystem_hint = None, filesystem_folder = None):
        super(StubHandler, self).__init__(config_file, filesystem_hint, filesystem_folder)
        self.manual_levels = { 1 : 'chapters',
                               2 : 'sections',
                               3 : 'subsections',
                               4 : 'subsubsections',
                               5 : 'paragraphs' }
        self.images = 'images'
        self.elements = list()
        self.image_map = list()

    def BuildTexSkeletons(self):
        self.__iterate_tree(self.config, 1, None);

    def __iterate_tree(self, tree, level = 1, method_delegate = None):
        document_part = self.manual_levels[level]
        if document_part in tree:
            for element in tree[document_part]:
                element_name = element.iterkeys().next()
                element_values = element.itervalues().next()
                self.__process_element_parents(level, element_name)
                self.__process_level(element_name, element_values, level, method_delegate)

    def __process_level(self, current_name, element, level, method_delegate = None):
        if element:
            if self.images in element:
                if method_delegate is None:
                    print [self.elements, element[self.images]]
                    method_delegate([self.elements, element[self.images]])
            if level != 5:
                self.__iterate_tree(element, level+1, method_delegate)

    def __process_element_parents(self, level, current_element):
        if not self.elements:
            self.elements.append(TexElement(level, current_element))
            if level == self.elements[-1].level:
                del self.elements[-1]
            elif level < self.elements[-1].level:
                new_trim = (self.elements[-1].level - level) + 1
                del self.elements[-new_trim:]
            self.elements.append(TexElement(level, current_element))

if __name__ == "__main__":
TREST = StubHandler("SHELL.yml")

As you can see I am using a method delegate, this method delegate gets passed down to the __process_level method.

The line that calls the delegate is:

method_delegate([self.elements, element[self.images]])

This is the thing I will be using to assemble my TeX files.

What I would like to improve

I put a stop to this because I want to keep moving forward. But something is bothering me.

Is there a way to implement this with a generator and that the iteration returns the same [self.elements, element[self.images]]?

I think with a generator it would be cleaner, since I could use the StubHandler in another higher level that has the Output methods.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Browse other questions tagged or ask your own question.