def validate_interfaces(self, callback, user_data):
for intf in user_data['interface_list']:
self.logger.info('Validating interface ({}:{})'
.format(user_data['intf_type'], intf))
invalid_intf = True
user_data['intf'] = intf
cmd = acl_template.get_interface_by_name
t = jinja2.Template(cmd)
config = t.render(**user_data)
config = ' '.join(config.split())
self.logger.debug(config)
rpc_response = callback(config, handler='get')
# xml.etree.ElementTree.dump(rpc_response)
for elem in rpc_response.iter():
if elem.text == intf:
invalid_intf = False
break
if invalid_intf:
raise ValueError("{} interface {} does not exist."
.format(user_data['intf_type'], intf))
python类Template()的实例源码
def __call__(self, environ, start_response):
req = Request(environ, shallow=True)
host = req.headers.get('Host')
if host not in ('metadata.google.internal', '169.254.169.254' , 'metadata'):
status = '403 Forbidden'
response_headers = [('Content-Type','text/html; charset=UTF-8')]
start_response(status, response_headers)
return ['Host Header nust be one of (metadata.google.internal, metadata, 169.254.169.254)']
req_path = environ.get('PATH_INFO')
metadata_flavor = req.headers.get('Metadata-Flavor')
if (metadata_flavor is None and req_path != '/'):
status = '403 Forbidden'
response_headers = [('Content-Type','text/html; charset=UTF-8')]
start_response(status, response_headers)
logging.error("Metadata-Flavor: Google header not sent for: " + environ.get('PATH_INFO'))
t = Template('''<p>Your client does not have permission to get URL
<code>{{ err_path }}</code> from this server. Missing Metadata-Flavor:Google header. ''')
return [str(t.render(err_path= environ.get('PATH_INFO')))]
return self.app(environ, start_response)
# Make sure every response has these headers (which is what gce does)
def html(self):
return Template('''
<div id="{{ css_id }}" class="dyns-page">
<div class="dyns-page-header-container row">
<div class='col-sm-8 page-header-col'>
<h1 class="dyns-page-header">{{ title }}</h1>
</div>
<div class='col-sm-4 page-header-col'>
<div id="export-button-group" class="btn-group dyns-page-header" role="group" style='margin-top:25px; float:right;'>
<button type="button" class="btn btn-default" onClick="/download_page/{{ title }}">PDF</button>
<button type="button" class="btn btn-default">XLSX</button>
<button type="button" class="btn btn-default">CSV</button>
</div>
</div>
</div>
<div class='dyns-page-renderers-container row'>
{% for rndr in renderers %}
{{ rndr.html() }}
{% endfor %}
</div>
</div>
''').render(renderers=self.renderers, css_id=self.css_id, title=self.title)
def _inner_html(self):
tbl_html = self.data.to_html(**self.df_kwargs)
table_class_str = 'table dataframe'
if self.bordered:
table_class_str += ' table-bordered'
if self.striped:
table_class_str += ' table-striped'
if self.hover:
table_class_str += ' table-hover'
if self.condensed:
table_class_str += ' table-condensed'
tbl_html = tbl_html.replace('<table border="1" class="dataframe">',
'<table class="{}">'.format(table_class_str))
return Template('''
<div class="dyns-Table-direct-container">
{{ tbl_html | safe }}
</div>
''').render(title=self.title, tbl_html=tbl_html)
def _inner_html(self):
rndrr_count = len(self.renderers)
if rndrr_count <= 3:
BOOTSTRAP_TOTAL_COLS = 12
col_size = int(BOOTSTRAP_TOTAL_COLS / rndrr_count)
else:
col_size = 'NULL'
return Template('''
<div class='horizontal-group-window'>
{% for rndr in renderers %}
<div class='col-sm-{{ col_size }}' style='display: inline-block;'>
{{ rndr.html() }}
</div>
{% endfor %}
</div>
''').render(renderers=self.renderers, css_id=self.css_id, title=self.title,
col_size=col_size)
def template(self):
html = '''<div class="col-lg-12">
<div class="panel panel-success">
<div class="panel-heading">
<h3 class="panel-title">
{{- name -}}
<span class="pull-right glyphicon glyphicon-thumbs-up"></span>
</h3>
</div>
<div id="logviewer" class="panel-collapse">
<div class="panel-body">
<pre class="prettyprint language-py" style="height: 500px;">
{%- for line in result -%}
{{ line }}<br>
{%- endfor -%}
</pre>
</div>
</div>
</div></div>
'''
t = Template(html)
return t.render(name=self.name, result=self.result, help_url=self.get_help_url())
def main(form):
instruction, state = get_form_state(form)
# print(instruction, state)
path = None
try:
path = tempfile.mkdtemp()
state, error = run_prog(instruction, state, path)
finally:
if path:
shutil.rmtree(path)
# print(error, state)
template = jinja2.Template(html_view_tmpl)
html = template.render(prog=instruction, error=error, **state)
return html
def main(argv=sys.argv):
"""main function
"""
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
# global here
global stalker_server_external_url
global mailer
global resource_mail_html_template
global responsible_mail_html_template
global resource_mail_html_template_content
global responsible_mail_html_template_content
# here = os.path.dirname(os.path.realpath(sys.argv[0]))
stalker_server_external_url = settings.get('stalker.external_url')
mailer = Mailer.from_settings(settings)
with open(resource_mail_html_template_path) as f:
resource_mail_html_template_content = f.read()
with open(responsible_mail_html_template_path) as f:
responsible_mail_html_template_content = f.read()
resource_mail_html_template = Template(resource_mail_html_template_content)
responsible_mail_html_template = Template(responsible_mail_html_template_content)
db.setup(settings)
for user in User.query.all():
send_resource_remainder(user)
send_responsible_remainder(user)
transaction.commit()
def template_string(template, **kwargs):
"""
Templates the given string with the keyword arguments
Args:
template: The template string
**kwards: Variables to use in templating
"""
temp = Template(template)
return temp.render(**kwargs)
def build_uwsgi():
print(blue("building {}".format(UWSGI_FILE_NAME)))
uwsgi_file = open(UWSGI_FILE_PATH, 'w')
context = {
'UID': UID,
'HOME_DIR': settings.HOME_DIR,
'PROJECT_NAME': settings.PROJECT_NAME,
'PROJECT_SLUG': settings.PROJECT_SLUG,
}
template = jinja2.Template(open(os.path.join(settings.BASE_DIR, 'templates/misc/uwsgi.ini'), 'r').read())
uwsgi_file.write(template.render(**context).encode('utf8'))
uwsgi_file.close()
def build_nginx():
print(blue("building {}".format(NGINX_FILE_NAME)))
nginx_file = open(NGINX_FILE_PATH, 'w')
context = {
'UID': UID,
'PORT': settings.PORT,
'SERVER_NAMES': settings.SERVER_NAMES,
'HOME_DIR': settings.HOME_DIR,
'PROJECT_SLUG': settings.PROJECT_SLUG,
}
template = jinja2.Template(open(os.path.join(settings.BASE_DIR, 'templates/misc/nginx.conf'), 'r').read())
nginx_file.write(template.render(**context).encode('utf8'))
nginx_file.close()
def test_template_loading(self):
instance = Controller.prepare(name='default').instance
await instance.db.connect()
await instance.apps.discover()
template = await load_template('core.views/generics/list.xml')
assert template and template.template
assert isinstance(template.template, Template)
def get_html(data):
template_raw = open('feed.tmpl', 'r').read()
for post in data:
if 'message' in post:
if (type(post['message']) is str):
post['message'] = fixnewlines(post['message'])
if 'flag' not in post :
post['message'] = enable_links(post['message'])
post['flag'] = 1
json.dump(data, open('docs/feed.json', 'w'))
template = Template(template_raw)
html = template.render(data=data)
# smart_str helps in unicode rendering
return smart_str(html)
def get_template_object(template_file=''):
"""Retrieve template.
Args:
template_file (str): Name of template file.
Returns:
jinja2.Template: Template ready to render.
Raises:
AssertionError: Configured path for templates does not exist.
:obj:`foremast.exceptions.ForemastTemplateNotFound`: Requested template
is not available.
"""
jinja_lst = []
if TEMPLATES_PATH:
external_templates = os.path.expanduser(TEMPLATES_PATH)
assert os.path.isdir(external_templates), 'External template path "{0}" not found'.format(external_templates)
jinja_lst.append(external_templates)
jinja_lst.append(LOCAL_TEMPLATES)
jinjaenv = jinja2.Environment(loader=jinja2.FileSystemLoader(jinja_lst))
try:
template = jinjaenv.get_template(template_file)
except jinja2.TemplateNotFound:
message = 'Unable to find template "{template_file}" in paths {paths}'.format(
template_file=template_file, paths=jinjaenv.loader.searchpath)
LOG.error(message)
raise ForemastTemplateNotFound(message)
return template
def render_jinja2(self, filename, **kwargs) -> Response:
fullname = os.path.join(self.folder, filename)
if os.path.isfile(fullname):
with open(fullname) as f:
return Response(Jinja2Template(f.read()).stream(**kwargs))
else:
raise Exception('Template {} Not Exists', format(filename))
def prepare_config(clone_no, memory, vcpus):
f = open('/tmp/ubuntu-%d' % clone_no, 'w')
template = jinja2.Template(TEMPLATE)
clone_properties = {}
clone_properties['clone_no'] = clone_no
clone_properties['padded_clone_no'] = "%02d" % (clone_no)
clone_properties['memory'] = memory
clone_properties['vcpus'] = vcpus
f.write(template.render(clone_properties))
f.close()
def read_template(template):
template_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "templates")
filename = template + ".template"
template_file = os.path.join(template_dir, filename)
if not os.path.isfile(template_file):
error("Unknown template file ({tmpl}).".format(tmpl=filename))
data = None
with open(template_file, "rU") as infile:
data = infile.read()
return Template(data)
def cache_runbooks(config, logger):
''' Open, read and cache runbooks '''
all_books = {}
runbooks = None
if os.path.isfile(config['runbook_path'] + "/init.yml"):
with open(config['runbook_path'] + "/init.yml") as fh:
template = Template(fh.read())
yml = template.render()
runbooks = yaml.load(yml)
if runbooks:
for target in runbooks:
all_books[target] = {}
if runbooks[target]:
for books in runbooks[target]:
logger.debug("Processing book: {0}".format(books))
book_path = "{0}/{1}".format(config['runbook_path'], books)
if os.path.isdir(book_path):
book_path = book_path + "/init.yml"
if os.path.isfile(book_path) is False:
logger.warn("Runbook File Error: {0} is not a file".format(book_path))
else:
with open(book_path) as bh:
all_books[target][books] = bh.read()
else:
logger.warn("Error: No runbooks specified under {0}".format(target))
return all_books
def render_runbooks(runbook, facts):
''' Render a runbook with given facts and return dictionary '''
template = Template(runbook)
yml = template.render(facts=facts)
return yaml.load(yml)
def test_BrowserReturnPositioner():
fake_browser = mock.create_autospec(EpiphanyBrowser)
html_template = jinja2.Template('genre: {{ genre }}')
tempdir = tempfile.mkdtemp()
try:
positioner = BrowserReturnPositioner(fake_browser, html_template, tempdir)
positioner.show('infraA[?3]')
assert fake_browser.open.called
positioner.hide()
assert fake_browser.close.called
finally:
shutil.rmtree(tempdir)
