def submit(request): params = request.params emailTemplate = Template(filename='relentless/templates/appointmentEmail.mak') outputBuffer = StringIO() contextObject = Context(outputBuffer, params=params) emailTemplate.render_context(contextObject) emailBody = outputBuffer.getvalue() msg = MIMEText(emailBody) # Email a copy of the booking to our email address sender = '*****@*****.**' receivers = ['*****@*****.**'] msg['Subject'] = 'Relentless Cleaning Booking! %s ' %(params['inputAddress']) msg['From'] = sender msg['To'] = '*****@*****.**' server = smtplib.SMTP('smtp.gmail.com:587') username = '******' password = '******' server.ehlo() server.starttls() server.login(username, password) server.sendmail(sender, receivers, msg.as_string()) server.quit() return {'params': params}
def mako_notice(self, fnames): attach = [] path = '' exp_date = date.today() + timedelta(30) exp_date = exp_date.strftime('%B %d, %Y') for fname in fnames: regex_dropdir = re.compile("dropdir/(.*)") r1 = regex_dropdir.search(self.attachDir) dirs = r1.groups() if not path: path = dirs[0] fname[2] = self.fhandling.filesize_notation(fname[1]) fname[3] = urllib2.quote(fname[0].encode('utf-8')) fname[0] = self.fhandling.unicodeConvert(fname[0]) attach.append(fname) EARStemplate = Template(filename='www/EARS.html', input_encoding='utf-8', output_encoding='utf-8', encoding_errors='replace') buf = StringIO() ctx = Context(buf, filepath=path, attachments=attach, deldate=exp_date) try: EARStemplate.render_context(ctx) return buf.getvalue() except: return exceptions.html_error_template().render()
def render_perf_html_report(report_dir): """Generate a simple HTML report for the perf tests.""" template_file = 'tools/run_tests/perf_html_report.template' try: mytemplate = Template(filename=template_file, format_exceptions=True) except NameError: print('Mako template is not installed. Skipping HTML report generation.') return except IOError as e: print('Failed to find the template %s: %s' % (template_file, e)) return resultset = {} for result_file in glob.glob(os.path.join(report_dir, '*.json')): with open(result_file, 'r') as f: scenario_result = json.loads(f.read()) test_case = scenario_result['scenario']['name'] if 'ping_pong' in test_case: latency50 = round(scenario_result['summary']['latency50'], 2) latency99 = round(scenario_result['summary']['latency99'], 2) summary = {'latency50': latency50, 'latency99': latency99} else: summary = {'qps': round(scenario_result['summary']['qps'], 2)} resultset[test_case] = summary args = {'resultset': resultset} html_file_path = os.path.join(report_dir, 'index.html') try: with open(html_file_path, 'w') as output_file: mytemplate.render_context(Context(output_file, **args)) except: print(exceptions.text_error_template().render()) raise
def render(self, template, output_name=None): """ Render the metadata model using a Mako template as the view. The template gets the metadata as an argument, as well as all public attributes from the metadata_helpers module. The output file is encoded with UTF-8. Args: template: path to a Mako template file output_name: path to the output file, or None to use stdout """ buf = StringIO.StringIO() metadata_helpers._context_buf = buf helpers = [(i, getattr(metadata_helpers, i)) for i in dir(metadata_helpers) if not i.startswith('_')] helpers = dict(helpers) lookup = TemplateLookup(directories=[os.getcwd()]) tpl = Template(filename=template, lookup=lookup) ctx = Context(buf, metadata=self.metadata, **helpers) tpl.render_context(ctx) tpl_data = buf.getvalue() metadata_helpers._context_buf = None buf.close() if output_name is None: print tpl_data else: file(output_name, "w").write(tpl_data.encode('utf-8'))
def render_interop_html_report( client_langs, server_langs, test_cases, auth_test_cases, http2_cases, resultset, num_failures, cloud_to_prod, http2_interop): """Generate HTML report for interop tests.""" html_report_dir = 'reports' template_file = os.path.join(html_report_dir, 'interop_html_report.template') try: mytemplate = Template(filename=template_file, format_exceptions=True) except NameError: print 'Mako template is not installed. Skipping HTML report generation.' return except IOError as e: print 'Failed to find the template %s: %s' % (template_file, e) return sorted_test_cases = sorted(test_cases) sorted_auth_test_cases = sorted(auth_test_cases) sorted_http2_cases = sorted(http2_cases) sorted_client_langs = sorted(client_langs) sorted_server_langs = sorted(server_langs) args = {'client_langs': sorted_client_langs, 'server_langs': sorted_server_langs, 'test_cases': sorted_test_cases, 'auth_test_cases': sorted_auth_test_cases, 'http2_cases': sorted_http2_cases, 'resultset': resultset, 'num_failures': num_failures, 'cloud_to_prod': cloud_to_prod, 'http2_interop': http2_interop} html_file_path = os.path.join(html_report_dir, 'index.html') with open(html_file_path, 'w') as output_file: mytemplate.render_context(Context(output_file, **args))
def to_markdown(self): template = Template(filename='pyzeef/markdown_template.md') buf = StringIO() context_dict = {'page': self} context = Context(buf, **context_dict) template.render_context(context) return buf.getvalue().encode('utf-8')
def executeTemplate(self, name): """execeute a single template with the data, return the output buffer""" tmplType = self.cfg[name].get('type', 'mako') if tmplType == 'mako': self.logger.debug('GEN | calling mako template') tLookup = TemplateLookup(directories=[self.getTemplateFolder()]) template = Template("""<%%include file="%s"/>""" % self.cfg[name].get('topFile'), lookup=tLookup, strict_undefined=True) buf = StringIO() ctx = Context(buf, d=self.data, systemCfg=self.controller.systemCfg, generatorCfg=self.cfg, logger=self.logger) template.render_context(ctx) buf.flush() buf.seek(0) return buf elif tmplType == 'jinja2': self.logger.debug('GEN | calling jinja2 template') env = Environment( loader=FileSystemLoader(self.getTemplateFolder())) template = env.get_template(self.cfg[name].get('topFile')) ns = {'d': self.data} ns['systemCfg'] = self.controller.systemCfg ns['generatorCfg'] = self.cfg ns['logger'] = self.logger tmp = template.render(ns) buf = StringIO(tmp) return (buf) else: raise Exception('Unknown template system: ' + tmplType)
def make_config(self, cmdfile, paramfile): '''Docstring''' self.logger.info("\tWriting:%s" % paramfile) cmdblank = Template(filename=cmdfile, input_encoding='utf-8', output_encoding='utf-8') buf = StringIO() stri = 'Context(buf,' for key in self.config['wwm']: if self.config['wwm'][key] is True: ss = "'T'" elif self.config['wwm'][key] is False: ss = "'F'" else: ss = self.config['wwm'][key] if type(ss) != int and type(ss) != float: ss = '"' + ss + '"' stri = stri + key + '=' + str(ss) + ',' stri = stri[0:-1] + ')' ctx = eval(stri.encode('utf-8')) try: cmdblank.render_context(ctx) except: self.logger.info(exceptions.text_error_template().render()) a = open(paramfile, 'w') a.write(buf.getvalue()) a.close()
class Serializer(object): def __init__(self, outputPath, templateName): super(Serializer, self).__init__() self.outputPath = outputPath self.templateName = templateName fileutil.writeStringToFile("", self.outputPath) tmplResource = datamanager.findResourceByLabel(self.templateName) tmplContent = unicode(tmplResource.description()) self.tmpl = Template(tmplContent) self.mapper = util.createDictFromResourceDescription("BibtexOntologyMapper") def serialize(self, resource): buf = StringIO() gresource = NepomukResource(resource) ctx = Context(buf, resource=gresource, mapper=self.mapper) self.tmpl.render_context(ctx) fileutil.appendStringToFile(buf.getvalue(), self.outputPath) def queryNextReadySlot(self, query): node = query.binding("r"); resource = Nepomuk.Resource(node.uri()) self.serialize(resource) query.next() def queryFinishedSlot(self): pass def setQuery(self, query): self.query = query
def lineage_report(template, command, time, today, data, report_stem, lineage, flight_figure, import_report, raw_data_csv): mytemplate = Template(filename=template) buf = StringIO() import_data = parse_import_data(import_report) raw_data = parse_raw_data(raw_data_csv) ctx = Context(buf, command=command, timestamp=time, date=today, version=__version__, summary_data=data, lineage_data=[lineage], flight_figure=flight_figure, import_report=import_data, raw_data=raw_data) try: mytemplate.render_context(ctx) except: traceback = RichTraceback() for (filename, lineno, function, line) in traceback.traceback: print("File %s, line %s, in %s" % (filename, lineno, function)) print(line, "\n") print("%s: %s" % (str(traceback.error.__class__.__name__), traceback.error)) with open(f"{report_stem}_{lineage}.html", "w") as fw: fw.write(buf.getvalue())
def render_index(): good_cells = get_good_units() region_list = {'mld':[], 'ov':[], 'l':[], 'cm':[]} #render each unit for u in good_cells[0:28]: uregs = [a.name for a in u.recsite.areas] reg = 'l' if 'MLd' in uregs: reg = 'mld' elif 'CM' in uregs: reg = 'cm' elif 'OV' in uregs: reg = 'ov' region_list[reg].append(u) main_file = os.path.join(MAKO_DIR, 'index.html') output_file = os.path.join(OUTPUT_DIR, 'index.html') tpl = Template(filename=main_file) #render main index f = open(output_file, 'w') ctx = Context(f, region_list=region_list) tpl.render_context(ctx) f.close()
def render(self, template, output_name=None): """ Render the metadata model using a Mako template as the view. The template gets the metadata as an argument, as well as all public attributes from the metadata_helpers module. Args: template: path to a Mako template file output_name: path to the output file, or None to use stdout """ buf = StringIO.StringIO() metadata_helpers._context_buf = buf helpers = [(i, getattr(metadata_helpers, i)) for i in dir(metadata_helpers) if not i.startswith('_')] helpers = dict(helpers) lookup = TemplateLookup(directories=[os.getcwd()]) tpl = Template(filename=template, lookup=lookup) ctx = Context(buf, metadata=self.metadata, **helpers) tpl.render_context(ctx) tpl_data = buf.getvalue() metadata_helpers._context_buf = None buf.close() if output_name is None: print tpl_data else: file(output_name, "w").write(tpl_data)
def writeTemplate(tmplFileName, outFileName, namespace={}, encodeAsUTF8=True, errorHandler=lambda ctx, msg: False): if os.access(outFileName, os.F_OK): os.chmod(outFileName, stat.S_IWRITE or stat.S_IREAD) os.unlink(outFileName) buf = StringIO.StringIO() ctx = Context(buf, **namespace) print tmplFileName.upper() try: tobj = Template(text=pkgutil.get_data( 'kosek', 'config/templates/%s' % tmplFileName), output_encoding='utf-8', format_exceptions=True, error_handler=errorHandler) tobj.render_context(ctx) except Exception as e: print str(e) print exceptions.text_error_template().render() raise #return None else: outFile = open(outFileName, mode='wt') outFile.write(buf.getvalue())
def make_config(self, cmdfile,paramfile,module): '''Docstring''' self.logger.info("\tWriting:%s" %paramfile) cmdblank = Template(filename=cmdfile,input_encoding='utf-8',output_encoding='utf-8') buf = StringIO() stri='Context(buf,' for key in self.config[module]: stri=stri+key+'='+str(self.config[module][key])+',' stri=stri[0:-1]+')' ctx = eval(stri.encode('utf-8')) #cmdblank.render_context(ctx) try: cmdblank.render_context(ctx) except: self.logger.info(exceptions.text_error_template().render()) a=open(paramfile,'w') a.write(buf.getvalue()) a.close()
def zwolnienie_edit(request, pk): doc = get_object_or_404(Docs, id=pk) if request.method == "POST": form = DocsForm(request.POST, instance=doc) if form.is_valid(): doc = form.save(commit=False) doc.publication_date = timezone.now() doc.form_type = 1 doc.save() mytemplate = Template( filename='Documents/html&css/zwolnienie.mako') buf = StringIO() ctx = Context(buf, **request.POST) mytemplate.render_context(ctx) # '/tmp/' response = HttpResponse(content_type='application/pdf') response[ 'Content-Disposition'] = 'attachment; filename="zwolnienie indywidualne.pdf"' html = HTML(string=buf.getvalue()) html.write_pdf(response, stylesheets=[CSS('Documents/html&css/style.css')]) return response else: form = DocsForm(instance=doc) return render(request, 'documents/zwolnienie_edit.html', {'form': form})
def patron_new(request): if request.method == "POST": form = DocsForm(request.POST) if form.is_valid(): doc = form.save(commit=False) doc.publication_date = timezone.now() doc.form_type = 2 doc.save() mytemplate = Template(filename='Documents/html&css/patron.mako') buf = StringIO() ctx = Context(buf, **request.POST) mytemplate.render_context(ctx) response = HttpResponse(content_type='application/pdf') response[ 'Content-Disposition'] = 'attachment; filename="Podanie o patronat.pdf"' html = HTML(string=buf.getvalue()) html.write_pdf(response, stylesheets=[CSS('Documents/html&css/style.css')]) return response else: form = DocsForm() return render(request, 'documents/patron_edit.html', {'form': form})
def render_template(destination, **kwargs): """ Renders the Mako template, and writes output file to the specified destination. Args: destination (Path): Location of the output file. **kwargs (dict): Variables to be used in the Mako template. Raises: ERROR: Error log containing information about the line where the exception occurred. Exception: Re-raised Exception coming from Mako template. """ destination.parent.mkdir(parents=True, exist_ok=True) with open(str(destination), 'w', newline='\n', encoding='utf-8') as rst_file: template = Template(filename=str(TEMPLATE_FILE), output_encoding='utf-8', input_encoding='utf-8') try: template.render_context(Context(rst_file, **kwargs)) except Exception as exc: traceback = RichTraceback() logging.error( "Exception raised in Mako template, which will be re-raised after logging line info:" ) logging.error("File %s, line %s, in %s: %r", *traceback.traceback[-1]) raise exc
def render_perf_html_report(report_dir): """Generate a simple HTML report for the perf tests.""" template_file = 'tools/run_tests/perf_html_report.template' try: mytemplate = Template(filename=template_file, format_exceptions=True) except NameError: print( 'Mako template is not installed. Skipping HTML report generation.') return except IOError as e: print('Failed to find the template %s: %s' % (template_file, e)) return resultset = {} for result_file in glob.glob(os.path.join(report_dir, '*.json')): with open(result_file, 'r') as f: scenario_result = json.loads(f.read()) test_case = scenario_result['scenario']['name'] if 'ping_pong' in test_case: latency50 = round(scenario_result['summary']['latency50'], 2) latency99 = round(scenario_result['summary']['latency99'], 2) summary = {'latency50': latency50, 'latency99': latency99} else: summary = {'qps': round(scenario_result['summary']['qps'], 2)} resultset[test_case] = summary args = {'resultset': resultset} html_file_path = os.path.join(report_dir, 'index.html') try: with open(html_file_path, 'w') as output_file: mytemplate.render_context(Context(output_file, **args)) except: print(exceptions.text_error_template().render()) raise
class JavaClassMako(JavaClassFile): def __init__(self, project, java_class, tl_file): super(JavaClassMako, self).__init__(project, java_class) self._template = Template(filename=tl_file, input_encoding='utf-8') self._buf = None @property def class_path(self): return self._project.java_src + CONTEXT.separator + self._java_class.package.replace( '.', CONTEXT.separator) def generator(self): self._buf = StringIO() ctx = Context(self._buf, java_class=self._java_class) self._template.render_context(ctx) pass def write_file(self): if (self._buf is None): return if not os.path.exists(self.class_path): os.makedirs(self.class_path) with open( self.class_path + CONTEXT.separator + self._java_class.file_name, 'w') as f: f.write(self._buf.getvalue()) f.close()
class Serializer(object): def __init__(self, outputPath, templateName): super(Serializer, self).__init__() self.outputPath = outputPath self.templateName = templateName fileutil.writeStringToFile("", self.outputPath) tmplResource = datamanager.findResourceByLabel(self.templateName) tmplContent = unicode(tmplResource.description()) self.tmpl = Template(tmplContent) self.mapper = util.createDictFromResourceDescription( "BibtexOntologyMapper") def serialize(self, resource): buf = StringIO() gresource = NepomukResource(resource) ctx = Context(buf, resource=gresource, mapper=self.mapper) self.tmpl.render_context(ctx) fileutil.appendStringToFile(buf.getvalue(), self.outputPath) def queryNextReadySlot(self, query): node = query.binding("r") resource = Nepomuk.Resource(node.uri()) self.serialize(resource) query.next() def queryFinishedSlot(self): pass def setQuery(self, query): self.query = query
def _makePage(self, template, outfile, **context): myTemplate = Template(filename=template, lookup=myLookup) buf = StringIO() ctx = Context(buf, **context) myTemplate.render_context(ctx) print buf.getvalue() outfile = os.path.join(OUTDIR, outfile) open(outfile, 'w').write(buf.getvalue())
def render(self, page): try: mytemplate = Template(page.templatefile, **self.kwargs) buf = io.StringIO() mytemplate.render_context(Context(buf, **page.context)) return buf.getvalue() except NameError: return ''
def render(self, page): try: mytemplate = Template(page.templatefile, **self.kwargs) buf = io.StringIO() mytemplate.render_context(Context(buf, **page.context)) return buf.getvalue() except NameError: return ""
def run_mako(infile, outfile): # pylint: disable=bad-whitespace context = dict(coffee=coffee_filter, vers=version_filter) lookup = TemplateLookup(directories=['.'], output_encoding='utf-8') template = Template(filename=infile, lookup=lookup, input_encoding='utf-8') with open(outfile, 'w') as output: ctx = Context(output, **context) template.render_context(ctx)
def get_file_overlays(templatefile): t = Template(filename=templatefile) ctx = CaptureContext() t.render_context(ctx) return ctx.get_all_keys()
def build_code_for_ev_blk(component, ev_blk, ev_blk_index, build_data): func_name = "evaluate_event_block_%d" % (ev_blk_index) # ${ev_blk_index} mytemplate = Template(ev_blk_function) buf = StringIO() ctx = Context(buf, ev_blk_index=ev_blk_index, ev_blk=ev_blk, component=component, bd=build_data) mytemplate.render_context(ctx) res = buf.getvalue() + ("\n" * 3) return res, func_name
def render_template(file, ctx, buf): mylookup = TemplateLookup(directories=['./'], output_encoding='utf-8', encoding_errors='replace') mytemplate = Template(filename='./templates/' + file, module_directory='/tmp/mako_modules', lookup=mylookup) mytemplate.render_context(ctx) return (buf.getvalue())
def generator(self, tables:List): # print(type(tables)) if not isinstance(tables, list) : print('sql just support list, get type(%s)' % (type(tables))) return template = Template(filename = path + '/sql.tl', input_encoding='utf-8') self._buf = StringIO() ctx = Context(self._buf, tables = tables) template.render_context(ctx)
def _render(self, template_file, lookup_dirs, properties): # build the template and send back the output mylookup = TemplateLookup(directories=lookup_dirs) t = Template(filename=template_file, lookup=mylookup) buf = StringIO() ctx = Context(buf, c=properties) t.render_context(ctx) return buf.getvalue()
def render(filename): code = Code(filename) annotations = annotate(code) template = Template(filename="templates/annotated.txt") buf = StringIO() ctx = Context(buf, lines=code.lines, annotations=annotations) template.render_context(ctx) return buf.getvalue()
def render_mako_file(template, context): if os.path.isfile(template): template=file(template).read() t=Template(template) buf=StringIO() ctx=Context(buf, **context) t.render_context(ctx) return buf.getvalue() else: return None
def build_api(methods): from loadApi import config template_path = config.get('main', 'template') programming_language = config.get('default', 'languages') tplt = os.path.join(template_path, programming_language, 'api.mako') mytemplate = Template(filename=os.path.join(tplt)) buf = StringIO() ctx = Context(buf, methods=methods) mytemplate.render_context(ctx) return buf.getvalue()
def doTemplateFromText(tmpl, namespace = {}, leftMargin = 0, rightMargin = 80, formatExceptions = True, encoding = 'utf-8'): buf = StringIO() ctx = Context(buf, **namespace) try: tobj = Template(text = tmpl, output_encoding = encoding, format_exceptions = formatExceptions) #, imports ='re' tobj.render_context(ctx) except: print(exceptions.text_error_template().render()) return None return indentText(buf.getvalue(), leftMargin) #, rightMargin)
def main(): argparser = argparse.ArgumentParser( description='CAN driver auto-generation script.') argparser.add_argument('template_file', help='Template file') argparser.add_argument('-s', '--spec', dest='xml_file', required=True, help='Filename of the XML bus specification') argparser.add_argument('-n', '--node', dest='node_name', help='Name of the node for which to generate code') argparser.add_argument('-o', '--out', dest='output', type=argparse.FileType('w'), help='Output file name') args = argparser.parse_args() xml_tree = ET.parse(args.xml_file) root = xml_tree.getroot() messages = dict() nodes = list() for xml_node in root.iter('message'): m = Message(xml_node) messages[m.name] = m for xml_node in root.iter('node'): nodes.append(Node(xml_node, messages)) node = None if args.node_name: for n in nodes: if n.name == args.node_name: node = n bus_name = root.attrib.get('name').lower() if not args.output: buf = StringIO() else: buf = args.output ctx = Context(buf, xml_root=root, node=node, bus_name=bus_name, messages=messages) try: bus_template = Template(filename=args.template_file) bus_template.render_context(ctx) except: print exceptions.text_error_template().render() if not args.output: print buf.getvalue()
def student_view(self, context=None): tpl = Template(filename="multichoice/multichoice/static/html/student_view.html") buf = StringIO() ctx = Context(buf, xblock=self) tpl.render_context(ctx) frag = Fragment(buf.getvalue()) frag.add_css(self.resource_string("static/css/student_view.css")) frag.add_javascript(self.resource_string("static/js/src/student_view.js")) frag.initialize_js('AnswerXBlock') return frag
def doTemplate(tmpl, namespace = {}, leftMargin = 0, rightMargin = 80, formatExceptions = True, encoding = 'utf-8'): buf = StringIO() ctx = Context(buf, **namespace) try: tobj = Template(filename = tmpl, output_encoding = encoding, format_exceptions = formatExceptions) #, imports ='re' # TODO: imports parameter. tobj.render_context(ctx) except: print(exceptions.text_error_template().render()) return None ##return strings.reformat(buf.getvalue(), leftMargin, rightMargin) return buf.getvalue()
def render_template(template: Template, context: Context) -> None: """Render the mako template with given context. Prints an error template to indicate where and what in the template caused the render failure. """ try: template.render_context(context) except: out(exceptions.text_error_template().render()) raise
def _write_prject(self): ## 1.create pom template = Template(filename=path + '/tl/pom/controller.tl', input_encoding='utf-8') buf = StringIO() ctx = Context(buf, package_name=CONTEXT.package, module_name=self._module.name) template.render_context(ctx) with open(self.path + CONTEXT.separator + 'pom.xml', 'w') as f: f.write(buf.getvalue()) f.close()
def render_mako(template, context, fn=None): t = Template(template) if fn: buf = open(fn, 'wb') else: buf = StringIO() ctx = Context(buf, **context) t.render_context(ctx) if fn: buf.close() else: return buf.getvalue()
def test_render(): if len(sys.argv) < 2: print "Missing filename" sys.exit(2) template = Template(filename=sys.argv[1]) buf = StringIO() ctx = TestContext(buf) template.render_context(ctx) print buf.getvalue() sys.exit(0)
def author_view(self, context=None): tpl = Template(filename="multichoice/multichoice/static/html/review_stud_quest.html") buf = StringIO() ctx = Context(buf, xblock=self) tpl.render_context(ctx) frag = Fragment(buf.getvalue()) frag.add_css(self.resource_string("static/css/multichoice.css")) frag.add_css(self.resource_string("static/css/font-awesome.min.css")) frag.add_javascript(self.resource_string("static/js/src/questionnaire_review.js")) frag.initialize_js('MultiChoiceXBlock') return frag
def build_code_for_ev_blk(component, ev_blk, ev_blk_index, build_data): func_name = "evaluate_event_block_%d" % (ev_blk_index) #${ev_blk_index} mytemplate = Template(ev_blk_function) buf = StringIO() ctx = Context(buf, ev_blk_index=ev_blk_index, ev_blk=ev_blk, component=component, bd=build_data) mytemplate.render_context(ctx) res = buf.getvalue() + ('\n' * 3) return res, func_name
def main(): csvfile = open(signals_file, 'r') ctrl_sig_reader = csv.DictReader(csvfile) fields = ctrl_sig_reader.fieldnames ctrl_signals = [] signal_fields = [] ctrl_signal_sizes = {} # Identify control signals needed for field in fields: signal_spec = field.split('[') sig = signal_spec[0] if not sig in ignore_fields: signal = sig.lower() ctrl_signals.append(signal) signal_fields.append(field) if len(signal_spec) == 2: sig_size = int(signal_spec[1].split(':')[0]) + 1 else: sig_size = 1 ctrl_signal_sizes[signal] = sig_size # Identify control signal values for each op ops = [] for op_data in ctrl_sig_reader: op = {} for signal, field in zip(ctrl_signals, signal_fields): data = op_data[field] if data: val = data.replace("[", "").replace("]", "") val_size = len(val) sig_val = '%d\'b%s' % (val_size, val) else: sig_val = '%d\'d0' % ctrl_signal_sizes[signal] op[signal] = sig_val op['name'] = op_data['OP'] op['opcode_hex'] = op_data['OPCODE'] op['opcode'] = int(op['opcode_hex'], 16) ops.append(op) csvfile.close() # Write data to template file from mako.template import Template from mako.runtime import Context control_unit_template = Template(filename=template_file) control_unit_file = open(output_file, 'w') ctx = Context(control_unit_file, ctrl_signals=ctrl_signals, ctrl_signal_sizes=ctrl_signal_sizes, ops=ops) control_unit_template.render_context(ctx) control_unit_file.close()
def _get_mako_tmpl_name(self): if self.mako_tmpl_name: try: mytemplate = Template(self.mako_tmpl_name or '') buf = StringIO() ctx = self._get_mako_context(buf) mytemplate.render_context(ctx) return buf.getvalue() except: _logger.error( _("Error while calculating mako product name: %s") % self.display_name) return self.display_name
def FileGen(self, src, dest): try: tmpl = Template(u''+self.templates[src], input_encoding='utf-8') buf = StringIO() model = self.model ctx = Context(buf, root = model) tmpl.render_context(ctx) hf = codecs.open(self.projectpath + '/' + dest, 'w', encoding='utf-8') hf.write(buf.getvalue()) hf.close() except Exception as e: global message message += e.message
def student_view(self, context=None): tpl = Template( filename="multichoice/multichoice/static/html/student_view.html") buf = StringIO() ctx = Context(buf, xblock=self) tpl.render_context(ctx) frag = Fragment(buf.getvalue()) frag.add_css(self.resource_string("static/css/student_view.css")) frag.add_javascript( self.resource_string("static/js/src/student_view.js")) frag.initialize_js('AnswerXBlock') return frag
class MakoTemplate(object): """ Wraps a mako template, context, and I/O Buffer. """ def __init__(self, template, context=None, buf: StringIO=None): """ Initializes a template relevant data """ # Sets template self._template = None if isinstance(template, str): self._template = Template(template) elif isinstance(template, Template): self._template = Template else: raise TypeError("Invalid template: expected string or Template") # Set internal string buffer self._buffer = buf if buf is None: self._buffer = StringIO() # Set context and context variables context = context if context is not None else {} self._context = Context(self._buffer, **context) @property def buffer(self) -> str: """ Returns contents of string buffer """ return self._buffer.getvalue() def reset_buffer(self): """ Refreshes the internal buffer and resets the context """ self._buffer = StringIO() self._context = Context(self._buffer, **self._context.kwargs) @property def context(self) -> dict: """ Returns a copy of the internal context namespace as a dict """ return self._context.kwargs @context.setter def context(self, new_context: dict): """ Replaces current context with new context and refreshes buffer """ self._buffer = StringIO() self._context = Context(self._buffer, **new_context) def render(self): """ Renders the template to the internal buffer.""" try: self._template.render_context(self._context) except exceptions.MakoException: print(exceptions.text_error_template().render())
def render_interop_html_report( client_langs, server_langs, test_cases, auth_test_cases, http2_cases, resultset, num_failures, cloud_to_prod, http2_interop, ): """Generate HTML report for interop tests.""" template_file = "tools/run_tests/interop_html_report.template" try: mytemplate = Template(filename=template_file, format_exceptions=True) except NameError: print "Mako template is not installed. Skipping HTML report generation." return except IOError as e: print "Failed to find the template %s: %s" % (template_file, e) return sorted_test_cases = sorted(test_cases) sorted_auth_test_cases = sorted(auth_test_cases) sorted_http2_cases = sorted(http2_cases) sorted_client_langs = sorted(client_langs) sorted_server_langs = sorted(server_langs) args = { "client_langs": sorted_client_langs, "server_langs": sorted_server_langs, "test_cases": sorted_test_cases, "auth_test_cases": sorted_auth_test_cases, "http2_cases": sorted_http2_cases, "resultset": resultset, "num_failures": num_failures, "cloud_to_prod": cloud_to_prod, "http2_interop": http2_interop, } html_report_out_dir = "reports" if not os.path.exists(html_report_out_dir): os.mkdir(html_report_out_dir) html_file_path = os.path.join(html_report_out_dir, "index.html") try: with open(html_file_path, "w") as output_file: mytemplate.render_context(Context(output_file, **args)) except: print (exceptions.text_error_template().render()) raise
def FileGenByDiagram(self, src, dest, diagram): global output_text try: tmpl = Template(self.templates[src], input_encoding='utf-8') buf = StringIO() model = diagram ctx = Context(buf, root = model) tmpl.render_context(ctx) #hf = codecs.open(self.projectpath + '/' + dest, 'w', encoding='utf-8') #hf.write(buf.getvalue()) #hf.close() output_text += buf.getvalue() except Exception as e: global message message += e.message
def create_single_pdf(self, cr, uid, ids, data, report_xml, context=None): if context is None: context = {} if report_xml.report_type != 'webkit': return super(WebKitParser,self).create_single_pdf(cr, uid, ids, data, report_xml, context=context) self.report_xml = report_xml self.parser_instance = self.parser(cr, uid, self.name2, context=context) self.pool = pooler.get_pool(cr.dbname) if not context.get('splitbrowse'): objs = self.getObjects(cr, uid, ids, context) else: objs = [] self.parser_instance.localcontext['ids'] = ids self.parser_instance.localcontext['context'] = context self.parser_instance.set_context(objs, data, ids, report_xml.report_type) template = False if report_xml.report_file: path = addons.get_module_resource(report_xml.report_file) if path and os.path.exists(path): template = file(path).read() if self.tmpl: f = file_open(self.tmpl) template = f.read() f.close() if not template: raise osv.except_osv(_('Error!'), _('Webkit Report template not found !')) self.localcontext.update({'lang': context.get('lang')}) self.parser_instance.localcontext.update({'setLang':self.setLang}) self.parser_instance.localcontext.update({'formatLang':self.formatLang}) null, tmpname = tempfile.mkstemp() fileout = codecs.open(tmpname, 'wb', 'utf8') body_mako_tpl = Template(template, input_encoding='utf-8', default_filters=['unicode']) try: mako_ctx = Context(fileout, _=self.translate_call, **self.parser_instance.localcontext) body_mako_tpl.render_context(mako_ctx) fileout.close() except Exception, e: msg = exceptions.text_error_template().render() netsvc.Logger().notifyChannel('Webkit render', netsvc.LOG_ERROR, msg) raise osv.except_osv(_('Webkit render'), msg)
def verify_and_replace_vars(raw_yaml, env_vars): missing_keys = set() matches = config_keys_re.findall(raw_yaml) for key_name in matches: key_name = key_name.strip() if key_name not in env_vars: missing_keys.add(key_name) if missing_keys: raise MissingEnvironmentKeys(missing_keys) buf = StringIO() template = Template(raw_yaml) context = Context(buf, **env_vars) template.render_context(context) rendered = buf.getvalue() return rendered
def build_simulation(component): print "C++ Simulation" print "Component", component ev_blks = utils.separate_integration_blocks(component) build_data = CPPBuildData(component, ev_blks) print ev_blks op_blks = "" func_names = [] for i, ev_blk in enumerate(ev_blks): blk, func_name = build_code_for_ev_blk( component=component, ev_blk=ev_blk, ev_blk_index=i, build_data=build_data ) op_blks = op_blks + blk func_names.append(func_name) mytemplate = Template(solver_function) buf = StringIO() ctx = Context(buf, ev_blk_func_names=func_names, component=component) mytemplate.render_context(ctx) res = buf.getvalue() + ("\n" * 3) data_mgr_txt = DataMgrBuilder(ev_blks=ev_blks, cpp_builddata=build_data, component=component).get_text() op_file = "out1.c" with open(op_file, "w") as fout: fout.write(header1) fout.write(data_mgr_txt) fout.write(header2) fout.write(op_blks) fout.write(res) print "File written to:", op_file print print print # mytemplate = Template("hello world!") # print mytemplate.render() assert False
def renderTemplate( filename=None, text=None, namespace={}, leftMargin=0, rightMargin=80, formatExceptions=True, encoding="utf-8" ): if filename is None and text is None: raise AttributeError("Neither 'filename' nor 'text' specified.") buf = StringIO() ctx = Context(buf, **namespace) try: if filename is not None: tobj = Template( filename=filename, output_encoding=encoding, format_exceptions=formatExceptions ) # , imports ='re' # TODO: imports parameter. elif text is not None: tobj = Template(text=text, output_encoding=encoding, format_exceptions=formatExceptions) # , imports ='re' tobj.render_context(ctx) except: print exceptions.text_error_template().render() return None return strings.reformat(buf.getvalue(), leftMargin, rightMargin)
def render_models_best(unit, score_values): upath = os.path.join(OUTPUT_DIR, 'units', unit.recsite.old_id) ipath = os.path.join(upath, 'images') preproc_types = ['rawspectrogram', 'lyons', 'surprise'] model_types = ['linear', 'sepnl_dists', 'sepnl_spline', 'poisson', 'binomial', 'leglm'] thresholds = [0.0, 0.25, 0.5, 0.75, 1.0] all_data = Struct() all_data.unit = unit all_data.preproc_types = preproc_types all_data.model_types = model_types all_data.model_types_strfs = ['linear', 'poisson', 'binomial', 'leglm'] all_data.model_types_nls = model_types best_models = {} for ptype in preproc_types: best_models[ptype] = {} for mtype in model_types: tvals = score_values[ptype][mtype].keys() svt = score_values[ptype][mtype].values() scores_per_thresh = [s.mean() for s in svt] scores_per_thresh = np.array(scores_per_thresh) bindx = np.argmax(scores_per_thresh) best_thresh = tvals[bindx] prefix = '%s_%s_%0.2f' % (ptype, mtype, best_thresh) s = Struct() s.strf_prefix = os.path.join(ipath, '%s_strf_mean' % prefix) s.nl_prefix = os.path.join(ipath, '%s_nl_mean' % prefix) best_models[ptype][mtype] = s all_data.img = best_models model_template = os.path.join(MAKO_DIR, 'models_best.html') fname = 'models_best.html' model_file = os.path.join(upath, fname) tpl = Template(filename=model_template) f = open(model_file, 'w') ctx = Context(f, all_data=all_data) tpl.render_context(ctx) f.close()
class PageServlet(Servlet): def __init__(self, servletContainer, manifestEntry, sourceChangeCallback): Servlet.__init__(self, servletContainer, None if not manifestEntry else manifestEntry.pattern) self._servletContainer = servletContainer fullServletPath = os.path.abspath(os.path.join(servletContainer.rootDir, manifestEntry.filePath)) templateLookup = TemplateLookup(directories=['/'], module_directory=self.servletContainer.tempDir ) self._makoTemplate = MakoTemplate(filename=fullServletPath, lookup=templateLookup, module_directory=self.servletContainer.tempDir) self._manifestEntry = manifestEntry self._sourceChangeCallback = sourceChangeCallback self._fileWatcher = FileWatcher(fullServletPath, lambda path: self._sourceChangeCallback(self)) self._fileWatcher.start() def __str__(self): return str(self._manifestEntry) def unload(self): self._fileWatcher.stop() @property def manifestEntry(self): return self._manifestEntry @property def servletContainer(self): return self._servletContainer def handleRequest(self, request, response): response.sendResponse(CODE_OK) response.sendHeader(HDR_CONTENT_TYPE, MIME_HTML) self._makoTemplate.render_context(Context(response, request=request, response=response, **self._servletContainer.env)) return True
def writeTemplate(tmplFileName, outFileName, namespace = {}, encodeAsUTF8 = True, errorHandler = lambda ctx, msg: False): if os.access(outFileName, os.F_OK): os.chmod(outFileName, stat.S_IWRITE or stat.S_IREAD) os.unlink(outFileName) buf = StringIO.StringIO() ctx = Context(buf, **namespace) print tmplFileName.upper() try: tobj = Template(text = pkgutil.get_data('kosek', 'config/templates/%s' % tmplFileName), output_encoding = 'utf-8', format_exceptions = False, error_handler = errorHandler ) tobj.render_context(ctx) except Exception as e: print str(e) print exceptions.text_error_template().render() raise #return None else: outFile = open(outFileName, mode='wt') outFile.write(buf.getvalue())
def main(): show_headers() form = cgi.FieldStorage() html_output = StringIO() log_files = utils.get_log_files(LOG_DIR) limit, top_to_bottom, regex, files_to_search = get_user_args(form, log_files) srch_rslt = [] result_count = 0 for file_name in files_to_search: if result_count < limit: # Note we only allow files to be searched if they exist in this dict # Otherwise a user could traverse the filesystem and read in /etc/passwd! file_path = log_files[file_name] for result in utils.grep(regex, file(file_path,'r'), top_to_bottom): if result_count < limit: # This assumes a syslog format (Date hostname program : content) res_split = result.split(file_name, 1) #res = [res[0]].extend(res[1].split(":", 1)) try: srch_rslt.append((res_split[0], file_name, res_split[1])) except: srch_rslt.append((file_name, result)) result_count += 1 else: break else: break ctx = Context(html_output, page_title="FLS",app_name="Funky Log Seer", search_page="index.py", log_results=srch_rslt, file_options=log_files) # Try to lookup the template and to render it using our context try: mylkup = TemplateLookup(directories=['templates/']) mytemp = Template(filename='templates/index.mako', lookup=mylkup) mytemp.render_context(ctx) except: print exceptions.text_error_template().render() # Print the resulting HTML print html_output.getvalue()