def test_toplevel(self):
"""test calling a def from the top level"""
template = Template("""
this is the body
<%def name="a()">
this is a
</%def>
<%def name="b(x, y)">
this is b, ${x} ${y}
</%def>
""")
self._do_test(template.get_def("a"),
"this is a",
filters=flatten_result)
self._do_test(template.get_def("b"),
"this is b, 10 15",
template_args={'x': 10, 'y': 15},
filters=flatten_result)
self._do_test(template.get_def("body"),
"this is the body",
filters=flatten_result)
# test that args outside of the dict can be used
self._do_test(template.get_def("a"), "this is a",
filters=flatten_result,
template_args={'q': 5, 'zq': 'test'})
def test_toplevel(self):
"""test calling a def from the top level"""
template = Template("""
this is the body
<%def name="a()">
this is a
</%def>
<%def name="b(x, y)">
this is b, ${x} ${y}
</%def>
""")
self._do_test(template.get_def("a"),
"this is a",
filters=flatten_result)
self._do_test(template.get_def("b"),
"this is b, 10 15",
template_args={'x': 10, 'y': 15},
filters=flatten_result)
self._do_test(template.get_def("body"),
"this is the body",
filters=flatten_result)
# test that args outside of the dict can be used
self._do_test(template.get_def("a"), "this is a",
filters=flatten_result,
template_args={'q': 5, 'zq': 'test'})
def test_def_is_found():
from mako.template import Template
template = Template(filename=os.path.join(here, "templates/helpers.mako"))
assert template.get_def("select")
assert template.get_def("_select")
assert template.get_def("text")
assert template.get_def("text").render().strip() == "text"
def test_def_is_found():
from mako.template import Template
template = Template(filename=os.path.join(here, "templates/helpers.mako"))
assert template.get_def("select")
assert template.get_def("_select")
assert template.get_def("text")
assert template.get_def("text").render().strip() == "text"
def test_def_operations(self):
"""test get/list/has def"""
template = Template("""
this is the body
<%def name="a()">
this is a
</%def>
<%def name="b(x, y)">
this is b, ${x} ${y}
</%def>
""")
assert template.get_def("a")
assert template.get_def("b")
assert_raises(AttributeError, template.get_def, ("c"))
assert template.has_def("a")
assert template.has_def("b")
assert not template.has_def("c")
defs = template.list_defs()
assert "a" in defs
assert "b" in defs
assert "body" in defs
assert "c" not in defs
def test_toplevel_contextual(self):
template = Template(
"""
<%!
def bar(fn):
def decorate(context):
context.write("BAR")
fn()
context.write("BAR")
return ''
return decorate
%>
<%def name="foo()" decorator="bar">
this is foo
</%def>
${foo()}
"""
)
assert flatten_result(template.render()) == "BAR this is foo BAR"
assert (
flatten_result(template.get_def("foo").render())
== "BAR this is foo BAR"
)
class ExaBgpBlocker:
def __init__(self):
self.t = Template(filename=os.getenv("BHR_TEMPLATE"))
self.block = self.t.get_def('block')
self.ipv4, self.ipv6 = get_ips()
def make_routes(self, action, cidrs):
return self.block.render(action, cidrs, ipv4=self.ipv4, ipv6=self.ipv6).rstrip("\t\n ;")
def send_lots_of_routes(self, action, cidrs):
v4 = [c for c in cidrs if ':' not in c]
v6 = [c for c in cidrs if ':' in c]
for batch in iterwindow(v4, BATCHSIZE):
write(self.make_routes(action, batch))
for batch in iterwindow(v6, BATCHSIZE):
write(self.make_routes(action, batch))
def block_many(self, records):
cidrs = [b['cidr'] for b in records]
self.send_lots_of_routes("announce", cidrs)
def unblock_many(self, records):
cidrs = [r['block']['cidr'] for r in records]
self.send_lots_of_routes("withdraw", cidrs)
class ExaBgpBlocker:
def __init__(self):
self.t = Template(filename=os.getenv("BHR_TEMPLATE"))
self.block = self.t.get_def('block')
self.ipv4, self.ipv6 = get_ips()
def make_routes(self, action, cidrs):
return self.block.render(action, cidrs, ipv4=self.ipv4,
ipv6=self.ipv6).rstrip("\t\n ;")
def send_lots_of_routes(self, action, cidrs):
v4 = [c for c in cidrs if ':' not in c]
v6 = [c for c in cidrs if ':' in c]
for batch in iterwindow(v4, BATCHSIZE):
write(self.make_routes(action, batch))
for batch in iterwindow(v6, BATCHSIZE):
write(self.make_routes(action, batch))
def block_many(self, records):
cidrs = [b['cidr'] for b in records]
self.send_lots_of_routes("announce", cidrs)
def unblock_many(self, records):
cidrs = [r['block']['cidr'] for r in records]
self.send_lots_of_routes("withdraw", cidrs)
def test_def_operations(self):
"""test get/list/has def"""
template = Template("""
this is the body
<%def name="a()">
this is a
</%def>
<%def name="b(x, y)">
this is b, ${x} ${y}
</%def>
""")
assert template.get_def("a")
assert template.get_def("b")
assert_raises(AttributeError,
template.get_def,
("c")
)
assert template.has_def("a")
assert template.has_def("b")
assert not template.has_def("c")
defs = template.list_defs()
assert "a" in defs
assert "b" in defs
assert "body" in defs
assert "c" not in defs
class TemplateCollector:
def __init__(self):
self._file_set = set()
self._uber_template = None
pass
def register_file(self, *path_elements):
"""Add a file used by the Mako templating engine, to render text.
These may be command specific, or format specific."""
filename = _absolute_file(*path_elements)
self._file_set.add(filename)
self._uber_template = None
def get_template(self, def_name=None):
if self._uber_template is None:
buf = StringIO()
for file in self._file_set:
t = Template(filename=file)
buf.write(t.source)
self._uber_template = Template(buf.getvalue(),
module_directory='/tmp/mako')
buf.close()
if self._uber_template.has_def(def_name):
return self._uber_template.get_def(def_name)
else:
return self._uber_template
def meetup_article_text(meetup):
t = Template(filename="r2/templates/showmeetup.html", output_encoding='utf-8', encoding_errors='replace')
res = t.get_def("meetup_info").render_unicode(meetup=meetup)
url = url_for(controller='meetups',action='show',id=meetup._id36)
title = python_websafe(meetup.title)
hdr = u"<h2>Discussion article for the meetup : <a href='%s'>%s</a></h2>"%(url,title)
return hdr+res+hdr
def write_hints(
tables: List[str],
elements: List[Union[ClassModel, NamespaceModel, FunctionModel,
AttributeModel]],
):
lookup = TemplateLookup(["templates/hints"])
with open("templates/hints/lua_class.mako", "r", encoding="utf-8") as tpl:
class_tpl = Template(tpl.read(), lookup=lookup)
with open("templates/hints/lua_function.mako", "r",
encoding="utf-8") as tpl:
function_tpl = Template(tpl.read(), lookup=lookup)
with open("templates/hints/lua_enum.mako", "r", encoding="utf-8") as tpl:
enum_tpl = Template(tpl.read(), lookup=lookup)
with open("templates/hints/lua_global.mako", "r", encoding="utf-8") as tpl:
global_tpl = Template(tpl.read(), lookup=lookup)
with open("templates/hints/lua_typedef.mako", "r",
encoding="utf-8") as tpl:
typedef_tpl = Template(tpl.read(), lookup=lookup)
hints = [f"{table} = {{}};\n" for table in tables]
hints += ["\n"]
for element in elements:
if element._type == "class":
hints.append(class_tpl.get_def("lua_class").render(klass=element))
elif element._type == "function":
hints.append(
function_tpl.get_def("lua_function").render(function=element))
elif element._type == "enum":
hints.append(enum_tpl.get_def("lua_enum").render(enum=element))
elif element._type == "global":
hints.append(global_tpl.get_def("lua_global").render(glob=element))
elif element._type == "typedef":
hints.append(
typedef_tpl.get_def("lua_typedef").render(typedef=element))
hints += ["\n\n"]
hints += [
f"---@type {manual_type_value}\n{manual_type_name} = {{}};\n\n"
for manual_type_name, manual_type_value in MANUAL_TYPES.items()
]
with open(
os.path.join("export", "hints.lua"),
"w",
encoding="utf-8",
) as export:
export.write("".join(hints))
def test_toplevel(self):
"""test calling a def from the top level"""
template = Template("""
this is the body
<%def name="a()">
this is a
</%def>
<%def name="b(x, y)">
this is b, ${x} ${y}
</%def>
""", output_encoding='utf-8')
assert flatten_result(template.get_def("a").render()) == "this is a"
assert flatten_result(template.get_def("b").render(x=10, y=15)) == "this is b, 10 15"
assert flatten_result(template.get_def("body").render()) == "this is the body"
def test_collect_def():
from mako.template import Template
template = Template(filename=os.path.join(here, "templates/helpers.mako"))
result = list(_callFUT(template))
assert len(result) == 2
assert sorted([name for name, _ in result]) == ["select", "text"]
assert sorted(result)[0][1].callable_ == template.get_def("select").callable_
def test_collect_def():
from mako.template import Template
template = Template(filename=os.path.join(here, "templates/helpers.mako"))
result = list(_callFUT(template))
assert len(result) == 2
assert sorted([name for name, _ in result]) == ["select", "text"]
assert sorted(result)[0][1].callable_ == template.get_def(
"select").callable_
class GPUNNPSHelper(object):
def __init__(self, ctx, tpl_filename, use_double=False):
disable_unicode = False if sys.version_info.major > 2 else True
self.src_tpl = Template(filename=os.path.join(
os.path.dirname(os.path.realpath(__file__)), tpl_filename),
disable_unicode=disable_unicode)
self.data_t = "double" if use_double else "float"
helper_tpl = Template(filename=os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"gpu_helper_functions.mako"),
disable_unicode=disable_unicode)
helper_preamble = helper_tpl.get_def("get_helpers").render(
data_t=self.data_t)
preamble = self.src_tpl.get_def("preamble").render(data_t=self.data_t)
self.preamble = "\n".join([helper_preamble, preamble])
self.ctx = ctx
self.cache = {}
def _get_code(self, kernel_name, **kwargs):
arguments = self.src_tpl.get_def("%s_args" % kernel_name).render(
data_t=self.data_t, **kwargs)
src = self.src_tpl.get_def("%s_src" % kernel_name).render(
data_t=self.data_t, **kwargs)
return arguments, src
def get_kernel(self, kernel_name, **kwargs):
data = kernel_name, tuple(kwargs.items())
if data in self.cache:
return profile_kernel(self.cache[data], kernel_name)
else:
args, src = self._get_code(kernel_name, **kwargs)
knl = ElementwiseKernel(self.ctx,
args,
src,
kernel_name,
preamble=self.preamble)
self.cache[data] = knl
return profile_kernel(knl, kernel_name)
def meetup_article_text(meetup):
t = Template(filename="r2/templates/showmeetup.html",
output_encoding='utf-8',
encoding_errors='replace')
res = t.get_def("meetup_info").render_unicode(meetup=meetup)
url = url_for(controller='meetups', action='show', id=meetup._id36)
title = python_websafe(meetup.title)
hdr = u"<h2>Discussion article for the meetup : <a href='%s'>%s</a></h2>" % (
url, title)
return hdr + res + hdr
class GPUNNPSHelper(object):
def __init__(self, ctx, tpl_filename, use_double=True):
self.src_tpl = Template(filename = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
tpl_filename), disable_unicode=True)
self.data_t = "double" if use_double else "float"
helper_tpl = Template(filename = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"gpu_helper_functions.mako"), disable_unicode=True)
helper_preamble = helper_tpl.get_def("get_helpers").render(
data_t=self.data_t)
self.preamble = "\n".join([
helper_preamble,
self.src_tpl.get_def("preamble").render(data_t=self.data_t)
])
self.ctx = ctx
def _get_code(self, kernel_name, **kwargs):
arguments = self.src_tpl.get_def("%s_args" % kernel_name).render(
data_t=self.data_t, **kwargs)
src = self.src_tpl.get_def("%s_src" % kernel_name).render(
data_t=self.data_t, **kwargs)
return arguments, src
def get_kernel(self, kernel_name, **kwargs):
args, src = self._get_code(kernel_name, **kwargs)
knl = ElementwiseKernel(self.ctx,
args,
src,
kernel_name,
preamble=self.preamble)
return knl
class ExaBgpBlocker:
def __init__(self):
self.t = Template(filename=os.getenv("BHR_TEMPLATE"))
self.block = self.t.get_def('block')
def make_route(self, action, b):
return action + " " + self.block.render(b=b).rstrip()
def block_many(self, records):
for r in records:
print self.make_route("announce", r)
flush()
def unblock_many(self, records):
for r in records:
print self.make_route("withdraw", r['block'])
flush()
def __init__(self, ctx, tpl_filename, use_double=True):
self.src_tpl = Template(filename = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
tpl_filename), disable_unicode=True)
self.data_t = "double" if use_double else "float"
helper_tpl = Template(filename = \
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"gpu_helper_functions.mako"), disable_unicode=True)
helper_preamble = helper_tpl.get_def("get_helpers").render(
data_t=self.data_t)
self.preamble = "\n".join([
helper_preamble,
self.src_tpl.get_def("preamble").render(data_t=self.data_t)
])
self.ctx = ctx
def __init__(self, ctx, tpl_filename, use_double=False):
disable_unicode = False if sys.version_info.major > 2 else True
self.src_tpl = Template(filename=os.path.join(
os.path.dirname(os.path.realpath(__file__)), tpl_filename),
disable_unicode=disable_unicode)
self.data_t = "double" if use_double else "float"
helper_tpl = Template(filename=os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"gpu_helper_functions.mako"),
disable_unicode=disable_unicode)
helper_preamble = helper_tpl.get_def("get_helpers").render(
data_t=self.data_t)
preamble = self.src_tpl.get_def("preamble").render(data_t=self.data_t)
self.preamble = "\n".join([helper_preamble, preamble])
self.ctx = ctx
self.cache = {}
def __init__(self,
tpl_filename,
backend=None,
use_double=False,
c_type=None):
"""
Parameters
----------
tpl_filename
filename of source template
backend
backend to use for helper
use_double:
Use double precision floating point data types
c_type:
c_type to use. Overrides use_double
"""
disable_unicode = False if sys.version_info.major > 2 else True
self.src_tpl = Template(
filename=os.path.join(os.path.dirname(os.path.realpath(__file__)),
tpl_filename),
disable_unicode=disable_unicode,
)
self.data_t = "double" if use_double else "float"
if c_type is not None:
self.data_t = c_type
helper_tpl = Template(filename=os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"gpu_helper_functions.mako"),
disable_unicode=disable_unicode)
helper_preamble = helper_tpl.get_def("get_helpers").render(
data_t=self.data_t)
preamble = self.src_tpl.get_def("preamble").render(data_t=self.data_t)
self.preamble = "\n".join([helper_preamble, preamble])
self.cache = {}
self.backend = backend
def test_toplevel_contextual(self):
template = Template("""
<%!
def bar(fn):
def decorate(context):
context.write("BAR")
fn()
context.write("BAR")
return ''
return decorate
%>
<%def name="foo()" decorator="bar">
this is foo
</%def>
${foo()}
""")
assert flatten_result(template.render()) == "BAR this is foo BAR"
assert flatten_result(template.get_def('foo').render()) == "BAR this is foo BAR"
class MakoTemplatesetFile(TemplatesetBase):
'''Mako file-based templateset (a wrapper to mako.template.Template)
Members:
_template -- Mako master template
'''
_template = None
def __init__(self, *args, **kwargs):
super(MakoTemplatesetFile, self).__init__()
if 'template_object' in kwargs:
self._template = kwargs.pop('template_object')
else:
self._template = ExternalMakoTemplate(*args, **kwargs)
# TemplateCollection interface
def get_template(self, name):
tpl = self._template.get_def(name)
return MakoTemplate(tpl)
get_template.__doc__ = TemplatesetBase.get_template.__doc__
class Walker:
def __init__(self):
self.template = Template(filename='/home/cap/thesis/cheqed/app/proof/proof.html', format_exceptions=True)
self.buffer = StringIO()
self.assumption_index = 0
def render(self, name, **kwargs):
template = self.template.get_def(name)
self.buffer.write(template.render(**kwargs))
def unpack_goal(self, goal):
p_goal = []
for i in range(max(len(goal.left), len(goal.right))):
if i < len(goal.left):
left = env.printer.print_term(goal.left[i])
else:
left = ''
if i < len(goal.right):
right = env.printer.print_term(goal.right[i])
else:
right = ''
p_goal.append((left, right))
return p_goal
def begin_primitive(self, primitive, goal):
assumption_index = self.assumption_index
if primitive.func.func_name == 'assumption':
rules = env.applicable_rules(goal)
rules.sort(key=lambda x: x.rule_name())
self.assumption_index += 1
else:
rules = []
p_primitive = env.print_proof(primitive)
p_goal = self.unpack_goal(goal)
self.render('begin_primitive',
primitive=p_primitive,
goal=p_goal,
rules=rules,
assumption_index=assumption_index)
def end_primitive(self, primitive):
self.render('end_primitive')
def begin_compound(self, compound, goal):
p_compound = env.print_proof(compound)
p_goal = self.unpack_goal(goal)
self.render('begin_compound',
compound=p_compound,
goal=p_goal)
def end_compound(self, compound):
self.render('end_compound')
def begin_branch(self, branch, goal):
if len(branch.branches) > 1:
self.render('begin_branch')
def end_branch(self, branch):
if len(branch.branches) > 1:
self.render('end_branch')
def __call__(self, field, **kwargs):
kwargs.setdefault("path", "")
template = Template(filename=join(dirname(__file__),
"templates",
"preview.html"))
return template.get_def("image").render(field=field, **kwargs)
class PovRayRenderer(AbstractRenderer):
def __init__(self, scene):
super(PovRayRenderer, self).__init__(scene);
def render(self):
self.__initialize();
self.__add_header();
self.__add_lights();
self.__add_active_camera();
self.__add_transformations();
self.__add_active_view();
self.__add_primitives();
self.__add_others();
self.__run_povray();
def __initialize(self):
self.__initialize_povray_setting();
self.__initialize_image_setting();
self.__initialize_geometry_setting();
def __initialize_povray_setting(self):
self.povray_setting = "";
self.pov_module_path = os.path.dirname(
inspect.getfile(PovRayRenderer));
template_file = os.path.join(self.pov_module_path,
"mako_files/povray_template.mako");
self.pov_template = Template(filename=template_file);
def __initialize_image_setting(self):
active_view = self.scene.active_view;
self.output_dir = self.scene.output_dir;
self.image_name = active_view.name;
self.image_width = float(active_view.width);
self.image_height = float(active_view.height);
active_camera = self.scene.active_camera;
active_camera.fovx = degrees(atan2(self.image_width,
self.image_height / tan(radians(active_camera.fovy * 0.5))
)) * 2.0;
def __initialize_geometry_setting(self):
active_view = self.scene.active_view;
if len(active_view.vertices) > 0:
self.global_transform = self.scene.global_transform[:3,:].ravel(order="F");
global_rotation = self.scene.global_transform[:3, :3];
vertices = active_view.vertices;
vertices = np.dot(active_view.rotation, vertices.T) +\
active_view.translation[:, np.newaxis];
vertices = np.dot(global_rotation, vertices);
vertices = vertices.T;
self.transformed_bbox_min = np.amin(vertices, axis=0);
self.transformed_bbox_max = np.amax(vertices, axis=0);
center = 0.5 * (self.transformed_bbox_min + self.transformed_bbox_max);
self.floor_height = self.transformed_bbox_min[1] - center[1];
else:
dim = active_view.vertices.shape[1];
self.transformed_bbox_min = np.zeros(dim);
self.transformed_bbox_max = np.ones(dim);
self.floor_height = 0;
self.global_transform = self.scene.global_transform[:3,:].ravel(order="F");
def __add_header(self):
header_setting = self.pov_template.get_def("header").render();
global_setting = self.pov_template.get_def("global_setting").render(
transform = self.global_transform,
bbox_min = self.transformed_bbox_min,
bbox_max = self.transformed_bbox_max,
floor_height = self.floor_height);
self.povray_setting += header_setting;
self.povray_setting += global_setting;
def __add_lights(self):
#TODO: load lights from scene.
light_setting = self.pov_template.get_def("add_lights").render();
self.povray_setting += light_setting;
def __add_active_camera(self):
camera = self.scene.active_camera;
camera_setting = self.pov_template.get_def("add_camera").render(
location = camera.location,
up_direction = camera.up_direction,
look_at_point = camera.look_at_point,
fovx = camera.fovx,
width = self.image_width,
height = self.image_height
);
self.povray_setting += camera_setting;
def __add_transformations(self):
active_view = self.scene.active_view;
transformation_setting = \
self.pov_template.get_def("add_transformations").render(
centroid = active_view.center,
scale = active_view.scale,
transform = active_view.transform.ravel(order="F")
);
self.povray_setting += transformation_setting;
def __add_active_view(self):
active_view = self.scene.active_view;
if len(active_view.vertices) == 0: return;
view_setting = self.pov_template.get_def("add_view").render(
vertices = active_view.vertices,
triangles = active_view.faces,
colors = active_view.vertex_colors
);
self.povray_setting += view_setting;
def __add_primitives(self):
primitives = self.scene.active_view.primitives;
for shape in primitives:
if isinstance(shape, Cylinder):
cylinder_setting = \
self.pov_template.get_def("add_cylinder").render(
end_points = shape.end_points,
radii = [shape.radius, shape.radius],
color = shape.color);
self.povray_setting += cylinder_setting;
elif isinstance(shape, Cone):
cone_setting = \
self.pov_template.get_def("add_cylinder").render(
end_points = shape.end_points,
radii = [shape.radius, 0.0],
color = shape.color);
self.povray_setting += cone_setting;
elif isinstance(shape, Sphere):
sphere_setting =\
self.pov_template.get_def("add_sphere").render(
center = shape.center,
radius = shape.radius,
color = shape.color);
self.povray_setting += sphere_setting;
def __add_others(self):
active_view = self.scene.active_view;
if active_view.with_quarter:
self.__add_quarter();
if active_view.with_axis:
self.__add_axis();
if active_view.background != "n":
self.__add_floor();
def __add_quarter(self):
quarter_setting = self.pov_template.get_def("add_quarter").render();
self.povray_setting += quarter_setting;
def __add_floor(self):
floor_setting = self.pov_template.get_def("add_floor").render(
background = self.scene.active_view.background);
self.povray_setting += floor_setting;
def __add_axis(self):
axis_setting = self.pov_template.get_def("add_axis").render();
self.povray_setting += axis_setting;
def __run_povray(self):
basename, ext = os.path.splitext(self.image_name);
pov_file = os.path.join(self.output_dir, basename + ".pov");
img_file = os.path.join(self.output_dir, basename + ".png");
with open(pov_file, 'w') as fout:
fout.write(self.povray_setting);
options = "+A -D -V +WL0 +W{} -H{} -L{} +O{}".format(
self.image_width, self.image_height,
os.path.join(self.pov_module_path, "pov_files"),
img_file);
if self.scene.active_view.transparent_bg:
options += " +ua";
command = "povray {} {}".format(options, pov_file);
print(command);
check_call(command.split());
def __call__(self, field, **kwargs):
kwargs.setdefault("path", "")
template = Template(
filename=join(dirname(__file__), "templates", "preview.html"))
return template.get_def("image").render(field=field, **kwargs)
class PhraseBank:
def __init__(self, template=None):
self._phrases = {}
self._src = template.source if template else ""
self._template = None
def set_template(self, template):
if template:
self._src = template.source
self._template = None
def __setitem__(self, key, value):
list = self._phrases.setdefault(key, [])
list.append(value)
def __getitem__(self, key):
list = self._phrases[key]
return list[-1]
def render(self, defName=None, **data):
if not self._template:
src = "%s\n%s" % (self._src, self._generate_mako(self._phrases))
self._template = Template(src, format_exceptions=False)
if not defName:
template = self._template
elif self.has_key(defName):
template = self._template.get_def(defName)
else:
raise ValueError()
return render_template(template, TEMPLATE=template, **data)
def has_key(self, key):
if self._template and self._template.has_def(key):
return True
else:
return self._phrases.has_key(key)
def _generate_mako(self, phrase_dict):
outer_funcs = []
for phrase_name_and_args, phrase_texts in phrase_dict.items():
# handle the case where no bracket has been added
if '__name__' is phrase_name_and_args:
continue
if "(" in phrase_name_and_args:
# slice the arglist of the function.
open = phrase_name_and_args.index('(')
phrase_name = phrase_name_and_args[:open]
ending = phrase_name_and_args[open:]
else:
# add one by default
ending = "()"
phrase_name = phrase_name_and_args
# generate an inner def for each value of the phrase we've got.
inner_func_names = []
inner_funcs = []
index = 0
for phrase in phrase_texts:
inner_func_name = "_%s_%s" % (index, phrase_name)
inner_funcs.append("<%%def name='%s%s'>%s</%%def>" %
(inner_func_name, ending, phrase))
inner_func_names.append(inner_func_name)
index = index + 1
outer_dict = {
'phrase_name': phrase_name,
'arg_list': ending,
'inner_funcs': "".join(inner_funcs),
'inner_func_names': ", ".join(inner_func_names),
}
# then generate a custom python routine which will select a random def and call it.
single_func = """
<%%def name='%(phrase_name)s%(arg_list)s'>%(inner_funcs)s<%%
fns = [%(inner_func_names)s]
import random
random.sample(fns, 1)[0]%(arg_list)s
%%></%%def>""" % outer_dict
outer_funcs.append(single_func)
return "\n".join(outer_funcs)
def install(self, phase):
"""\
Apply the templates in "phase" by searching in tplpath.
"""
# TODO: installation file ownership
if not os.path.isdir(self._tplpath):
self._logger.warning("{td} is not a directory, ignoring for templating".format(td=self._tplpath))
return
self._logger.debug("Applying templates for phase {p}".format(p=phase))
for (root, dirs, files) in os.walk(self._tplpath):
for tplfile in [file for file in files if file.endswith(".tpl")]:
with open(os.path.join(root, tplfile), "rb") as tplfp:
makot = Template(tplfp.read(), strict_undefined=True)
install = {}
makot.get_def("install").render(i=install)
install["dest"] = os.path.join(self._image.path, "origin", *install["filename"].split(os.sep))
install["mode"] = int(install.get("mode", "0644"), 8)
try:
# Check the template is relevant to this phase of the build
if phase not in install["phase"]:
continue
except KeyError:
pass
self._logger.debug("Installing {filename} from template to {dest}".format(**install))
renderctx = {
"ymlcfg": self._ymlcfg,
"vmyml": self._vmyml,
"rootpath": os.path.join(self._image.path, "origin"),
"phase": phase
}
if os.path.isfile(install["dest"]):
# If there is an existing file at the location generate
# a checksum for it. This can be used by a template to
# a) decide how to render content based on current source
# b) validate that the default file being replaced is the
# the one template is relevant for, e.g. has upstream
# made changes the template should account for.
s256 = hashlib.sha256()
with open(install["dest"], "rb") as fp:
while True:
data = fp.read(16 * 4096)
if not data:
break
s256.update(data)
renderctx["sha256"] = s256.hexdigest()
self._logger.debug("Existing {filename} checksum {s}".format(s=s256.hexdigest(), **install))
else:
renderctx["sha256"] = None
try:
rendered = makot.render(**renderctx)
except VMCPhaseError:
continue
try:
# For some files we may be interested in the old
# content to ensure that our template replaces
# it with something compatible.
if renderctx["sha256"] not in install["sha256"]:
# The rendered file is not acceptable, check if
# we already applied this template by examinging
# the rendered digest before error.
r256 = hashlib.sha256()
r256.update(rendered.encode("utf-8"))
if renderctx["sha256"] == r256.hexdigest():
self._logger.warning("Template was already applied")
else:
raise VMCTemplateChecksumError("unacceptable sha256: {c}".format(c=renderctx["sha256"]))
except KeyError:
pass
try:
# Create the installation path if it isn't already present
insdir = os.path.join(os.sep, *install["dest"].split(os.sep)[:-1])
self._logger.debug("Creating {insdir} if necessary".format(insdir=insdir))
os.makedirs(insdir)
except FileExistsError:
if not os.path.isdir(insdir):
raise
with open(install["dest"], "wb") as tplout:
tplout.write(rendered.encode("utf-8"))
dstat = os.stat(install["dest"])
dmode = stat.S_IMODE(dstat.st_mode)
if dmode != install["mode"]:
self._logger.debug("chmod {mode} {dest_oct}".format(dest_oct=oct(install["mode"]), **install))
os.chmod(install["dest"], install["mode"])
class GPUNNPSHelper(object):
def __init__(self,
tpl_filename,
backend=None,
use_double=False,
c_type=None):
"""
Parameters
----------
tpl_filename
filename of source template
backend
backend to use for helper
use_double:
Use double precision floating point data types
c_type:
c_type to use. Overrides use_double
"""
self.src_tpl = Template(filename=os.path.join(
os.path.dirname(os.path.realpath(__file__)), tpl_filename), )
self.data_t = "double" if use_double else "float"
if c_type is not None:
self.data_t = c_type
helper_tpl = Template(filename=os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"gpu_helper_functions.mako"), )
helper_preamble = helper_tpl.get_def("get_helpers").render(
data_t=self.data_t)
preamble = self.src_tpl.get_def("preamble").render(data_t=self.data_t)
self.preamble = "\n".join([helper_preamble, preamble])
self.cache = {}
self.backend = backend
def _get_code(self, kernel_name, **kwargs):
arguments = self.src_tpl.get_def("%s_args" % kernel_name).render(
data_t=self.data_t, **kwargs)
src = self.src_tpl.get_def("%s_src" % kernel_name).render(
data_t=self.data_t, **kwargs)
return arguments, src
def get_kernel(self, kernel_name, **kwargs):
key = kernel_name, tuple(kwargs.items())
wgs = kwargs.get('wgs', None)
if key in self.cache:
return self.cache[key]
else:
args, src = self._get_code(kernel_name, **kwargs)
if wgs is None:
knl = get_elwise_kernel(kernel_name,
args,
src,
preamble=self.preamble)
else:
knl = get_simple_kernel(kernel_name,
args,
src,
wgs,
preamble=self.preamble)
self.cache[key] = knl
return knl