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))
