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'
