def render_dummy_page(data=None): template = Template(filename='templates/dummy.html', module_directory='templates/modules/') return template.render_unicode(data=data)
def gs_gpu(idata, itera=100): """Gerchberg-Saxton algorithm to calculate DOEs using the GPU Calculates the phase distribution in a object plane to obtain an specific amplitude distribution in the target plane. It uses a FFT to calculate the field propagation. The wavefront at the DOE plane is assumed as a plane wave. **ARGUMENTS:** ========== ====================================================== idata numpy array containing the target amplitude distribution itera Maximum number of iterations ========== ====================================================== """ pl = cl.get_platforms()[0] devices = pl.get_devices(device_type=cl.device_type.GPU) ctx = cl.Context(devices=[devices[0]]) queue = cl.CommandQueue(ctx) plan = Plan(idata.shape, queue=queue, dtype=complex128) #no funciona con "complex128" src = str( Template(KERNEL).render( double_support=all(has_double_support(dev) for dev in devices), amd_double_support=all( has_amd_double_support(dev) for dev in devices))) prg = cl.Program(ctx, src).build() idata_gpu = cl_array.to_device(queue, ifftshift(idata).astype("complex128")) fdata_gpu = cl_array.empty_like(idata_gpu) rdata_gpu = cl_array.empty_like(idata_gpu) plan.execute(idata_gpu.data, fdata_gpu.data) e = 1000 ea = 1000 for i in range(itera): prg.norm(queue, fdata_gpu.shape, None, fdata_gpu.data) plan.execute(fdata_gpu.data, rdata_gpu.data, inverse=True) tr = rdata_gpu.get() rdata = ifftshift(tr) #TODO: This calculation should be done in the GPU e = (abs(rdata) - idata).std() if e > ea: break ea = e prg.norm2(queue, rdata_gpu.shape, None, rdata_gpu.data, idata_gpu.data) plan.execute(rdata_gpu.data, fdata_gpu.data) fdata = fdata_gpu.get() #~ prg.norm(queue, fdata_gpu.shape, None,fdata_gpu.data) fdata = ifftshift(fdata) fdata = exp(1.j * angle(fdata)) #~ fdata=fdata_gpu.get() return fdata
def testnonexpression(self): t = Template(""" <%! def a(text): return "this is a" def b(text): return "this is b" %> ${foo()} <%def name="foo()" buffered="True"> this is text </%def> """, buffer_filters=['a']) assert t.render().strip() == "this is a" t = Template(""" <%! def a(text): return "this is a" def b(text): return "this is b" %> ${'hi'} ${foo()} <%def name="foo()" buffered="True"> this is text </%def> """, buffer_filters=['a'], default_filters=['b']) assert flatten_result(t.render()) == "this is b this is b" t = Template(""" <%! class Foo(object): foo = True def __str__(self): return "this is a" def a(text): return Foo() def b(text): if hasattr(text, 'foo'): return str(text) else: return "this is b" %> ${'hi'} ${foo()} <%def name="foo()" buffered="True"> this is text </%def> """, buffer_filters=['a'], default_filters=['b']) assert flatten_result(t.render()) == "this is b this is a" t = Template(""" <%! def a(text): return "this is a" def b(text): return "this is b" %> ${foo()} ${bar()} <%def name="foo()" filter="b"> this is text </%def> <%def name="bar()" filter="b" buffered="True"> this is text </%def> """, buffer_filters=['a']) assert flatten_result(t.render()) == "this is b this is a"
def _compile_from_file(self, path, filename): self.path = path return Template("foo bar").module
def test_future_import(self): t = Template("${ x / y }", future_imports=["division"]) assert result_lines(t.render(x=12, y=5)) == ["2.4"]
TEMPLATE_C = Template(COPYRIGHT + """ /* This file generated from ${filename}, don't edit directly. */ #define VK_PROTOTYPES #include <vulkan/vulkan.h> #include "lvp_private.h" #include "pipe/p_context.h" #include "vk_util.h" % for c in commands: % if c.name in manual_commands: <% continue %> % endif % if c.guard is not None: #ifdef ${c.guard} % endif VKAPI_ATTR ${c.return_type} VKAPI_CALL lvp_${c.name} (VkCommandBuffer commandBuffer % for p in c.params[1:]: , ${p.decl} % endfor ) { LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); vk_enqueue_${to_underscore(c.name)}(&cmd_buffer->queue % for p in c.params[1:]: , ${p.name} % endfor ); % if c.return_type == 'VkResult': return VK_SUCCESS; % endif } % if c.guard is not None: #endif // ${c.guard} % endif % endfor """, output_encoding='utf-8')
def create_configuration_to_string(): template_path = resource_filename('nikola', 'conf.py.in') conf_template = Template(filename=template_path) return conf_template.render(**prepare_config(SAMPLE_CONF))
def run(self, snapshot, recursive=False): dataset = snapshot.get('dataset') or snapshot.get('id').split('@')[0] id = snapshot.get('id') or '{0}@{1}'.format(dataset, snapshot.get('name')) vm_snapname = self.environment.get('vmware_snapshot_name') failed_snapshots = self.environment.get('vmware_failed_snapshots', []) if not vm_snapname: return logger.info('VM snapshot name is: {0}'.format(vm_snapname)) for mapping in self.datastore.query_stream('vmware.datasets'): if recursive: if not re.search('^{0}(/|$)'.format(mapping['dataset']), dataset) and \ not re.search('^{0}(/|$)'.format(dataset), mapping['dataset']): continue else: if mapping['dataset'] != dataset: continue peer = self.dispatcher.call_sync('peer.query', [('id', '=', mapping['peer'])], {'single': True}) if not peer: failed_snapshots.append({ 'when': 'connect', 'host': '<mapping {0}>'.format(mapping['name']), 'datastore': mapping['datastore'], 'error': 'Cannot find peer entry for mapping {0}'.format( mapping['name']) }) continue if any( i.get('host') == q.get(peer, 'credentials.address') for i in failed_snapshots): continue try: ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ssl_context.verify_mode = ssl.CERT_NONE si = connect.SmartConnect(host=q.get(peer, 'credentials.address'), user=q.get(peer, 'credentials.username'), pwd=q.get(peer, 'credentials.password'), sslContext=ssl_context) content = si.RetrieveContent() vm_view = content.viewManager.CreateContainerView( content.rootFolder, [vim.VirtualMachine], True) except BaseException as err: logger.warning( 'Connecting to VMware instance at {0} failed: {1}'.format( q.get(peer, 'credentials.address'), str(err))) failed_snapshots.append({ 'when': 'connect', 'host': q.get(peer, 'credentials.address'), 'datastore': mapping['datastore'], 'error': getattr(err, 'msg', str(err)) }) continue for vm in vm_view.view: if not any(i.info.name == mapping['datastore'] for i in vm.datastore): continue if not vm.snapshot: continue snapshot = find_snapshot(vm.snapshot.rootSnapshotList, vm_snapname) if not snapshot: continue logger.info( 'Removing snapshot of VM {0} (datastore {1})'.format( vm.summary.config.name, mapping['datastore'])) try: task.WaitForTask(snapshot.RemoveSnapshot_Task(True)) except vmodl.MethodFault as err: logger.warning( 'Deleting snapshot of {0} failed: {1}'.format( vm.summary.config.name, err.msg)) failed_snapshots.append({ 'when': 'delete', 'vm': vm.summary.config.name, 'datastore': mapping['datastore'], 'error': err.msg }) connect.Disconnect(si) if failed_snapshots: descr = Template(ALERT_TEMPLATE).render( id=id, failed_snapshots=failed_snapshots) self.dispatcher.call_sync( 'alert.emit', { 'class': 'VMwareSnapshotFailed', 'target': dataset, 'title': 'Failed to create or remove snapshot of one or more VMware virtual machines', 'description': descr })
def main(argv): got_input = False module_directory = None dictionary = {} json_dict = {} got_output = False output_file = sys.stdout plugins = [] output_name = None try: opts, args = getopt.getopt(argv, 'hm:d:o:p:') except getopt.GetoptError: out('Unknown option') showhelp() sys.exit(2) for opt, arg in opts: if opt == '-h': out('Displaying showhelp') showhelp() sys.exit() elif opt == '-o': if got_output: out('Got more than one output') showhelp() sys.exit(3) got_output = True output_name = arg elif opt == '-m': if module_directory is not None: out('Got more than one cache directory') showhelp() sys.exit(4) module_directory = arg elif opt == '-d': dict_file = open(arg, 'r') bunch.merge_json(json_dict, yaml.load(dict_file.read())) dict_file.close() elif opt == '-p': plugins.append(import_plugin(arg)) for plugin in plugins: plugin.mako_plugin(json_dict) for k, v in json_dict.items(): dictionary[k] = bunch.to_bunch(v) cleared_dir = False for arg in args: got_input = True with open(arg) as f: srcs = list(yaml.load_all(f.read())) for src in srcs: if isinstance(src, basestring): assert len(srcs) == 1 template = Template(src, filename=arg, module_directory=module_directory, lookup=TemplateLookup(directories=['.'])) with open(output_name, 'w') as output_file: template.render_context(Context(output_file, **dictionary)) else: # we have optional control data: this template represents # a directory if not cleared_dir: if not os.path.exists(output_name): pass elif os.path.isfile(output_name): os.unlink(output_name) else: shutil.rmtree(output_name, ignore_errors=True) cleared_dir = True items = [] if 'foreach' in src: for el in dictionary[src['foreach']]: if 'cond' in src: args = dict(dictionary) args['selected'] = el if not eval(src['cond'], {}, args): continue items.append(el) assert items else: items = [None] for item in items: args = dict(dictionary) args['selected'] = item item_output_name = os.path.join( output_name, Template(src['output_name']).render(**args)) if not os.path.exists(os.path.dirname(item_output_name)): os.makedirs(os.path.dirname(item_output_name)) template = Template( src['template'], filename=arg, module_directory=module_directory, lookup=TemplateLookup(directories=['.'])) with open(item_output_name, 'w') as output_file: template.render_context(Context(output_file, **args)) if not got_input: out('Got nothing to do') showhelp() output_file.close()
] modules.sort() for module in modules: __import__(module) classes = {} for module in modules: classes[module] = [] for name, obj in inspect.getmembers(sys.modules[module]): if inspect.isclass(obj) and obj.__module__ == module: classes[module].append(name) module_file_names = [] for module_name, classes in six.iteritems(classes): file_name = module_name.replace('.', '_').lower() module_file_names.append(file_name) with open('standard/models/{name}.rst'.format(name=file_name), 'w') as sources: template = Template(filename='standard/models/models.rst.mako') sources.write(template.render(**{'module_name': module_name, 'classes': classes})) with open('standard/models/index.rst', 'w') as sources: template = Template(filename='standard/models/index.rst.mako') sources.write(template.render(**{'module_file_names': module_file_names})) # Add any paths that contain templates here, relative to this directory. templates_path = ['doc/_buildtemplates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] source_suffix = '.rst' # The master toctree document.
return insert(instr); } % if name == 'sop1' or name == 'sop2' or name == 'sopc': <% args[0] = 'WaveSpecificOpcode opcode' params = [] for i in range(num_definitions): params.append('def%d' % i) for i in range(num_operands): params.append('op%d' % i) %>\\ inline Result ${name}(${', '.join(args)}) { return ${name}(w64or32(opcode), ${', '.join(params)}); } % endif % endfor % endfor }; } #endif /* _ACO_BUILDER_ */""" from aco_opcodes import opcodes, Format from mako.template import Template print(Template(template).render(opcodes=opcodes, Format=Format))
_filterL = filter(lambda e,_path=_path: os.path.commonprefix([_path, e])==e, filter_list) filtered = bool(list(_filterL)) if filtered: print('filtered %r' % path) return filtered if __name__=='__main__': resultL = [] filterL = filter_list() print("generated Filterlist: \n%r" % filterL) for base_path in config['base_pathL']: log.debug('Find dirvish vaults in path %r', base_path) for dirname, dirnames, _ in os.walk(base_path): for possible_vault in dirnames: possible_vault_dir = os.path.join(base_path, possible_vault) if is_blacklisted(possible_vault_dir, filterL): continue print("Check directory in %r/%r" %(base_path, possible_vault)) backupDir = backup_dir(base_path, possible_vault) if backupDir: resultL.append(os.path.join(backupDir)) dirnames.clear() with open('/etc/ptx_backup/dirvish.vault.script.sh', 'w') as file: try: template = Template(filename=config['templateFile']) file.write(template.render(dirL=resultL, config=config)) except: print(exceptions.text_error_template().render()) raise
def _connections(self): fg = self._flow_graph templates = { key: Template(text) for key, text in fg.parent_platform.connection_templates.items() } def make_port_sig(port): # TODO: make sense of this if port.parent.key in ('pad_source', 'pad_sink'): block = 'self' key = fg.get_pad_port_global_key(port) else: block = 'self.' + port.parent_block.name key = port.key if not key.isdigit(): key = repr(key) return '({block}, {key})'.format(block=block, key=key) connections = fg.get_enabled_connections() # Get the virtual blocks and resolve their connections connection_factory = fg.parent_platform.Connection virtual_source_connections = [ c for c in connections if isinstance(c.source_block, blocks.VirtualSource) ] for connection in virtual_source_connections: sink = connection.sink_port for source in connection.source_port.resolve_virtual_source(): resolved = connection_factory(fg.orignal_flowgraph, source, sink) connections.append(resolved) virtual_connections = [ c for c in connections if (isinstance(c.source_block, blocks.VirtualSource) or isinstance(c.sink_block, blocks.VirtualSink)) ] for connection in virtual_connections: # Remove the virtual connection connections.remove(connection) # Bypassing blocks: Need to find all the enabled connections for the block using # the *connections* object rather than get_connections(). Create new connections # that bypass the selected block and remove the existing ones. This allows adjacent # bypassed blocks to see the newly created connections to downstream blocks, # allowing them to correctly construct bypass connections. bypassed_blocks = fg.get_bypassed_blocks() for block in bypassed_blocks: # Get the upstream connection (off of the sink ports) # Use *connections* not get_connections() source_connection = [ c for c in connections if c.sink_port == block.sinks[0] ] # The source connection should never have more than one element. assert (len(source_connection) == 1) # Get the source of the connection. source_port = source_connection[0].source_port # Loop through all the downstream connections for sink in (c for c in connections if c.source_port == block.sources[0]): if not sink.enabled: # Ignore disabled connections continue connection = connection_factory(fg.orignal_flowgraph, source_port, sink.sink_port) connections.append(connection) # Remove this sink connection connections.remove(sink) # Remove the source connection connections.remove(source_connection[0]) # List of connections where each endpoint is enabled (sorted by domains, block names) def by_domain_and_blocks(c): return c.type, c.source_block.name, c.sink_block.name rendered = [] for con in sorted(connections, key=by_domain_and_blocks): template = templates[con.type] code = template.render(make_port_sig=make_port_sig, source=con.source_port, sink=con.sink_port) rendered.append(code) return rendered
import tempfile import textwrap import time from mako.template import Template from .. import Messages, blocks from ..Constants import TOP_BLOCK_FILE_MODE from .FlowGraphProxy import FlowGraphProxy from ..utils import expr_utils DATA_DIR = os.path.dirname(__file__) PYTHON_TEMPLATE = os.path.join(DATA_DIR, 'flow_graph.py.mako') python_template = Template(filename=PYTHON_TEMPLATE) class TopBlockGenerator(object): def __init__(self, flow_graph, file_path): """ Initialize the top block generator object. Args: flow_graph: the flow graph object file_path: the path to write the file to """ self._flow_graph = FlowGraphProxy(flow_graph) self._generate_options = self._flow_graph.get_option( 'generate_options')
C_TEMPLATE = Template(textwrap.dedent(u"""\ /* Autogenerated file -- do not edit * generated by ${file} * ${copyright} */ #include <string.h> #include <vulkan/vulkan.h> #include <vulkan/vk_android_native_buffer.h> #include <vulkan/vk_layer.h> #include "util/macros.h" #include "vk_enum_to_str.h" % for enum in enums: % if enum.guard: #ifdef ${enum.guard} % endif const char * vk_${enum.name[2:]}_to_str(${enum.name} input) { switch(input) { % for v in sorted(enum.values.keys()): case ${v}: return "${enum.values[v]}"; % endfor default: unreachable("Undefined enum value."); } } % if enum.guard: #endif % endif %endfor size_t vk_structure_type_size(const struct VkBaseInStructure *item) { switch((int)item->sType) { % for struct in structs: % if struct.extension is not None and struct.extension.define is not None: #ifdef ${struct.extension.define} case ${struct.stype}: return sizeof(${struct.name}); #endif % else: case ${struct.stype}: return sizeof(${struct.name}); % endif %endfor case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: return sizeof(VkLayerInstanceCreateInfo); case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: return sizeof(VkLayerDeviceCreateInfo); default: unreachable("Undefined struct type."); } } void vk_load_instance_commands(VkInstance instance, PFN_vkGetInstanceProcAddr gpa, struct vk_instance_dispatch_table *table) { memset(table, 0, sizeof(*table)); table->GetInstanceProcAddr = gpa; % for cmd in commands: % if not cmd.device_entrypoint and cmd.name != 'vkGetInstanceProcAddr': % if cmd.extension is not None and cmd.extension.define is not None: #ifdef ${cmd.extension.define} table->${cmd.name[2:]} = (PFN_${cmd.name}) gpa(instance, "${cmd.name}"); #endif % else: table->${cmd.name[2:]} = (PFN_${cmd.name}) gpa(instance, "${cmd.name}"); % endif % endif %endfor } void vk_load_device_commands(VkDevice device, PFN_vkGetDeviceProcAddr gpa, struct vk_device_dispatch_table *table) { memset(table, 0, sizeof(*table)); table->GetDeviceProcAddr = gpa; % for cmd in commands: % if cmd.device_entrypoint and cmd.name != 'vkGetDeviceProcAddr': % if cmd.extension is not None and cmd.extension.define is not None: #ifdef ${cmd.extension.define} table->${cmd.name[2:]} = (PFN_${cmd.name}) gpa(device, "${cmd.name}"); #endif % else: table->${cmd.name[2:]} = (PFN_${cmd.name}) gpa(device, "${cmd.name}"); % endif % endif %endfor } """), output_encoding='utf-8')
def render_template_to_string(self, template, context): """ Render template to a string using context. """ context.update(self.filters) return Template(template).render(**context)
#!/usr/bin/env python # -*- coding: utf-8 -*- if __name__ == "__main__": from inpho.model import * from mako.template import Template node_q = Session.query(Node) idea_q = Session.query(Idea) thinker_q = Session.query(Thinker) profession_q = Session.query(Profession) nationality_q = Session.query(Nationality) nodes = node_q.all() ideas = idea_q.all() thinkers = thinker_q.all() professions = profession_q.all() nationalities = nationality_q.all() owl = Template(filename='/var/inpho/inphosite/scripts/owl/owl.xml', default_filters=['decode.utf8', 'u', 'x']) print owl.render_unicode(nodes=nodes, thinkers=thinkers, ideas=ideas, professions=professions, nationalities=nationalities).encode( 'utf-8', 'replace') else: raise Exception("Must be called from command line")
print("--- %s seconds ---" % (time.time() - start_time)) if __name__ == "__main__": hostname = socket.gethostname() if args.qsub: with MPICommExecutor(MPI.COMM_WORLD, root=0) as executor: if executor is not None: arrancar_simulacion(executor, cluster_env_var=ENV_VAR, optimize=args.optimize) exit() if 'labomat' in hostname: user = getpass.getuser() ENV_VAR = f'LD_LIBRARY_PATH=/home/{user}/lib64:/home/{user}/usr/lib64:$LD_LIBRARY_PATH /home/{user}/lib64/ld-2.17.so /home/{user}/usr/bin/' os.environ['ELMER_HOME'] = f'/home/{user}/usr/' with open(f'cluster.q', 'w') as text_file: cluster_template = Template(filename='cluster_template.q') cluster = cluster_template.render( workers=8 if args.optimize else 96, opt='-opt' if args.optimize else '' user=user) text_file.write(cluster) subprocess.run('qsub cluster.q') os.remove('cluster.q') else: cpus = 1 if args.optimize else multiprocessing.cpu_count() with ThreadPoolExecutor(max_workers=cpus) as executor: arrancar_simulacion(executor, optimize=args.optimize)
def create_configuration(target): template_path = resource_filename('nikola', 'conf.py.in') conf_template = Template(filename=template_path) conf_path = os.path.join(target, 'conf.py') with io.open(conf_path, 'w+', encoding='utf8') as fd: fd.write(conf_template.render(**prepare_config(SAMPLE_CONF)))
def _build_email_body(self, mako_template_filepath: str, role: UserRoleInWorkspace, content: Content, actor: User) -> str: """ Build an email body and return it as a string :param mako_template_filepath: the absolute path to the mako template to be used for email body building :param role: the role related to user to whom the email must be sent. The role is required (and not the user only) in order to show in the mail why the user receive the notification :param content: the content item related to the notification :param actor: the user at the origin of the action / notification (for example the one who wrote a comment :param config: the global configuration :return: the built email body as string. In case of multipart email, this method must be called one time for text and one time for html """ logger.debug( self, 'Building email content from MAKO template {}'.format( mako_template_filepath)) template = Template(filename=mako_template_filepath) # TODO - D.A. - 2014-11-06 - move this # Import is here for circular import problem import tracim.lib.helpers as helpers dictified_item = Context( CTX.EMAIL_NOTIFICATION, self._global_config.WEBSITE_BASE_URL).toDict(content) dictified_actor = Context(CTX.DEFAULT).toDict(actor) main_title = dictified_item.label content_intro = '' content_text = '' call_to_action_text = '' action = content.get_last_action().id if ActionDescription.COMMENT == action: content_intro = l_( '<span id="content-intro-username">{}</span> added a comment:' ).format(actor.display_name) content_text = content.description call_to_action_text = l_('Answer') elif ActionDescription.CREATION == action: # Default values (if not overriden) content_text = content.description call_to_action_text = l_('View online') if ContentType.Thread == content.type: call_to_action_text = l_('Answer') content_intro = l_( '<span id="content-intro-username">{}</span> started a thread entitled:' ).format(actor.display_name) content_text = '<p id="content-body-intro">{}</p>'.format(content.label) + \ content.get_last_comment_from(actor).description elif ContentType.File == content.type: content_intro = l_( '<span id="content-intro-username">{}</span> added a file entitled:' ).format(actor.display_name) if content.description: content_text = content.description else: content_text = '<span id="content-body-only-title">{}</span>'.format( content.label) elif ContentType.Page == content.type: content_intro = l_( '<span id="content-intro-username">{}</span> added a page entitled:' ).format(actor.display_name) content_text = '<span id="content-body-only-title">{}</span>'.format( content.label) elif ActionDescription.REVISION == action: content_text = content.description call_to_action_text = l_('View online') if ContentType.File == content.type: content_intro = l_( '<span id="content-intro-username">{}</span> uploaded a new revision.' ).format(actor.display_name) content_text = '' elif ContentType.Page == content.type: content_intro = l_( '<span id="content-intro-username">{}</span> updated this page.' ).format(actor.display_name) previous_revision = content.get_previous_revision() title_diff = '' if previous_revision.label != content.label: title_diff = htmldiff(previous_revision.label, content.label) content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \ title_diff + \ htmldiff(previous_revision.description, content.description) elif ContentType.Thread == content.type: content_intro = l_( '<span id="content-intro-username">{}</span> updated the thread description.' ).format(actor.display_name) previous_revision = content.get_previous_revision() title_diff = '' if previous_revision.label != content.label: title_diff = htmldiff(previous_revision.label, content.label) content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \ title_diff + \ htmldiff(previous_revision.description, content.description) # elif ContentType.Thread == content.type: # content_intro = l_('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name) # previous_revision = content.get_previous_revision() # content_text = l_('<p id="content-body-intro">Here is an overview of the changes:</p>')+ \ # htmldiff(previous_revision.description, content.description) elif ActionDescription.EDITION == action: call_to_action_text = l_('View online') if ContentType.File == content.type: content_intro = l_( '<span id="content-intro-username">{}</span> updated the file description.' ).format(actor.display_name) content_text = '<p id="content-body-intro">{}</p>'.format(content.get_label()) + \ content.description elif ActionDescription.STATUS_UPDATE == action: call_to_action_text = l_('View online') intro_user_msg = l_('<span id="content-intro-username">{}</span> ' 'updated the following status:') content_intro = intro_user_msg.format(actor.display_name) intro_body_msg = '<p id="content-body-intro">{}: {}</p>' content_text = intro_body_msg.format( content.get_label(), content.get_status().label, ) if '' == content_intro and content_text == '': # Skip notification, but it's not normal logger.error( self, 'A notification is being sent but no content. ' 'Here are some debug informations: [content_id: {cid}]' '[action: {act}][author: {actor}]'.format( cid=content.content_id, act=action, actor=actor)) raise ValueError('Unexpected empty notification') # Import done here because cyclic import from tracim.config.app_cfg import CFG body_content = template.render( base_url=self._global_config.WEBSITE_BASE_URL, _=l_, h=helpers, user_display_name=role.user.display_name, user_role_label=role.role_as_label(), workspace_label=role.workspace.label, content_intro=content_intro, content_text=content_text, main_title=main_title, call_to_action_text=call_to_action_text, result=DictLikeClass(item=dictified_item, actor=dictified_actor), CFG=CFG.get_instance(), ) return body_content
def template(tmpl): return Template(filename=os.path.join(root, 'setup/templates', tmpl))
def test_import_2(self): t = Template(""" trim this string: ${" some string to trim " | filters.trim} continue\ """, imports=["from mako import filters"]) #print t.code assert t.render().strip()=="trim this string: some string to trim continue"
def test_via_template(self): t = Template("foo", lexer_cls=self._fixture()) self._test_custom_lexer(t)
def test_encode_filter(self): t = Template("""# coding: utf-8 some stuff.... ${x} """, default_filters=['decode.utf8']) #print t.code assert t.render_unicode(x="voix m’a réveillé").strip() == u"some stuff.... voix m’a réveillé"
def test_canuse_builtin_names(self): template = Template(""" exception: ${Exception} id: ${id} """) assert flatten_result(template.render(id='some id', Exception='some exception')) == "exception: some exception id: some id"
def test_basic(self): t = Template(""" ${x | myfilter} """) assert flatten_result(t.render(x="this is x", myfilter=lambda t: "MYFILTER->%s<-MYFILTER" % t)) == "MYFILTER->this is x<-MYFILTER"
def test_global(self): t = Template(""" <%page expression_filter="h"/> ${"<tag>this is html</tag>"} """) assert t.render().strip() == "<tag>this is html</tag>"
import os from mako.template import Template myTemplate = Template(filename='template.html', strict_undefined=True) # The installed gobos picture folder src_dir = "C:/ProgramData/MA Lighting Technologies/grandma/gma2_V_3.9.60/gobos/" # The generated filename. Default into gobo folder genfile = open(src_dir + "./generated.html", "w", encoding='utf8') i = 1 egysor = {1: {'sorszam': 0, 'filename': 'lófasz'}, } for r, d, f in os.walk(src_dir): for file in f: if ".png" in file or ".bmp" in file: filename = os.path.join(r, file) egysor[i] = {'filename': filename} i += 1 genfile.write(myTemplate.render(rows=egysor, mappa=src_dir)) genfile.close()
def test_convert_str(self): """test that string conversion happens in expressions before sending to filters""" t = Template(""" ${x | trim} """) assert flatten_result(t.render(x=5)) == "5"
def render_login_page(data=None): login_template = Template(filename='templates/login.html', ) return login_template.render_unicode()