python类PackageLoader()的实例源码

def __init__(self, loop=None, port=None, db=None):
        """Init AiohttpTarantoolOne with loop, port and db."""
        super().__init__(loop=loop, port=port)
        self.db = db
        self.statistics = {
            "packs_count": "empty",
            "stickers_count": "empty",
            "clicks": "empty",
            "votes": "empty",
            "users": "empty"}
        self.jinja = Environment(
            loader=PackageLoader('aiohttp_server', 'templates'),
            # enable_async=False,
            auto_reload=False)

def run(self):
        env = Environment(loader=PackageLoader('web'))
        t = env.get_template('summary.html')
        title = 'Summary for search "%s"' % self.term
        t.stream(title=title).dump(self.output().fn)

def __init__(self, package, path):
        self.env = Environment(
            loader=PackageLoader(package, path),
            autoescape=select_autoescape(['html'])
        )
        self.env.filters['basename'] = lambda s: os.path.basename(s)
        self.env.filters['media'] = \
            lambda url, ts, *a: shortcuts.reverse_media_url(ts, url, *a)

def export_html(self, include_recibo_sacado=True, static_url=None):
        ''' Gera e retorna o boleto em HTML '''
        env = Environment(loader=PackageLoader('python_boleto', 'templates'))
        env.filters['index_or_blank'] = filters.index_or_blank
        env.filters['format_currency_or_blank'] = filters.format_currency_or_blank
        env.filters['format_date_or_blank'] = filters.format_date_or_blank
        env.filters['format_agencia_conta'] = filters.format_agencia_conta
        template = env.get_template(self._template)

        context_data = self.get_context_data() or {}

        # Monta a URL do logo do banco
        logo_url = self._logo
        if static_url:
            logo_url = urljoin(static_url, self._logo)
        context_data['logo_url'] = logo_url

        # gera o barse64 do logo, se possível
        try:
            logo_img_file = os.path.join(STATIC_DIR, self._logo)
            if os.path.exists(logo_img_file):
                img = open(logo_img_file, "rb")
                context_data['logo_base64'] = base64.b64encode(img.read()).decode('utf-8')
        except:
            logger.exception("Erro ao converter logo em Base64")

        return template.render(boleto=self,
                               include_recibo_sacado=include_recibo_sacado,
                               **context_data)

def rst(self, partial_path, full_path, doclet, use_short_name=False):
        """Return rendered RST about an entity with the given name and doclet."""
        dotted_name = partial_path[-1] if use_short_name else _dotted_path(partial_path)

        # Render to RST using Jinja:
        env = Environment(loader=PackageLoader('sphinx_js', 'templates'))
        template = env.get_template(self._template)
        return template.render(**self._template_vars(dotted_name, full_path, doclet))

def encode(self, api_input, action):
        """Transform input to laposte compatible xml."""
        if not (action in LAPOSTE_ACTIONS):
            raise InvalidApiInput(
                'action %s not in %s' % (action, ', '.join(LAPOSTE_ACTIONS)))

        api = LaposteApi()
        if not api.validate(api_input):
            _logger.warning('Laposte api call exception:')
            raise InvalidApiInput(
                {'api_call_exception': api.errors(api_input)})
        data = api.normalize(api_input)

        data['service']['labelFormat'] = self.lookup_label_format(
            data['service']['labelFormat'])

        env = Environment(
            loader=PackageLoader('roulier', '/carriers/laposte/templates'),
            extensions=['jinja2.ext.with_', 'jinja2.ext.autoescape'],
            autoescape=True)

        template = env.get_template("laposte_%s.xml" % action)
        return {
            "body": template.render(
                service=data['service'],
                parcel=data['parcels'][0],
                auth=data['auth'],
                sender_address=data['from_address'],
                receiver_address=data['to_address'],
                customs=data['customs']),
            "headers": data['auth'],
            "output_format": data['service']['labelFormat']
        }

def soap_wrap(self, body, headers):
        """Wrap body in a soap:Enveloppe."""
        env = Environment(
            loader=PackageLoader('roulier', '/carriers/laposte/templates'),
            extensions=['jinja2.ext.with_'])

        template = env.get_template("laposte_soap.xml")
        body_stripped = remove_empty_tags(body)
        data = template.render(body=body_stripped)
        return data.encode('utf8')

def soap_wrap(self, body, auth):
        """Wrap body in a soap:Enveloppe."""
        env = Environment(
            loader=PackageLoader('roulier', '/carriers/geodis/templates'),
            extensions=['jinja2.ext.with_'])

        template = env.get_template("geodis_soap.xml")
        body_stripped = remove_empty_tags(body)
        header_template = env.get_template("geodis_header.xml")
        header_xml = header_template.render(auth=auth)
        data = template.render(body=body_stripped, header=header_xml)
        return data.encode('utf8')

def encode(self, api_input, action):
        """Transform input to geodis compatible xml."""
        if not (action in GEODIS_ACTIONS):
            raise InvalidApiInput(
                'action %s not in %s' % (action, ', '.join(GEODIS_ACTIONS)))

        api = GeodisApiWs()
        if not api.validate(api_input):
            raise InvalidApiInput(
                'Input error : %s' % api.errors(api_input))
        data = api.normalize(api_input)

        data['service']['labelFormat'] = self.lookup_label_format(
            data['service']['labelFormat'])
        data['service']['shippingDate'] = data['service']['shippingDate'].replace('/','') 
        data['from_address']['departement'] = data['from_address']['zip'][:2]

        is_test = data['service']['is_test']

        env = Environment(
            loader=PackageLoader('roulier', '/carriers/geodis/templates'),
            extensions=['jinja2.ext.with_', 'jinja2.ext.autoescape'],
            autoescape=True)

        template = env.get_template("geodis_%s.xml" % action)
        return {
            "body": template.render(
                service=data['service'],
                parcels=data['parcels'],
                sender_address=data['from_address'],
                receiver_address=data['to_address']),
            "headers": data['auth'],
            "is_test": is_test,
            "output_format": api_input['service']['labelFormat']
        }

def soap_wrap(self, body, auth):
        """Wrap body in a soap:Enveloppe."""
        env = Environment(
            loader=PackageLoader('roulier', '/carriers/dpd/templates'),
            extensions=['jinja2.ext.with_'])

        template = env.get_template("dpd_soap.xml")
        body_stripped = remove_empty_tags(body)
        header_template = env.get_template("dpd_header.xml")
        header_xml = header_template.render(auth=auth)
        data = template.render(body=body_stripped, header=header_xml)
        return data.encode('utf8')

def remove_empty_tags(xml, ouput_as_string=True):
    """Remove empty tags with xslt transformation.

    param: xml a string or a etree type
    return: unicode string or lxml.etree._XSLTResultTree
    """
    # use Jinja env for getting the path of template file
    # pkg_resouces may be an alternative, but we already
    # have Jinja
    env = Environment(
        loader=PackageLoader('roulier', 'templates'),
        extensions=['jinja2.ext.with_'])
    template = env.get_template("remove_empty_tags.xsl")
    xsl = etree.parse(open(template.filename))
    transform = etree.XSLT(xsl)

    if isinstance(xml, basestring):
        xml = etree.fromstring(xml)
    # else we asume xml is an lxml.etree
    if ouput_as_string:
        return unicode(transform(xml))
    else:
        return transform(xml)

def init(loop):
    # setup application and extensions
    app = web.Application(loop=loop)

    setattr(app, "config", configuration)
    # configure jinja 2 rendering engine
    aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader("app", "templates"))
    setup_global_helpers(app)

    await bootstrap_dal(configuration, loop)

    # setup routes
    setup_routes(app, PROJ_ROOT)
    # setup middlewares
    app.middlewares.append(cookies_middleware)
    app.middlewares.append(errors_middleware)

    host, port = configuration.host, configuration.port
    return app, host, port

def _build_env():
    # Ignore bandit false positive: B701:jinja2_autoescape_false
    # This env is not used to render content that is vulnerable to XSS.
    env = jinja2.Environment(  # nosec
        loader=jinja2.PackageLoader('promenade', 'templates/include'),
        undefined=jinja2.StrictUndefined)
    env.filters['b64enc'] = _base64_encode
    env.filters['fill_no_proxy'] = _fill_no_proxy
    env.filters['yaml_safe_dump_all'] = _yaml_safe_dump_all
    return env

def render(template_name, extra_environments=None, **kwargs):
    """??? ???? jinja? ??????

    :param template_name:
    :return:

    """
    if extra_environments is None:
        extra_environments = {}
    default_loader = PackageLoader('dodotable', 'templates')
    loader = extra_environments.get(
        'template_loader',
        default_loader)
    if not loader:
        loader = default_loader
    get_translations = extra_environments.get('get_translations')
    env = Environment(loader=loader,
                      extensions=['jinja2.ext.i18n', 'jinja2.ext.with_'],
                      autoescape=True)
    env.globals.update(extra_environments)
    translations = get_translations() if callable(get_translations) else None
    if translations is None:
        translations = gettext.NullTranslations()
    env.install_gettext_translations(translations)
    template = env.get_template(template_name)
    return template.render(**kwargs)

def __init__(self):
        env = Environment(loader=PackageLoader('example', 'templates'))
        # Cache the template so we don't have to do it again for every item.
        self.template = env.get_template('sitemap_template.html')

        # Directory where result will be stored.
        self.result_dir = os.path.dirname(os.path.abspath(__file__))
        self.result_dir = os.path.join(self.result_dir, RESULT_DIR)
        self.url_count = 0

def run(self, parser, namespace, values, dest, option_string=None):
        """
        Execution of the action.

        :name parser: The argument parser in use.
        :type parser: argparse.ArgumentParser
        :name namespace: The namespace for parsed args.
        :type namespace: argparse.Namespace
        :name values: Values for the action.
        :type values: mixed
        :name option_string: Option string.
        :type option_string: str or None
        :raises: subprocess.CalledProcessError
        """
        hostfs_dirs = []
        add_files = {}
        for item in namespace.add_file:
            local, host = item.split('=')
            hostfs_dirs.append(os.path.dirname(host))
            add_files[local] = host

        output = util.mkdir(namespace.output)
        with open(os.path.sep.join([output, 'Dockerfile']), 'w') as dockerfile:
            loader = jinja2.PackageLoader('system_buildah')
            rendered = loader.load(
                jinja2.Environment(), 'Dockerfile.j2').render(
                    from_base=namespace.from_base, name=values,
                    maintainer=namespace.maintainer,
                    license_name=namespace.license, summary=namespace.summary,
                    version=namespace.version, help_text=namespace.help_text,
                    architecture=namespace.architecture, scope=namespace.scope,
                    add_files=add_files, hostfs_dirs=set(hostfs_dirs))
            dockerfile.write(rendered)

def _render_service_template(self, namespace):
        """
        Renders and returns the service template.

        :name namespace: The namespace for parsed args.
        :type namespace: argparse.Namespace
        :returns: Rendered template
        :rtype: str
        """
        loader = jinja2.PackageLoader('system_buildah')
        return loader.load(
            jinja2.Environment(), 'service.template.j2').render(
                description=namespace.description)

def _render_init_template(self, namespace):
        """
        Renders and returns the init.sh.

        :name namespace: The namespace for parsed args.
        :type namespace: argparse.Namespace
        :returns: Rendered template
        :rtype: str
        """
        loader = jinja2.PackageLoader('system_buildah')
        return loader.load(
            jinja2.Environment(), 'init.sh.j2').render()

def _template_render(self, template, peer):
        ''' Get Data and render the template '''
        env = Environment(loader=PackageLoader('peerme', 'templates'))
        template = env.get_template(template)
        return template.render(
            my_asn=self.opts.config.config['peerme']['my_asn'],
            peer=peer)