def emit_class(self, ctx):
        """Emits code corresponding to a python class.

        :param ctx: Generation context information.
        :type ctx: pyesdoc_mp.generators.generator.GeneratorContext

        """
        # Set helper vars.
        class_imports = self.emit_class_imports(ctx, ctx.cls.imports)
        class_circular_imports = self.emit_class_imports(ctx, ctx.cls.circular_imports)
        class_properties = self.emit_class_properties(ctx)
        class_property_constants = self.emit_class_property_constants(ctx)
        class_representations = self.emit_class_representations(ctx)

        # Open template.
        if ctx.cls.is_abstract:
            code = get_template(ctx, _TEMPLATE_CLASS_ABSTRACT)
        else:
            code = get_template(ctx, _TEMPLATE_CLASS_CONCRETE)

        # Generate code.        
        code = code.replace('{package-name}', get_package_name(ctx.pkg))
        code = code.replace('{class-name}', get_class_name(ctx.cls))
        code = code.replace('{base-class-name}', get_class_base_name(ctx.cls.base))
        code = code.replace('{class-doc-string}', ctx.cls.doc_string)
        code = code.replace('{class_constants}', class_property_constants)
        code = code.replace('{class-imports}', class_imports)
        code = code.replace('{class-circular-imports}', class_circular_imports)
        code = code.replace('{class-properties}', class_properties)
        code = code.replace('{class-representations}', class_representations)

        return code
        def get_imports():
            imports = []

            def append_import(imp):
                if imp not in imports:
                    imports.append(imp)

            # Set package class type imports.
            imp = 'from py{0}.v{1}.types.{2} import *'.format(
                get_ontology_name(ctx.ontology),
                get_ontology_version(ctx.ontology),
                get_package_name(ctx.pkg))
            append_import(imp)

            # Set type decoding imports.
            for type in [t for t in ctx.pkg.external_types if t.is_class]:
                imp = 'from py{0}.v{1}.validation.{2} import *'.format(
                    get_ontology_name(ctx.ontology),
                    get_ontology_version(ctx.ontology),
                    get_package_module_name(type.name_of_package, 'validator'))
                append_import(imp)

            if len(imports) > 0:
                return reduce(add, map(lambda i : i + emit_line_return(), sorted(imports)))
            else:
                return ''
    def on_package_parse(self, ctx):
        """Event handler for the package parse event.

        :param ctx: Generation context information.
        :type ctx: pyesdoc_mp.generators.generator.GeneratorContext

        """
        def get_imports():
            imports = []

            def append_import(imp):
                if imp not in imports:
                    imports.append(imp)

            # Set package class type imports.
            imp = 'from py{0}.v{1}.types.{2} import *'.format(
                get_ontology_name(ctx.ontology),
                get_ontology_version(ctx.ontology),
                get_package_name(ctx.pkg))
            append_import(imp)

            # Set type decoding imports.
            for type in [t for t in ctx.pkg.external_types if t.is_class]:
                imp = 'from py{0}.v{1}.validation.{2} import *'.format(
                    get_ontology_name(ctx.ontology),
                    get_ontology_version(ctx.ontology),
                    get_package_module_name(type.name_of_package, 'validator'))
                append_import(imp)

            if len(imports) > 0:
                return reduce(add, map(lambda i : i + emit_line_return(), sorted(imports)))
            else:
                return ''


        def get_functions():
            fns = ''
            for cls in ctx.pkg.classes:
                fn = get_template(ctx, _TEMPLATE_VALIDATOR_FUNCTION)
                fn = fn.replace('{class-name}', get_class_name(cls))
                fn = fn.replace('{class-function-name}', get_class_functional_name(cls))
                fn = fn.replace('{class-doc-name}', get_class_doc_string_name(cls))
                fn += emit_line_return(3)
                fns += fn
            return fns
        

        code = get_template(ctx, _TEMPLATE_VALIDATOR_MODULE)
        code = code.replace('{module-imports}', get_imports())
        code = code.replace('{validation-functions}', get_functions())
        code = code.replace('{package-name}', get_package_name(ctx.pkg))
        dir = self.output_dir
        file = get_package_module_file_name(ctx.pkg, 'validator')

        return (code, dir, file)
    def emit_package_init_file(self, ctx, template, package_imports_fn):
        """Emits a package initialisation file.

        :param ctx: Generation context information.
        :param template: Code template.
        :param package_imports_fn: Package imports generator callback.
        :type ctx: pyesdoc_mp.generators.generator.GeneratorContext
        :type template: str
        :type package_imports_fn: function

        """
        code = get_template(ctx, template)

        if ctx.pkg is not None:
            code = code.replace('{package-name}', get_package_name(ctx.pkg))
        code = code.replace('{module-imports}', package_imports_fn())

        return code
    def emit_imports_for_sub_package(self, ctx, pkg=None):
        """Emits code corresponding to a set of sub package imports.

        :param ctx: Generation context information.
        :type ctx: pyesdoc_mp.generators.generator.GeneratorContext

        """
        code = ''

        pkg = pkg if pkg is not None else ctx.pkg
        for cls in pkg.classes:
            code += 'from py{0}.v{1}.types.{2}.{3} import {4}{5}'.format(
                get_ontology_name(ctx.ontology),
                get_ontology_version(ctx.ontology),
                get_package_name(pkg),
                get_class_import_name(cls),
                get_class_name(cls),
                emit_line_return())
                
        return code