A class with a function pointer instead of a generator

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.

chapters:
- ConfigurationAndOperation:
        sections:
            - StartupParameters:
                subsections:
                    - GeneralSettings:
                        subsubsections:
                            - 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]]
                else:
                    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))
        else:
            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")
TREST.BuildTexSkeletons()

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.