def __init__(self, dbtype): loaders = [PackageLoader('dwgenerator', f'sql/{dbtype}')] # Use standard SQL as fallback if not the specific template is implemented. if dbtype != 'standard': loaders.append(PackageLoader('dwgenerator', 'sql/standard')) self.env = Environment( loader=ChoiceLoader(loaders), trim_blocks=True, lstrip_blocks=True, )
def generate(model): parts = [ block for block in model.blocks if block.__class__.__name__ == "PartType" ] for part in parts: part_pl = part.namePiece.partname.lower() + mean_gen_config.PLURAL part_dir = os.path.join(mean_gen_config.GEN_DIR, part_pl) if not os.path.exists(part_dir): os.makedirs(part_dir) env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader(mean_gen_config.TEMPLATES_DIR, '.')) template = env.get_template(TEMPLATE_NAME) rendered = template.render({ 'items': part_pl, 'Items': part_pl.capitalize() }) file_name = os.path.join(part_dir, TEMPLATE_NAME) with open(file_name, "w+") as f: f.write(rendered) print(mean_gen_config.GENERATED_MESSAGE + file_name)
def generate(model): templateLoader = Environment( loader=PackageLoader("templates", TEMPLATE_DIR)) template = templateLoader.get_template(TEMPLATE_NAME) for block in model.blocks: if block.__class__.__name__ == 'PartType': itemName = block.namePiece.partname itemName_pl = itemName + gen_cfg.PLURAL createAction = "create" editAction = "update" deleteAction = "delete" readAction = "read" rendered = template.render({ 'Item': itemName, 'item': itemName.lower(), 'Items': itemName_pl, 'items': itemName_pl.lower(), 'createAction': createAction, 'editAction': editAction, "deleteAction": deleteAction, 'readAction': readAction }) file_path = os.path.join(gen_cfg.GEN_DIR, itemName_pl.lower(), TEMPLATE_DIR) if not os.path.exists(file_path): os.makedirs(file_path) file_name = os.path.join(file_path, itemName_pl.lower() + '.js') with open(file_name, "w+") as f: f.write(rendered) print(gen_cfg.GENERATED_MESSAGE + file_name)
def get_source(self, environment, template): """Get raw template for environment. First attempts to load overriding template then uses template within specified package. For example "package/template.html" """ try: if self._fsl is not None: source = self._fsl.get_source(environment, template) log.info("Loaded Override Template %s" % template) return source except TemplateNotFound: pass try: package_path = split_template_path(template) package = package_path[0] template = "/".join(package_path[1:]) if package not in self._pkgloaders: self._pkgloaders[package] = PackageLoader( package, package_path='/templates', encoding='UTF-8') source = self._pkgloaders[package].get_source( environment, template) log.info("Loaded Package Template %s/%s" % (package, template)) return source except ImportError: raise TemplateNotFound("'importerror' " + package + '/' + template) from None except TemplateNotFound: raise TemplateNotFound(package + '/' + template) from None
def setUp(self): self.jinja_env = Environment(extensions=[ 'jinjitsu.display.DisplayExtension', 'jinja2.ext.WithExtension' ], loader=PackageLoader('tests')) print(self.jinja_env.list_templates())
def get_source(self, environment, template): """Get raw template for environment. First attempts to load overriding template then uses template within specified package. For example "package/template.html" """ with Timer() as elapsed: try: source = self._fsl.get_source(environment, template) log.info("Loaded Override Template %s" % template, timer=elapsed()) return source except TemplateNotFound: pass try: package_path = split_template_path(template) package = package_path[0] template = ".".join(package_path[1:]) if package not in self._pkgloaders: self._pkgloaders[package] = PackageLoader( package, package_path='/templates', encoding='UTF-8') source = self._pkgloaders[package].get_source( environment, template) log.info("Loaded Package Template %s/%s" % (package, template), timer=elapsed()) except ModuleNotFoundError: raise TemplateNotFound(package + '/' + template) from None return source
def generate(model): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("templates", TEMPLATE_DIR)) template = env.get_template(TEMPLATE_NAME) for block in model.blocks: if block.__class__.__name__ == 'PartType': itemName = block.namePiece.partname itemName_pl = itemName + mean_gen_config.PLURAL rendered = template.render({ 'item': itemName.lower(), 'items': itemName_pl.lower() }) file_path = os.path.join(mean_gen_config.GEN_DIR, itemName_pl.lower(), TEMPLATE_DIR) if not os.path.exists(file_path): os.makedirs(file_path) file_name = os.path.join(file_path, itemName_pl.lower() + '.js') with open(file_name, "w+") as f: f.write(rendered) print(mean_gen_config.GENERATED_MESSAGE + file_name)
def generate(model): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("templates", TEMPLATE_DIR)) #dodajemo filter pod nazivom inputType env.filters["inputType"] = filters.inputType template = env.get_template(TEMPLATE_NAME) for block in model.blocks: if block.__class__.__name__ == 'PartType': itemName = block.namePiece.partname itemName_pl = itemName + mean_gen_config.PLURAL props = block.propertiesPiece.properties properties = [ models.Property(prop.name, prop.type, prop.visibility) for prop in props ] item = models.Item(itemName) item.properties = properties rendered = template.render({'items': itemName_pl.lower()}) file_path = os.path.join(mean_gen_config.GEN_DIR, itemName_pl.lower(), TEMPLATE_DIR) if not os.path.exists(file_path): os.makedirs(file_path) file_name = os.path.join(file_path, itemName_pl.lower() + '.css') with open(file_name, "w+") as f: f.write(rendered) print(mean_gen_config.GENERATED_MESSAGE + file_name)
def create_blueprint(self, admin): res = super(OpenERPModelView, self).create_blueprint(admin) loader = ChoiceLoader([ PackageLoader('flask_admin_openerp'), self.blueprint.jinja_loader ]) self.blueprint.jinja_loader = loader return res
def init(argv): ap = ArgumentParser() commandline.standard_argparse_options(ap, default_config='./config/dev.yaml') options = ap.parse_args(argv) config = commandline.config_from_options(options, CONFIG_SCHEMA) app = Application( debug=True, middlewares=[ session_middleware, # csrf_middleware, error_middleware, ]) app['config'] = config setup_jinja(app, loader=PackageLoader('sqli', 'templates'), context_processors=[csrf_processor, auth_user_processor], autoescape=False) setup_database(app) setup_redis(app) setup_routes(app) return app
def generate_environment(): """Generate a common template environment.""" env = Environment( loader=PackageLoader("maro", "cli/project_generator/templates"), trim_blocks=True ) return env
def render_html_report(params): '''Render Jinja2 template of fast_ep report using SHELXC/D/E results.''' env = Environment(loader=PackageLoader('lib.report', 'templates/html')) tmpl = env.get_template('fastep_report.html') html_page = tmpl.render(**params) with open('fastep_report.html', 'wt') as f: f.write(html_page)
def generate(template_name, render_vars): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("app", "generator/templates")) template = env.get_template(template_name) rendered = template.render(render_vars) return rendered
def _render(self, template_filename, context={}): "Helper method" env = Environment( loader=PackageLoader('tests', 'templates'), extensions=[], ) template = env.get_template(template_filename) return template.render(context).strip()
def generate(model): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("templates", TEMPLATE_DIR)) template = env.get_template(TEMPLATE_NAME) env.filters["inputType"] = inputType class Property(object): def __init__(self, name, type): self.name = name self.type = type @property def label(self): return self.name.capitalize() def __str__(self): return self.name + ":" + self.label class Item(object): def __init__(self, name): self.name = name self._properties = [] @property def properties(self): return self._properties @properties.setter def properties(self, value): if not isinstance(value, list): raise TypeError("Properties must be a list!") self._properties = value for block in model.blocks: if block.__class__.__name__ == 'PartType': itemName = block.namePiece.partname itemName_pl = itemName + mean_gen_config.PLURAL props = block.propertiesPiece.properties properties = [Property(prop.name, prop.type) for prop in props] item = Item(itemName) item.properties = properties rendered = template.render({ 'item': item}) file_path = os.path.join(mean_gen_config.GEN_DIR, itemName_pl.lower(), TEMPLATE_DIR) if not os.path.exists(file_path): os.makedirs(file_path) file_name = os.path.join(file_path, TEMPLATE_NAME) with open(file_name, "w+") as f: f.write(rendered) print(mean_gen_config.GENERATED_MESSAGE + file_name)
def render(self): """ Create main LaTex file for guidebook """ #Create LaTex Jinja2 Environment env = make_env(loader=PackageLoader('guidebook')) tmpl = env.get_template('main.tex') #Grab all area information info = {'areas' : [name_chapter(area.name) for area in self.areas]} return tmpl.render(info)
class VhdlTmplContainer(): tmplEnv = Environment( loader=PackageLoader('hwt', 'serializer/vhdl/templates')) architectureTmpl = tmplEnv.get_template('architecture.vhd') entityTmpl = tmplEnv.get_template('entity.vhd') processTmpl = tmplEnv.get_template('process.vhd') componentTmpl = tmplEnv.get_template('component.vhd') componentInstanceTmpl = tmplEnv.get_template('component_instance.vhd') ifTmpl = tmplEnv.get_template('if.vhd') switchTmpl = tmplEnv.get_template('switch.vhd')
def generate(self, template_name, directory, output_name, render_vars): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("generation", "templates")) template = env.get_template(template_name) rendered = template.render(render_vars) path = os.path.join(self.path, directory) if not os.path.exists(path): os.makedirs(path) file_name = os.path.join(path, output_name) with open(file_name, "w+") as f: f.write(rendered)
def generate(template_name, output_name, render_vars): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("generation", "templates")) template = env.get_template(template_name) rendered = template.render(render_vars) print(rendered) #i pisemo u fajl file_name = os.path.join(root, "output", output_name) print(file_name) with open(file_name, "w+") as f: f.write(rendered)
class VerilogTmplContainer(): tmplEnv = Environment( loader=PackageLoader('hwt', 'serializer/verilog/templates')) moduleHeadTmpl = tmplEnv.get_template('module_head.v') moduleBodyTmpl = tmplEnv.get_template('module_body.v') processTmpl = tmplEnv.get_template('process.v') ifTmpl = tmplEnv.get_template("if.v") componentInstanceTmpl = tmplEnv.get_template("component_instance.v") switchTmpl = tmplEnv.get_template("switch.v")
def __init__(self): self.basedir = os.path.dirname(__file__) env = Environment() loader = PackageLoader(__name__, package_path="") self.send_password_recovery_t = loader.load( env, "send_password_recovery.html") # type: Template self.new_member_t = loader.load(env, "new_member.html") # type: Template self.membership_ended_t = loader.load( env, "membership_ended.html") # type: Template
def mail_ticket(ticket_id, fake=False): """ Sends a ticket to the user. """ try: ticket = lookup_ticket_by_id(ticket_id) event = get_event_of_ticket(ticket) order = ticket.ticket_order.order env = Environment(loader=PackageLoader('tickee', 'templates'), extensions=['jinja2.ext.with_']) body = env.get_template('mail_ticket.html')\ .render(ticket=ticket, account=order.account, event=event, order=order, as_guest=False) body_plain = env.get_template('mail_ticket.txt')\ .render(ticket=ticket, account=order.account, event=event, order=order, as_guest=False) # send generated mail blogger.info('sending mail for ticket %s to user %s (%s)' % (ticket.id, ticket.user.id, ticket.user.email)) validate_email(ticket.user.email) if not ticket.user.email: raise ex.OrderError("user has no email.") if not fake: send_email("Tickee Ticketing <*****@*****.**>", ticket.user.email, "Your ticket for '%s' is here!" % event.name, body, body_plain) log_crm("ticket", ticket.id, dict(action="mailed", addressee=ticket.user.email)) transaction.commit() return True except Exception as e: try: email = ticket.user.email except: email = "no mail found." log_crm("ticket", ticket_id, dict(action="mail failed", addressee=email)) transaction.commit() tlogger.exception("failed sending mail for ticket %s: %s" % (ticket_id, e)) return False
def generate(self, template_name, output_name, render_vars, output_dir): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("generated", "templates")) env.filters["typeDef"] = self.typeDef env.filters["annotationdef"] = self.annotationdef env.filters["annotation_attribute_def"] = self.annotation_attribute_def env.tests["checkType"] = self.checkType env.tests["choice"] = self.choice template = env.get_template(template_name) rendered = template.render(render_vars) file_name = os.path.join(output_dir, output_name) print(file_name) with codecs.open(file_name, "w+", "utf-8") as f: f.write(rendered)
def generate(model): env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader(mean_gen_config.TEMPLATES_DIR, mean_gen_config.USERS_TEMPLATE_DIR)) template = env.get_template(TEMPLATE_NAME) rendered = template.render() users_dir = os.path.join(mean_gen_config.GEN_DIR, mean_gen_config.GEN_DIR_USERS) if not os.path.exists(users_dir): os.makedirs(users_dir) file_name = os.path.join(users_dir, TEMPLATE_NAME) with open(file_name, "w+") as f: f.write(rendered) print(mean_gen_config.GENERATED_MESSAGE + mean_gen_config.DEFAULT_USER_GENERATED_MESSAGE + file_name)
def _create_app(self): app = Flask(__name__) app.debug = self.conf.FLASK_DEBUG if not self.conf.STATIC_RESOURCE: raise Exception('STATIC_RESOURCE setting not configured.') if not self.conf.TEMPLATE_RESOURCE: raise Exception('TEMPLATE_RESOURCE setting not configured.') app.wsgi_app = SharedDataMiddleware(app.wsgi_app, { '/': self.conf.STATIC_RESOURCE }) if type(self.conf.TEMPLATE_RESOURCE) == tuple: # package, not filepath app.jinja_loader = PackageLoader(*self.conf.TEMPLATE_RESOURCE) else: app.jinja_loader = FileSystemLoader(self.conf.TEMPLATE_RESOURCE) if self.conf.ALLOW_DEFERREDS: self._enable_deferreds(app) return app
def render(self, main_tex='main.tex'): """ Create LaTex for area Parameters --------- main_tex : str, optional Relative location of main LaTex file. `main.tex` by default """ #Create LaTex Jinja2 Environment env = make_env(loader=PackageLoader('guidebook')) tmpl = env.get_template('area.tex') #Grab all area information info = copy.deepcopy(vars(self)) #Render all contained boulders and add main file location info.update({ 'boulders': [bldr.render() for bldr in self.boulders], 'main_tex': main_tex }) return tmpl.render(info)
def mail_order(order_id, fake=False, as_guest=False, auto_retry=False): """ Sends the mail of the order to the user. """ # fetch information for template try: order = om.lookup_order_by_id(order_id) # generate template env = Environment(loader=PackageLoader('tickee', 'templates'), extensions=['jinja2.ext.with_']) validate_email(order.user.email) if not order.user.email: raise ex.OrderError("user has no email.") if len(order.get_tickets()) == 0: raise ex.TicketError("no tickets found.") # send out a mail per event tickets_per_event = order.get_tickets_per_event() for event in tickets_per_event: tickets = tickets_per_event[event] # send generated mail blogger.info( 'sending mail for "order %s - event %s" to user %s (%s)' % (order_id, event.id, order.user.id, order.user.email)) if not fake: htmlbody = env.get_template('mail_order_of_event.html')\ .render(event=event, tickets=tickets, order=order, as_guest=as_guest, account=order.account) plainbody = env.get_template('mail_order_of_event.txt')\ .render(event=event, tickets=tickets, order=order, as_guest=as_guest, account=order.account) send_email("Tickee Ticketing <*****@*****.**>", order.user.email, "Your tickets for '%s' are here!" % event.name, htmlbody, plainbody) order.meta['tickets_sent'] = datetime.datetime.utcnow().strftime( "%d-%m-%Y %H:%M:%S UTC%z") log_crm("order", order.id, dict(action="mailed", addressee=order.user.email)) transaction.commit() return True except Exception as e: tlogger.exception("failed sending mail for order %s: %s" % (order_id, e)) order.meta['tickets_sent'] = "failed @ %s" % datetime.datetime.utcnow( ).strftime("%d-%m-%Y %H:%M:%S UTC%z") transaction.commit() if auto_retry: mail_order.retry(exc=e) return False
from tickee.db.models.tickettype import TicketTypeEventPartAssociation, \ TicketType from tickee.db.models.user import User from tickee.events.manager import lookup_event_by_id from tickee.orders.states import PURCHASED from tickee.users.manager import lookup_user_by_id from tickee.users.tasks import mail_user import datetime import logging import random import sqlahelper import transaction Session = sqlahelper.get_session() env = Environment(loader=PackageLoader('tickee', 'templates')) blogger = logging.getLogger('blm.events') @task(name="routine.event_in_48_hours_reminder", ignore_result=True) def event_in_48_hours_reminder(): """Looks up all happening in 48 hours and sends notification mails""" # find all events happening between now and 48 hours now = datetime.datetime.utcnow() in_48_hours = now + datetime.timedelta(hours=48) events = Session.query(Event).join(EventPart).filter(EventPart.starts_on >= now)\ .filter(EventPart.starts_on < in_48_hours).all() for event in set(events): # only send if not sent before if not event.meta.get('notifications_sent', False): event_notification.delay(event.id)
class SystemCSerializer(SystemCSerializer_value, SystemCSerializer_type, SystemCSerializer_statements, SystemCSerializer_ops, GenericSerializer): """ Serialized used to convert HWT design to SystemC code """ fileExtension = '.cpp' _keywords_dict = {kw: LangueKeyword() for kw in SYSTEMC_KEYWORDS} env = Environment( loader=PackageLoader('hwt', 'serializer/systemC/templates')) moduleTmpl = env.get_template('module.cpp.template') methodTmpl = env.get_template("method.cpp.template") ifTmpl = env.get_template("if.cpp.template") switchTmpl = env.get_template("switch.cpp.template") @classmethod def getBaseContext(cls): return SystemCCtx(cls.getBaseNameScope(), 0, None, None) @classmethod def comment(cls, comentStr): return "\n".join(["/*", comentStr, "*/"]) @classmethod def PortItem(cls, p, ctx): d = cls.DIRECTION(p.direction) p.name = ctx.scope.checkedName(p.name, p) p.getInternSig().name = p.name if isinstance(p.getInternSig()._interface, Clk): return "sc_%s_clk %s;" % (d, p.name) return "sc_%s<%s> %s;" % (d, cls.HdlType(p._dtype, ctx), p.name) @classmethod def DIRECTION(cls, d): return d.name.lower() @classmethod def Entity(cls, ent, ctx): cls.Entity_prepare(ent, ctx) # [TODO] separate declarations from definitions doc = ent.__doc__ if doc and id(doc) != id(Entity.__doc__): return cls.comment(doc) + "\n" return "" @classmethod def GenericItem(cls, g, ctx): # [TODO] params currently serialized evaluated return "" @classmethod def Architecture_var(cls, v, serializerVars, extraTypes, extraTypes_serialized, ctx, childCtx): """ :return: list of extra discovered processes """ v.name = ctx.scope.checkedName(v.name, v) serializedVar = cls.SignalItem(v, childCtx, declaration=True) serializerVars.append(serializedVar) @classmethod def Architecture(cls, arch, ctx): serializerVars = [] procs = [] extraTypes = set() extraTypes_serialized = [] arch.variables.sort(key=lambda x: (x.name, x._instId)) arch.componentInstances.sort(key=lambda x: x._name) childCtx = ctx.withIndent() ports = [cls.PortItem(pi, childCtx) for pi in arch.entity.ports] extraProcesses = [] for v in arch.variables: cls.Architecture_var(v, serializerVars, extraTypes, extraTypes_serialized, ctx, childCtx) arch.processes.extend(extraProcesses) arch.processes.sort(key=lambda x: (x.name, maxStmId(x))) for p in arch.processes: procs.append(cls.HWProcess(p, childCtx)) # architecture names can be same for different entities # arch.name = scope.checkedName(arch.name, arch, isGlobal=True) processesSensitivity = [] sensitivityCtx = ctx.forSensitivityList() for p in arch.processes: sens = [cls.asHdl(s, sensitivityCtx) for s in p.sensitivityList] processesSensitivity.append((p.name, sens)) return cls.moduleTmpl.render( processesSensitivity=processesSensitivity, name=arch.getEntityName(), ports=ports, signals=serializerVars, extraTypes=extraTypes_serialized, processes=procs, processObjects=arch.processes, componentInstances=arch.componentInstances, DIRECTION=DIRECTION, )
from hwt.hdlObjects.constants import SENSITIVITY from hwt.hdlObjects.statements import IfContainer from hwt.hdlObjects.types.enum import Enum from hwt.hdlObjects.types.enumVal import EnumVal from hwt.hdlObjects.value import Value from hwt.serializer.exceptions import SerializerException from hwt.serializer.nameScope import LangueKeyword, NameScope from hwt.serializer.simModel.value import SimModelSerializer_value from hwt.serializer.simModel.ops import SimModelSerializer_ops from hwt.serializer.simModel.types import SimModelSerializer_types from hwt.serializer.utils import maxStmId from hwt.synthesizer.param import evalParam from hwt.synthesizer.rtlLevel.mainBases import RtlSignalBase from hwt.hdlObjects.types.bits import Bits env = Environment(loader=PackageLoader('hwt', 'serializer/simModel/templates')) unitTmpl = env.get_template('modelCls.py') processTmpl = env.get_template('process.py') ifTmpl = env.get_template("if.py") simCls_reservedWords = [ 'sim', 'self' 'reload', 'vecT', 'Array', 'ArrayVal', 'convertBits__val', 'BitsVal', 'SLICE', 'Enum' 'DIRECTION', 'SENSITIVITY', 'convertSimInteger__val', 'simHInt', 'SIM_INT', 'simBitsT', 'SIM_BIT', 'convertSimBits__val', 'SimModel', 'sensitivity', 'connectSimPort', 'simEvalCond', 'mkUpdater', 'mkArrayUpdater' 'Concat', 'power' 'RtlNetlist' 'SimSignal' 'SliceVal'