Example #1
0
    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'})
Example #2
0
    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'})
Example #3
0
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"
Example #4
0
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"
Example #5
0
    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"
        )
Example #7
0
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)
Example #8
0
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)
Example #9
0
    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
Example #10
0
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
Example #12
0
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))
Example #13
0
File: test_def.py Project: SjB/mako
    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"
Example #14
0
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_
Example #15
0
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_
Example #16
0
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)
Example #17
0
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
Example #18
0
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
Example #19
0
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()
Example #20
0
    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
Example #21
0
    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 = {}
Example #22
0
    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
Example #23
0
    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"
Example #24
0
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__
Example #25
0
File: views.py Project: cap/cheqed
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')
Example #26
0
 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)
Example #27
0
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());
Example #28
0
 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)
Example #29
0
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)
Example #30
0
    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"])
Example #31
0
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