def show_template(template, directory): """Show the given raw template.""" if directory != "": loader = ChoiceLoader([FileSystemLoader(directory), PackageLoader("templar")]) else: loader = PackageLoader("templar") print(loader) env = Environment(loader=loader) print(loader.get_source(env, template)[0])
def get_source(self, environment, filename): if ':' in filename: package, filename = filename.split(':', 1) loader = ChoiceLoader([ FileSystemLoader(os.path.join(self.directory, 'packages', package)), PackageLoader(package, '') ]) else: loader = FileSystemLoader(self.directory) return loader.get_source(environment, filename)
def __init__( self, *, openapi: GeneratorData, meta: MetaType, config: Config, custom_template_path: Optional[Path] = None, file_encoding: str = "utf-8", ) -> None: self.openapi: GeneratorData = openapi self.meta: MetaType = meta self.file_encoding = file_encoding package_loader = PackageLoader(__package__) loader: BaseLoader if custom_template_path is not None: loader = ChoiceLoader( [ FileSystemLoader(str(custom_template_path)), package_loader, ] ) else: loader = package_loader self.env: Environment = Environment(loader=loader, trim_blocks=True, lstrip_blocks=True) self.project_name: str = config.project_name_override or f"{utils.kebab_case(openapi.title).lower()}-client" self.project_dir: Path = Path.cwd() if meta != MetaType.NONE: self.project_dir /= self.project_name self.package_name: str = config.package_name_override or self.project_name.replace("-", "_") self.package_dir: Path = self.project_dir / self.package_name self.package_description: str = utils.remove_string_escapes( f"A client library for accessing {self.openapi.title}" ) self.version: str = config.package_version_override or openapi.version self.env.filters.update(TEMPLATE_FILTERS)
def __init__(self, *args, **kwargs): for idx, item in enumerate(('context', 'settings', 'path', 'theme', 'output_path', 'markup')): setattr(self, item, args[idx]) for arg, value in kwargs.items(): setattr(self, arg, value) # templates cache self._templates = {} self._templates_path = [] self._templates_path.append(os.path.expanduser( os.path.join(self.theme, 'templates'))) self._templates_path += self.settings['EXTRA_TEMPLATES_PATHS'] theme_path = os.path.dirname(os.path.abspath(__file__)) simple_loader = FileSystemLoader(os.path.join(theme_path, "themes", "simple", "templates")) self.env = Environment( trim_blocks=True, loader=ChoiceLoader([ FileSystemLoader(self._templates_path), simple_loader, # implicit inheritance PrefixLoader({'!simple': simple_loader}) # explicit one ]), extensions=self.settings['JINJA_EXTENSIONS'], ) logger.debug('template list: {0}'.format(self.env.list_templates())) # provide utils.strftime as a jinja filter self.env.filters.update({'strftime': DateFormatter()}) # get custom Jinja filters from user settings custom_filters = self.settings['JINJA_FILTERS'] self.env.filters.update(custom_filters) signals.generator_init.send(self)
def userModel(request): loader = ChoiceLoader([ FileSystemLoader(settings.TEMPLATE_DIRS), PackageLoader('main_sys', 'templates') ]) env = Environment(loader=loader) template = env.get_template('viewTemplate.html') showfields=["字段1","字段2","字段3"] userService=service.Service() listDto=[{'username':'******',"password":'******','accountMoney':1239.0 }, {'username': '******', "password": '******', 'accountMoney': 1239.0}, {'username': '******', "password": '******', 'accountMoney': 1239.0}] uDto={'id':'6','username':'******',"password":'******','accountMoney':1221.0 } #userService.insetList(listDto) userService.updateById(uDto) allList=userService.findAllDto() print(allList) return HttpResponse( template.render(fields=showfields,values=allList) ) #return render(request, "userModel/userModelManage.html")
def default_jinja_environment(local_search_path=None, owner='totem', repo='fleet-templates', path='templates', ref='master', token=None): """ Creates default jinja environment using FileSystemLoader and GithubTemplateLoader. Basically , it will try to locate the template in local file system first. If not found, it will try to find it in public github repository (https://github.com/totem/fleet-templates). :param local_search_path: Local path for searching the templates :type local_search_path: list or str :return: Jinja Environment :rtype: Environment """ return Environment(loader=ChoiceLoader([ FileSystemLoader(local_search_path or ['./templates']), GithubTemplateLoader( owner=owner, repo=repo, path=path, ref=ref, token=token) ]))
def make_scaling_html(self, scaling_script): """Collect data from the individual observers and write the html.""" html_file = scaling_script.params.output.html json_file = scaling_script.params.output.json if not (html_file or json_file): return self.data.update(ScalingModelObserver().make_plots()) self.data.update(ScalingOutlierObserver().make_plots()) self.data.update(ErrorModelObserver().make_plots()) self.data.update(MergingStatisticsObserver().make_plots()) self.data.update(FilteringObserver().make_plots()) if html_file: logger.info("Writing html report to: %s", html_file) loader = ChoiceLoader( [ PackageLoader("dials", "templates"), PackageLoader("dials", "static", encoding="utf-8"), ] ) env = Environment(loader=loader) template = env.get_template("scaling_report.html") html = template.render( page_title="DIALS scaling report", scaling_model_graphs=self.data["scaling_model"], scaling_tables=self.data["scaling_tables"], resolution_plots=self.data["resolution_plots"], scaling_outlier_graphs=self.data["outlier_plots"], error_model_plots=self.data["error_model_plots"], anom_plots=self.data["anom_plots"], batch_plots=self.data["batch_plots"], misc_plots=self.data["misc_plots"], filter_plots=self.data["filter_plots"], ) with open(html_file, "wb") as f: f.write(html.encode("ascii", "xmlcharrefreplace")) if json_file: logger.info("Writing html report data to: %s", json_file) with open(json_file, "w") as outfile: json.dump(self.data, outfile)
def __init__(self, request, client_address, server, options): if DashBoardHTTPRequestHandler.conf is None: DashBoardHTTPRequestHandler.conf = 1 myself = {'self': FileSystemLoader(os.path.dirname(__file__)) } loader = PrefixLoader(myself) env = Environment(loader=ChoiceLoader([FileSystemLoader([".",'/']), loader])) env.filters.update({'server_to_list': server_to_list}) template = env.get_template(options.input.name) buf = template.render() DashBoardHTTPRequestHandler.conf = yaml.load(buf,Loader=yaml.Loader) # generate ids i = 1 for r in DashBoardHTTPRequestHandler.conf['rows']: for c in r['cells']: c['id'] = str("id%d"%i) i += 1 super().__init__(request, client_address, server)
def initialize(self, argv=None): super().initialize(argv) if self.generate_config: print(self.generate_config_file()) sys.exit(0) if self.config_file: self.load_config_file(self.config_file) # Totally confused by traitlets logging self.log.parent.setLevel(self.log.level) self.init_queue() self.init_ssl_context() base_path = self._template_paths_default()[0] if base_path not in self.template_paths: self.template_paths.append(base_path) loader = ChoiceLoader( [ PrefixLoader({'templates': FileSystemLoader([base_path])}, '/'), FileSystemLoader(self.template_paths), ] ) self.settings = { "static_path": os.path.join(self.data_files_path, "static"), "static_url_prefix": url_path_join(self.service_prefix, "static/") } self.app = web.Application([ (self.service_prefix, AnnouncementViewHandler, dict(queue=self.queue, fixed_message=self.fixed_message, loader=loader), "view"), (self.service_prefix + r"latest", AnnouncementLatestHandler, dict(queue=self.queue, allow_origin=self.allow_origin)), (self.service_prefix + r"update", AnnouncementUpdateHandler, dict(queue=self.queue)), (self.service_prefix + r"static/(.*)", web.StaticFileHandler, dict(path=self.settings["static_path"])), (self.service_prefix + r"logo", LogoHandler, {"path": self.logo_file}) ], **self.settings)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # will look first in 'JINJA2CONTENT_TEMPLATES', by default the # content root path, then in the theme's templates local_dirs = self.settings.get("JINJA2CONTENT_TEMPLATES", ["."]) local_dirs = [ os.path.join(self.settings["PATH"], folder) for folder in local_dirs ] theme_dir = os.path.join(self.settings["THEME"], "templates") loaders = [FileSystemLoader(_dir) for _dir in local_dirs + [theme_dir]] if "JINJA_ENVIRONMENT" in self.settings: # pelican 3.7 jinja_environment = self.settings["JINJA_ENVIRONMENT"] else: jinja_environment = { "trim_blocks": True, "lstrip_blocks": True, "extensions": self.settings["JINJA_EXTENSIONS"], } self.env = Environment(loader=ChoiceLoader(loaders), **jinja_environment)
def load_conf(options): global CONF myself = {'self': FileSystemLoader(os.path.dirname(__file__))} loader = PrefixLoader(myself) env = Environment( loader=ChoiceLoader([FileSystemLoader([".", '/']), loader])) env.filters.update({'server_to_list': server_to_list}) template = env.get_template(options.input.name) buf = template.render() CONF = yaml.load(buf, Loader=yaml.Loader) # generate ids i = 1 for r in CONF['rows']: r['id'] = str("id%d" % i) i += 1 for c in r['cells']: c['id'] = str("id%d" % i) i += 1 logging.debug("CONF: " + str(CONF))