def tohtml(self):
     # TODO temporary
     path = os.path.join(os.path.dirname(__file__), 'reader.html.template')
     loader = DictLoader({'reader': open(path).read()})
     engine = Engine(loader=loader, extensions=[CoreExtension()])
     template = engine.get_template('reader')
     return template.render({'feed': self}).encode('utf-8')

    def tohtml(self):
        if DictLoader is None:
            raise ImportError('dep wheezy.template needed')

        loader = DictLoader({'reader': open('reader.html.template').read()})
        engine = Engine(loader=loader, extensions=[CoreExtension()])
        template = engine.get_template('reader')
        return template.render({'feed': self}).encode('utf-8')

    def render(self, result):
        """Take the function return value and renders a html document."""
        templateFile = result["templatePath"]
        context = result["context"]

        searchPath = [""]
        engine = Engine(loader=FileLoader(searchPath), extensions=[CoreExtension(), CodeExtension()])
        template = engine.get_template(templateFile)
        return template.render(context)

 def render(self, source, ctx=None):
     from wheezy.template.engine import Engine
     from wheezy.template.ext.core import CoreExtension
     from wheezy.template.loader import DictLoader
     loader = DictLoader({'test.html': source})
     engine = Engine(
         loader=loader,
         extensions=[CoreExtension()])
     template = engine.get_template('test.html')
     return template.render(ctx or {})

def init_templates():
	""" Initialize all templates.
	"""
	global g_template_dic
	searchpath = ['mportal/templates']
	engine = Engine(loader=FileLoader(searchpath),extensions=[CoreExtension()])
	
	g_template_dic['login'] = engine.get_template('login.html')
	g_template_dic['console'] = engine.get_template('console.html')
	g_template_dic['not_found'] = engine.get_template('not_found.html')
	g_template_dic['redirect'] = engine.get_template('redirect.html')

	def to_autopkg(self, outfile):		
		searchpath = [os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')]
		engine = Engine(
			loader=FileLoader(searchpath),
			extensions=[CoreExtension()]
		)
		template = engine.get_template('redist-packages.autopkg')
		autopkg = template.render({'package': self})
		
		with open(outfile, 'w') as f:
			f.write(autopkg)
		
		return autopkg

    def get(self):
        fortunes = db_session.query(Fortune).all()
        fortunes.append(Fortune(id=0, message="Additional fortune added at request time."))
        fortunes.sort(key=attrgetter("message"))
        engine = Engine(loader=FileLoader(["views"]), extensions=[CoreExtension()])
        template = engine.get_template("fortune.html")
        for f in fortunes:
            f.message = bleach.clean(f.message)
        template_html = template.render({"fortunes": fortunes})		

        response = HTTPResponse()
        response.write(template_html)
        return response

def main(args=None):
    if not json:  # pragma: nocover
        print('error: json module is not available')
        return 1
    args = parse_args(args or sys.argv[1:])
    if not args:
        return 2
    ts = args.token_start
    extensions = [CoreExtension(ts), CodeExtension(ts)]
    extensions.extend(args.extensions)
    engine = Engine(FileLoader(args.searchpath), extensions)
    engine.global_vars.update({'h': escape})
    t = engine.get_template(args.template)
    sys.stdout.write(t.render(load_context(args.context)))
    return 0

def generate_source(options, version, enums, functions_by_category, passthru, extensions, types, raw_enums):
    template_pattern = re.compile("(.*).template")

    # Sort by categories and sort the functions inside the categories
    functions_by_category = sorted(functions_by_category
                                  ,key=lambda x: x[0])
    functions_by_category = list(map(lambda c: (c[0], sorted(c[1], key=lambda x: x.name))
                                ,functions_by_category))

    template_namespace = {'passthru'  : passthru,
                          'functions' : functions_by_category,
                          'enums'     : enums,
                          'options'   : options,
                          'version'   : version,
                          'extensions': extensions,
                          'types': types,
                          'raw_enums': raw_enums}
    if not os.path.isdir(options.template_dir):
        print ('%s is not a directory' % options.template_dir)
        exit(1)

    if os.path.exists(options.outdir) and not os.path.isdir(options.outdir):
        print ('%s is not a directory' % options.outdir)
        exit(1)

    if not os.path.exists(options.outdir):
        os.mkdir(options.outdir)

    engine = Engine(loader=FileLoader([options.template_dir]),extensions=[CoreExtension(),CodeExtension()])

    generatedFiles = 0
    allFiles       = 0;

    for template_path in glob('%s/*.template' % os.path.abspath(options.template_dir)):

        infile = os.path.basename(template_path)
        outfile = '%s/%s' % (options.outdir, template_pattern.match(infile).group(1))

        template = engine.get_template(infile)

        allFiles += 1

        with open(outfile, 'w') as out:
            out.write(template.render(template_namespace))
            print("Successfully generated %s" % outfile)
            generatedFiles += 1;

    print("Generated %d of %d files" % (generatedFiles, allFiles))

    def __init__(self, path):
        self.path = path

        template_dct = {
            'docker': templates.docker,
        }
        engine = Engine(
            loader=DictLoader(template_dct),
            extensions=[
                CoreExtension(),
                CodeExtension()
            ]
        )
        self.templates = {
            name: engine.get_template(name) for name in template_dct
        }

 def setUp(self):
     from wheezy.template.engine import Engine
     from wheezy.template.ext.core import CoreExtension
     from wheezy.template.loader import DictLoader
     self.templates = {}
     self.engine = Engine(
         loader=DictLoader(templates=self.templates),
         extensions=[CoreExtension()])

def generate_source(options, version, enums, functions_by_category, passthru, extensions):
    generated_warning = '/* WARNING: This file was automatically generated */\n/* Do not edit. */\n'
    template_pattern = re.compile("(.*).template")

    template_namespace = {'passthru'  : passthru,
                          'functions' : functions_by_category,
                          'enums'     : enums,
                          'options'   : options,
                          'version'   : version,
                          'extensions': extensions}
    if not os.path.isdir(options.template_dir):
        print ('%s is not a directory' % options.template_dir)
        exit(1)

    if os.path.exists(options.outdir) and not os.path.isdir(options.outdir):
        print ('%s is not a directory' % options.outdir)
        exit(1)

    if not os.path.exists(options.outdir):
        os.mkdir(options.outdir)

    engine = Engine(loader=FileLoader([options.template_dir]), extensions=[CoreExtension()])
    
    generatedFiles = 0
    allFiles       = 0;

    for template_path in glob('%s/*.template' % os.path.abspath(options.template_dir)):

        infile = os.path.basename(template_path)
        outfile = '%s/%s' % (options.outdir, template_pattern.match(infile).group(1))

        template = engine.get_template(infile)

        allFiles += 1

        with open(outfile, 'w') as out:
            out.write(generated_warning)
            out.write(template.render(template_namespace))
            print("Successfully generated %s" % outfile)
            generatedFiles += 1;

    print("Generated %d of %d files" % (generatedFiles, allFiles))

def render(outname, templatename, newcontext=None):
  engine = Engine(
    loader=FileLoader(['templates'], 'UTF-8'),
    extensions=[CoreExtension()]
  )
  template = engine.get_template(templatename)
  context = {
    'title': WLOG_TITLE,
    'wlog_url': WLOG_URL,
    'site_url': SITE_URL,
    'version': VERSION,
    'categories': MAIN_CATEGORIES,
  }
  if newcontext:
    context.update(newcontext)
  
  output = template.render(context)
  
  with open("output/{}.html".format(outname), 'w') as f:
    f.write(output.encode('utf-8'))

class EngineTestCase(unittest.TestCase):
    """ Test the ``Engine``.
    """

    def setUp(self):
        from wheezy.template.engine import Engine
        from wheezy.template.loader import DictLoader
        self.engine = Engine(
            loader=DictLoader(templates={}),
            extensions=[])

    def test_template_not_found(self):
        """ Raises IOError.
        """
        self.assertRaises(IOError, lambda: self.engine.get_template('x'))

    def test_import_not_found(self):
        """ Raises IOError.
        """
        self.assertRaises(IOError, lambda: self.engine.import_name('x'))

    def test_remove_unknown_name(self):
        """ Invalidate name that is not known to engine.
        """
        self.engine.remove('x')

    def test_remove_name(self):
        """ Invalidate name that is known to engine.
        """
        self.engine.templates['x'] = 'x'
        self.engine.renders['x'] = 'x'
        self.engine.modules['x'] = 'x'
        self.engine.remove('x')

    def generate_html(self, filename, template_file="Default.html"):
        
        engine = Engine(
            loader=FileLoader(['templates']),
            extensions=[CoreExtension()]
            )
        
        template = engine.get_template(template_file)
        
        try:
            file = open(filename, "w")
            try:

                clients_list_descendant = list(reversed(sorted(self.clients_hours.items(), key=lambda x: x[1])))
                file.write(template.render({'clients_hours':clients_list_descendant,
                                            'total_hours':str(self.total_hours_booked),
                                            'unbooked_timeranges':self.get_unbooked_hours(),
                                            'total_hours_unbooked': self.total_hours_unbooked}))
            finally:
                file.close()
        except IOError:
            pass

    def __init__(self, searchpath):
        Formatter.__init__(self)

        self._symbol_formatters = {
            FunctionSymbol: self._format_function,
            FunctionMacroSymbol: self._format_function_macro,
            CallbackSymbol: self._format_callback,
            ConstantSymbol: self._format_constant,
            ExportedVariableSymbol: self._format_constant,
            AliasSymbol: self._format_alias,
            StructSymbol: self._format_struct,
            EnumSymbol: self._format_enum,
            ParameterSymbol: self._format_parameter_symbol,
            ReturnItemSymbol: self._format_return_item_symbol,
            FieldSymbol: self._format_field_symbol,
            SignalSymbol: self._format_signal_symbol,
            VFunctionSymbol: self._format_vfunction_symbol,
            PropertySymbol: self._format_property_symbol,
            ClassSymbol: self._format_class_symbol,
            InterfaceSymbol: self._format_interface_symbol,
        }

        self._ordering = [InterfaceSymbol, ClassSymbol, FunctionSymbol,
                          FunctionMacroSymbol, SignalSymbol,
                          PropertySymbol, StructSymbol,
                          VFunctionSymbol, EnumSymbol, ConstantSymbol,
                          ExportedVariableSymbol, AliasSymbol, CallbackSymbol]

        if HtmlFormatter.theme_path:
            theme_templates_path = os.path.join(
                HtmlFormatter.theme_path, 'templates')

            if os.path.exists(theme_templates_path):
                searchpath.insert(0, theme_templates_path)

        searchpath.append(os.path.join(HERE, "html_templates"))
        self.engine = Engine(
            loader=FileLoader(searchpath, encoding='UTF-8'),
            extensions=[CoreExtension(), CodeExtension()]
        )

        self.all_scripts = set()
        self.all_stylesheets = set()
        self._docstring_formatter = GtkDocStringFormatter()

class TemplateTestCase(unittest.TestCase):
    """ Test the ``CodeExtension`` compiled templates.
    """

    def setUp(self):
        from wheezy.template.engine import Engine
        from wheezy.template.ext.code import CodeExtension
        from wheezy.template.ext.core import CoreExtension
        from wheezy.template.loader import DictLoader
        self.templates = {}
        self.engine = Engine(
            loader=DictLoader(templates=self.templates),
            extensions=[CoreExtension(), CodeExtension()])

    def render(self, source):
        self.templates['test.html'] = source
        template = self.engine.get_template('test.html')
        return template.render({})

    def test_code_single_line(self):
        assert '1' == self.render('@(i = 1)@i!s')

    def test_code_continue_newline(self):
        assert '1' == self.render('@(i = 1)\\\[email protected]!s')

    def test_code_separated_lines(self):
        assert '\n1' == self.render('@(i = 1)\[email protected]!s')

    def test_code_with_markup1(self):
        assert 'x = 1' == self.render('[email protected](i = 1) = @i!s')

    def test_code_with_markup2(self):
        assert 'x = 1' == self.render('x @(i = 1)= @i!s')

    def test_code_multiline(self):
        assert 'x = 1' == self.render("""\
x \
@(
    i = 1
)\
= @i!s""")

    def __init__(self, output_filename, mz_dtype=np.float64, intensity_dtype=np.float32):
        self.mz_dtype = mz_dtype
        self.intensity_dtype = intensity_dtype
        self.run_id = os.path.splitext(output_filename)[0]
        self.filename =  self.run_id + ".imzML"
        self.ibd_filename = self.run_id + ".ibd"
        self.xml = open(self.filename, 'w')
        self.ibd = open(self.ibd_filename, 'w')
        self.sha1 = hashlib.sha1()
        self.ibd_offset = 0
        self.uuid = uuid.uuid4()

        self._write_ibd(self.uuid.bytes_le)

        self.wheezy_engine = Engine(loader=DictLoader({'imzml': IMZML_TEMPLATE}), extensions=[CoreExtension()])
        self.imzml_template = self.wheezy_engine.get_template('imzml')

        self.spectra = []

        from collections import namedtuple
        self.Spectrum = namedtuple('Spectrum', ['coords', 'mz_len', 'mz_offset', 'mz_enc_len', 'int_len', 'int_offset', 'int_enc_len'])

    def __init__(self, searchpath):
        Formatter.__init__(self)
        self._symbol_formatters = {
                FunctionSymbol: self._format_function,
                FunctionMacroSymbol: self._format_function_macro,
                CallbackSymbol: self._format_callback,
                ConstantSymbol: self._format_constant,
                ExportedVariableSymbol: self._format_constant,
                AliasSymbol: self._format_alias,
                StructSymbol: self._format_struct,
                EnumSymbol: self._format_enum,
                ClassSymbol: self._format_class,
                SectionSymbol: self._format_class,
                ParameterSymbol: self._format_parameter_symbol,
                ReturnValueSymbol : self._format_return_value_symbol,
                FieldSymbol: self._format_field_symbol,
                }

        self._summary_formatters = {
                FunctionSymbol: self._format_function_summary,
                FunctionMacroSymbol: self._format_function_macro_summary,
                CallbackSymbol: self._format_callback_summary,
                ConstantSymbol: self._format_constant_summary,
                ExportedVariableSymbol: self._format_exported_variable_summary,
                AliasSymbol: self._format_alias_summary,
                StructSymbol: self._format_struct_summary,
                EnumSymbol: self._format_enum_summary,
                }

        self._ordering = [FunctionSymbol, FunctionMacroSymbol,
                StructSymbol, EnumSymbol, ConstantSymbol, ExportedVariableSymbol,
                AliasSymbol, CallbackSymbol]

        module_path = os.path.dirname(__file__)
        searchpath.append (os.path.join(module_path, "templates"))
        self.engine = Engine(
            loader=FileLoader(searchpath, encoding='UTF-8'),
            extensions=[CoreExtension()]
        )

			${PAYPAL}
		''',
	},
	{
		'title': "I have a feature request",
		'body': '''
			<a href="/contact">Contact me</a>
		''',
	},
	{
		'title': "These don't solve my problem",
		'body': '''
			<a href="/contact">Contact me</a>. Please describe your problem in as much detail as possible. The more I know about your issue right off the start, the less questions I have to ask you. Also, please provide information about your phone (model, Android version, etc.).
		''',
	},
]

from wheezy.template.engine import Engine
from wheezy.template.ext.core import CoreExtension
from wheezy.template.loader import FileLoader

searchpath = ['.']
engine = Engine(
    loader=FileLoader(searchpath),
    extensions=[CoreExtension()]
)
template = engine.get_template('template.html')

f = open('prioritysms.html', 'w')
f.write(template.render({'pagetitle': 'Priority SMS Help', 'topics': topics}))
f.close()