def _is_template(template_str):
template_str = to_unicode(template_str)
template = Template(template_str)
try:
return template_str != template.render({})
except exceptions.UndefinedError:
return True
def traits(args):
"""
%prog traits directory
Make HTML page that reports eye and skin color.
"""
p = OptionParser(traits.__doc__)
opts, args = p.parse_args(args)
if len(args) < 1:
sys.exit(not p.print_help())
samples = []
for folder in args:
targets = iglob(folder, "*-traits.json")
if not targets:
continue
filename = targets[0]
js = json.load(open(filename))
js["skin_rgb"] = make_rgb(
js["traits"]["skin-color"]["L"],
js["traits"]["skin-color"]["A"],
js["traits"]["skin-color"]["B"])
js["eye_rgb"] = make_rgb(
js["traits"]["eye-color"]["L"],
js["traits"]["eye-color"]["A"],
js["traits"]["eye-color"]["B"])
samples.append(js)
template = Template(traits_template)
fw = open("report.html", "w")
print >> fw, template.render(samples=samples)
logging.debug("Report written to `{}`".format(fw.name))
fw.close()
def process_dockerfile(self):
"""
Read source dockerfile --> Render with jinja --> Write to outfile
"""
source_dockerfile = self.args["--dockerfile"]
with open(source_dockerfile, "r") as stream:
log.info("Reading source file...")
template = Template(stream.read())
# Update the jinja environment with all custom functions & filters
self._update_env(template.environment)
context = self.config.get("env", {})
log.info("Rendering context")
for k, v in context.items():
log.info(" * %s: %s" % (k, v))
log.info("Rendering Dockerfile...")
out_data = template.render(**context)
log.debug("\n******\nWriting to file\n*******")
log.debug(out_data)
if "--outfile" not in self.args:
log.debug("No --outfile <FILE> was specified. Defaulting to Dockerfile")
self.outfile = "Dockerfile"
else:
self.outfile = self.args['--outfile']
with open(self.outfile, "w") as stream:
log.info("Writing to outfile...")
stream.write(out_data)
def __render(self):
with open(self.template, 'r') as fp:
tmpl = fp.read()
template = Template(tmpl)
rtxt = template.render(clusters = self.clusters)
with open(self.target_path, 'w') as fp:
fp.write(rtxt)
def run_instances(self):
min_count = int(self.querystring.get('MinCount', ['1'])[0])
image_id = self.querystring.get('ImageId')[0]
user_data = self.querystring.get('UserData')
new_reservation = ec2_backend.add_instances(image_id, min_count, user_data)
template = Template(EC2_RUN_INSTANCES)
return template.render(reservation=new_reservation)
def to_python(self):
url = self.ast.left.url
method = self.ast.method.name
params = {}
headers = {}
body = {}
for option in self.ast.right.options if self.ast.right else []:
if isinstance(option.key, QueryStringNode):
if isinstance(option.value, ValueNode):
params[option.key.key] = option.value.value
elif isinstance(option.value, ShellNode):
params[option.key.key] = commands.getstatusoutput(option.value.value)[1]
elif isinstance(option.key, HeaderNode):
headers[option.key.key] = option.value.value
elif isinstance(option.key, BodyNode):
body[option.key.key] = option.value.value
template = Template('Hello {{ name }}!')
template.render(name='John Doe')
return '''
params = {params}
data = {data}
headers = {headers}
requests.{method}('{url}', params=params, data=data, body=body, headers=headers)
'''.format(url=url, method=method.lower(), params=params, data=body, headers=headers)
def format_notification(body):
body['fullname'] = body.get('fullname', body['name'])
NOTIFICATION_TEMPLATE = Template("""Build #{{build.number}} \
{{build.status}} for Job {{fullname}} ({{build.full_url}})
{% if build.scm %}Based on {{build.scm.url}}/commit/{{build.scm.commit}} \
({{build.scm.branch}}){% endif %}""")
return NOTIFICATION_TEMPLATE.render(body)
def create_security_group(self):
name = self.querystring.get('GroupName')[0]
description = self.querystring.get('GroupDescription', [None])[0]
vpc_id = self.querystring.get("VpcId", [None])[0]
group = ec2_backend.create_security_group(name, description, vpc_id=vpc_id)
template = Template(CREATE_SECURITY_GROUP_RESPONSE)
return template.render(group=group)
def renderEq(fname, inline, scale):
#env = Environment(loader=FileSystemLoader('./'))
#template = env.get_template('display_eq.j2')
if inline:
template = Template(INLINE_TEMPLATE)
else:
template = Template(DISPLAY_TEMPLATE)
eq_str = open(fname,'r').read()
print eq_str
out_str = template.render(eq=eq_str[:-1])
print out_str
outfile=open('/var/tmp/eq_render.tex','w')
outfile.write(out_str)
outfile.close()
#def call_latex():
#call latex to convert tex->dvi
subprocess.call(["latex","--output-directory=/var/tmp/","/var/tmp/eq_render.tex"])
#def call_dvi2svg():
#call dvi2svgm to convert dvi->svg
subprocess.call(["dvisvgm","-a","-e","-n","-c"+str(scale)+","+str(scale), "/var/tmp/eq_render.dvi", "--output=eq_render.svg"])
def show(ctx, path, order):
router = Router(open(ctx.obj['CONFIG']))
route = router.match(path)
logging.debug("Matched route: %s" % route)
if not route:
print 'No queries matched'
return
es = Elasticsearch(hosts=route.get('elasticsearch_url'))
request_body = {}
for non_mandatory_key in ['sort', 'query']:
value = route.get(non_mandatory_key)
if value:
request_body[non_mandatory_key] = value
if order == 'asc':
request_body['sort'] = {'@timestamp': 'asc'}
elif order == 'desc':
request_body['sort'] = {'@timestamp': 'desc'}
elif order:
click.echo("Unknown order format: %s" % order, err=True)
return 1
logging.debug("Query: %s" % (request_body,))
result = es.search(index=route.get('index'), doc_type=None, body=request_body)
hits = result['hits']['hits']
template = Template(route.get("format", "{{ __at_timestamp }} {{ message }}"))
for hit in hits:
doc = hit['_source']
doc['__at_timestamp'] = doc.get('@timestamp')
print template.render(doc)
def as_supervisor_program(self):
config = """[program:{{program_name}}]
command = {{cmd}}
directory = {{base_dir}}
autostart = true
autorestart = true
stopsignal = KILL
killasgroup = true
stopasgroup = true
environment = {{env}}
stdout_logfile = {{stdout}}
stderr_logfile = {{stderr}}
"""
env = Template(config)
return env.render({
"program_name" : self.config['name'],
"base_dir" : self.config['base_dir'],
"env" : self.get_env_str(),
"cmd" : self.config['cmd'],
"stdout" : self.config['stdout_file'],
"stderr" : self.config['stderr_file'],
})
def render_container(self, body):
""" Render the "body" HTML inside of a bootstrap container page. """
template = Template("""
<!DOCTYPE html>
<html>
<head><title>Kudu test results</title>
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css" />
<style>
.new-date { border-bottom: 2px solid #666; }
#flaky-rate tr :nth-child(1) { width: 70%; }
/* make sparkline data not show up before loading */
.inlinesparkline { color: #fff; }
/* fix sparkline tooltips */
.jqstooltip {
-webkit-box-sizing: content-box;
-moz-box-sizing: content-box;
box-sizing: content-box;
}
</style>
</head>
<body>
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script src="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-sparklines/2.1.2/jquery.sparkline.min.js"></script>
<div class="container-fluid">
{{ body }}
</div>
</body>
</html>
""")
return template.render(body=body)
def __init__(self, parameter_name):
template = Template(ERROR_RESPONSE)
super(MissingParameterError, self).__init__()
self.description = template.render(
code="Missing Parameter",
message="Missing parameter {0}".format(parameter_name),
)
def generate_index(api=True, single=False, **kwds):
from jinja2 import Template
with open("source/index.rst.template") as f:
t = Template(f.read())
with open("source/index.rst","w") as f:
f.write(t.render(api=api,single=single,**kwds))
def gen_tensorflow_client_string(generated_tensor_data, model_name):
"""
Generate TensorFlow SDK in JavaScript.
Args:
generated_tensor_data: Example is {"keys": [[1.0], [2.0]], "features": [[1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1]]}
"""
code_template = """#!/usr/bin/env node
var request = require("request");
var options = {
uri: "http://127.0.0.1:8500",
method: "POST",
json: {"model_name": "{{ model_name }}", "data": {{ tensor_data }} }
};
request(options, function (error, response, body) {
if (!error && response.statusCode == 200) {
console.log(body)
} else {
console.log(error)
}
});
"""
generated_tensor_data_string = json.dumps(generated_tensor_data)
template = Template(code_template)
generate_code = template.render(
model_name=model_name, tensor_data=generated_tensor_data_string)
logging.debug("Generate the code in JavaScript:\n{}".format(generate_code))
return generate_code
def test_call_with_args(self):
t = Template(
"""{% macro dump_users(users) -%}
<ul>
{%- for user in users -%}
<li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
{%- endfor -%}
</ul>
{%- endmacro -%}
{% call(user) dump_users(list_of_user) -%}
<dl>
<dl>Realname</dl>
<dd>{{ user.realname|e }}</dd>
<dl>Description</dl>
<dd>{{ user.description }}</dd>
</dl>
{% endcall %}"""
)
assert [
x.strip()
for x in t.render(
list_of_user=[{"username": "******", "realname": "something else", "description": "test"}]
).splitlines()
] == [
"<ul><li><p>apo</p><dl>",
"<dl>Realname</dl>",
"<dd>something else</dd>",
"<dl>Description</dl>",
"<dd>test</dd>",
"</dl>",
"</li></ul>",
]
def test_call_with_args(self):
t = Template("""{% macro dump_users(users) -%}
<ul>
{%- for user in users -%}
<li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
{%- endfor -%}
</ul>
{%- endmacro -%}
{% call(user) dump_users(list_of_user) -%}
<dl>
<dl>Realname</dl>
<dd>{{ user.realname|e }}</dd>
<dl>Description</dl>
<dd>{{ user.description }}</dd>
</dl>
{% endcall %}""")
assert [x.strip() for x in t.render(list_of_user=[{
'username':'******',
'realname':'something else',
'description':'test'
}]).splitlines()] == [
'<ul><li><p>apo</p><dl>',
'<dl>Realname</dl>',
'<dd>something else</dd>',
'<dl>Description</dl>',
'<dd>test</dd>',
'</dl>',
'</li></ul>'
]
def construct(self, event):
try:
event["header"][self.key]["template"]
except KeyError:
self.logging.error('Header information event["header"]["%s"]["template"] was expected but not found. Event purged.'%(self.key))
raise
for key in self.header_templates:
try:
template = JinjaTemplate(event["header"][self.key][key])
event["header"][self.key][key] = template.render(**event["data"])
except Exception as err:
self.logging.warning("Failed to convert header key %s. Reason: %s"%(key))
raise
try:
template = self.templates.get_template(event["header"][self.key]["template"])
except Exception as err:
self.logging.error("Template %s does not exist as a file in directory %s."%(event["header"][self.key]["template"], self.location))
raise
else:
try:
event["data"] = template.render(**event["data"])
except Exception as err:
self.logging.error('There was an error processing the template. Reason: %s'%(err))
raise
return event
def main():
db = dataset.connect('sqlite:///reddit.db')
if not os.path.exists('./deploy'):
os.mkdir('./deploy')
def get_items_from_day(date):
return db.query('SELECT title, link, min(rank) as rank, (upvotes - downvotes) as votes, subreddit FROM status ' + \
('JOIN entry ON status.eid=entry.id WHERE rank <= 10 %s GROUP BY eid ORDER BY rank, (upvotes - downvotes) DESC;' % date))
all_items = {}
def process_items_from_day(items):
data = []
for item in filter(lambda item: item['link'] is not None, [item for item in items]):
item = process(item)
if item['link'] not in all_items:
all_items[item['link']] = True
data.append(item)
return data
collections = ['AND observed > date("now", "start of day", "-1 day") AND observed < date("now", "start of day")',
'AND observed > date("now", "start of day", "-2 day") AND observed < date("now", "start of day", "-1 day")',
'AND observed > date("now", "start of day", "-3 day") AND observed < date("now", "start of day", "-2 day")']
collections = [process_items_from_day(get_items_from_day(date)) for date in collections]
with open('./templates/newsletter.html', 'r') as newspaper:
template = Template(newspaper.read())
html = template.render(title="Reddit News Agency", edition=len(os.listdir('./deploy')),
collections=collections).encode('utf-8')
f = open('./deploy/' + str(int(time())) + '.html', 'w')
f.write(html)
requests.post('http://reddit-snews-agency.herokuapp.com/', data=html, headers={
'Authorization': '9f9fa431c64a86da8324bb370d05377bbf49dbf9'
})
def index():
current_time = ctime()
data = open('html/index.html').read()
# new_data = data.replace('@{time}',current_time)
template = Template(data)
result = template.render(name='ying', age='29', time=current_time,user_list=["Ying","Dora","Ericsson","Avaya"],num=1)
return result.encode('utf-8')
def _make_sql_query(self, chunk):
""" Format template and return sql query string """
assert type(chunk) == dict, "Input data is not dictionary!"
sql = """
INSERT INTO
results
(
'filename',
'buee',
'is_cheating'
)
VALUES
{% for val in values.keys() %}
(
"{{val}}",
{{values[val]['buee']}},
{{1 if values[val]['is_cheating'] else 0 }}
){% if not loop.last %},{% endif %}
{%endfor%}
;
"""
template = Template(sql)
template = template.render(values=chunk)
return template
def _get_cluster_services(self, cluster):
"""Return a list of services from a cluster name
"""
services_list = []
if ('vars' in cluster):
try:
j2 = Template(str(cluster['services']))
services_yaml = j2.render(cluster['vars'])
services = yaml.load(services_yaml)
except ValueError:
for l in cluster['vars']:
j2 = Template(str(cluster['services']))
services_yaml = j2.render(l)
services = yaml.load(services_yaml)
cluster['services'] = services
for service in cluster['services']:
service['cluster'] = {}
service['cluster']['images'] = cluster['images']
service['cluster']['name'] = cluster['name']
service['cluster']['hosts'] = cluster.get('hosts')
service['cluster']['vars'] = cluster.get('vars')
services_list.append(service)
return services_list
def list_or_change_tags_for_resource_request(self, request, full_url, headers):
self.setup_class(request, full_url, headers)
parsed_url = urlparse(full_url)
id_ = parsed_url.path.split("/")[-1]
type_ = parsed_url.path.split("/")[-2]
if request.method == "GET":
tags = route53_backend.list_tags_for_resource(id_)
template = Template(LIST_TAGS_FOR_RESOURCE_RESPONSE)
return 200, headers, template.render(
resource_type=type_, resource_id=id_, tags=tags)
if request.method == "POST":
tags = xmltodict.parse(
self.body)['ChangeTagsForResourceRequest']
if 'AddTags' in tags:
tags = tags['AddTags']
elif 'RemoveTagKeys' in tags:
tags = tags['RemoveTagKeys']
route53_backend.change_tags_for_resource(id_, tags)
template = Template(CHANGE_TAGS_FOR_RESOURCE_RESPONSE)
return 200, headers, template.render()
def get(self, request,
app_label=None, actor=None,
pk=None, fldname=None, tplname=None, **kw):
if request.method == 'GET':
rpt = requested_actor(app_label, actor)
elem = rpt.get_row_by_pk(None, pk)
if elem is None:
raise http.Http404("%s %s does not exist." % (rpt, pk))
TextFieldTemplate = rt.modules.tinymce.TextFieldTemplate
if tplname:
tft = TextFieldTemplate.objects.get(pk=int(tplname))
if settings.SITE.trusted_templates:
#~ return http.HttpResponse(tft.text)
template = JinjaTemplate(tft.text)
context = dict(request=request,
instance=elem, **rt.modules)
return http.HttpResponse(template.render(**context))
else:
return http.HttpResponse(tft.text)
qs = TextFieldTemplate.objects.all().order_by('name')
templates = []
for obj in qs:
url = dd.plugins.tinymce.build_plain_url(
'templates',
app_label, actor, pk, fldname, str(obj.pk))
templates.append([
str(obj.name), url, str(obj.description)])
js = "var tinyMCETemplateList = %s;" % py2js(templates)
return http.HttpResponse(js, content_type='text/json')
raise http.Http404("Method %r not supported" % request.method)
def health_check_response(self, request, full_url, headers):
self.setup_class(request, full_url, headers)
parsed_url = urlparse(full_url)
method = request.method
if method == "POST":
properties = xmltodict.parse(self.body)['CreateHealthCheckRequest'][
'HealthCheckConfig']
health_check_args = {
"ip_address": properties.get('IPAddress'),
"port": properties.get('Port'),
"type": properties['Type'],
"resource_path": properties.get('ResourcePath'),
"fqdn": properties.get('FullyQualifiedDomainName'),
"search_string": properties.get('SearchString'),
"request_interval": properties.get('RequestInterval'),
"failure_threshold": properties.get('FailureThreshold'),
}
health_check = route53_backend.create_health_check(
health_check_args)
template = Template(CREATE_HEALTH_CHECK_RESPONSE)
return 201, headers, template.render(health_check=health_check)
elif method == "DELETE":
health_check_id = parsed_url.path.split("/")[-1]
route53_backend.delete_health_check(health_check_id)
return 200, headers, DELETE_HEALTH_CHECK_RESPONSE
elif method == "GET":
template = Template(LIST_HEALTH_CHECKS_RESPONSE)
health_checks = route53_backend.get_health_checks()
return 200, headers, template.render(health_checks=health_checks)
def parameters_example(self, template_subfolder, template_name, parameters):
parameters = parameters.copy()
parameters_template_file = os.path.join(
self.repo_root,
"pages_builder/parameters_template.html"
)
parameters_template = Template(
open(parameters_template_file).read()
)
if "title" in parameters:
# title is a parameter reserved for naming the pattern
# in the documentation
parameters.pop("title", None)
presented_parameters = {
key: json.dumps(value, indent=4)
for key, value in parameters.iteritems()
}
return parameters_template.render(
{
"parameters": presented_parameters,
"file": os.path.join("toolkit", template_subfolder, template_name) + ".html"
}
)
def to_tjp(self):
"""overridden to_tjp method
"""
from jinja2 import Template
template = Template(defaults.tjp_vacation_template)
return template.render({'vacation': self})
def list_hosted_zones_by_name_response(self, request, full_url, headers):
self.setup_class(request, full_url, headers)
parsed_url = urlparse(full_url)
query_params = parse_qs(parsed_url.query)
dnsname = query_params.get("dnsname")
if dnsname:
dnsname = dnsname[0] # parse_qs gives us a list, but this parameter doesn't repeat
# return all zones with that name (there can be more than one)
zones = [zone for zone in route53_backend.get_all_hosted_zones() if zone.name == dnsname]
else:
# sort by names, but with domain components reversed
# see http://boto3.readthedocs.io/en/latest/reference/services/route53.html#Route53.Client.list_hosted_zones_by_name
def sort_key(zone):
domains = zone.name.split(".")
if domains[-1] == "":
domains = domains[-1:] + domains[:-1]
return ".".join(reversed(domains))
zones = route53_backend.get_all_hosted_zones()
zones = sorted(zones, key=sort_key)
template = Template(LIST_HOSTED_ZONES_BY_NAME_RESPONSE)
return 200, headers, template.render(zones=zones)
def DrawTransacLinksStr(self, PathList, ForPlugin = False):
URL, TransacPath, ReqPath, ResHeadersPath, ResBodyPath = PathList
template = Template("""
<!-- Start Transactions Links -->
<a href="{{ Transaction_URL }}" class="label label-info" target="_blank">
Site
</a>
<a href="{{ Base_Path }}{{ Transaction_Path }}" class="label" target="_blank">
F
</a>
<a href="{{ Base_Path }}{{ Request_Path }}" class="label" target="_blank">
R
</a>
<a href="{{ Base_Path }}{{ Resource_Headers_Path }}" class="label" target="_blank">
H
</a>
<a href="{{ Base_Path }}{{ Resource_Body_Path }}" class="label" target="_blank">
B
</a>
<!-- End Transactions Links -->
""")
vars = {
"Transaction_URL": URL,
"Transaction_Path": TransacPath,
"Request_Path": ReqPath,
"Resource_Headers_Path": ResHeadersPath ,
"Resource_Body_Path": ResBodyPath,
"Base_Path": "../" if not ForPlugin else "../../../../"
}
return template.render(vars)
def construct_events_page(events):
utc_now = datetime.utcnow().replace(tzinfo=parser.tz.tzutc())
events = deepcopy(events)
events_t = []
for e in events:
if e.get('start_time'):
e['start_time'] = parser.parse(e['start_time'])
e['display_date'] = e['start_time'].strftime('%B %-d, %Y')
if e['start_time'] <= utc_now:
events_t.append(e)
events_t.sort(key=lambda x: x['start_time'], reverse=True)
events = events_t
with open('templates/feed.j2') as f:
template = Template(f.read())
for event in events:
for image in event.get('photos', []):
if image.get('url_small'):
suffix = '_small'
else:
suffix = ''
image['url'] = path.join(
'/feed/images',
image['id'] + suffix + '.jpg',
)
return template.render(events=events)
def generateFile(filename, mid):
myFields = []
packetTypeUnique = []
totalPacketSize = 0
currFieldPos = 0
for myType in soup.find_all('mtype', id=mid):
var = myType['typeuniq'].split('=')[0].replace(
".", "_").encode('ascii').strip()
val = int(myType['typeuniq'].split('=')[1].replace(
".", "_").encode('ascii'))
packetTypeUnique.append((var, val))
currPacketSize = 0
for myField in myType.find_all('mfield'):
#only include the field if its byte location has not been specified by another field:
if myField.msize.contents[0].split(';')[
0] != 'unspecified' and myField.msize.contents[0].split(
';')[0] != '0' and len(
myField.mvalue.contents
) > 0 and myField.mvalue.contents[0].split(
';')[0] != 'unspecified':
totalPacketSize += int(myField.msize.contents[0].split(';')[0])
#fix up the mname field:
mname = myField.mname.contents[0].split(';')[0].replace(
"(", "").replace(")", "").replace(" ",
"_").replace(".", "_")
#fix up the vocab field to work with C++ (hex bytes)
mvalue = ""
mvalueItem = myField.mvalue.contents[0].split(';')[0]
if mvalueItem.strip() != ';' and mvalueItem.strip() != '':
if myField.msize.contents[0].split(
';')[0] == '1' or myField.msize.contents[0].split(
';'
)[0] == '2' or myField.msize.contents[0].split(
';')[0] == '4' or myField.msize.contents[
0].split(';')[0] == '8':
mvalue = "0x" + mvalueItem
else:
mvalueItem = mvalueItem.decode("hex")
mvalue = ''.join(
["0x%02X " % ord(x) for x in mvalueItem]).strip()
if int(myField.mpos.contents[0].split(';')
[0]) == currFieldPos or len(myFields) == 0:
#print 'NEW: adding new',myField.mname.contents[0].split(';')[0].replace("(","").replace(")","").replace(" ","_").replace(".","_")
myFields.append(
(myType['id'], mname,
myField.msize.contents[0].split(';')[0],
myField.mentropy.contents[0].split(';')[0], mvalue,
myField.mpos.contents[0].split(';')[0]))
currFieldPos = int(
myField.mpos.contents[0].split(';')[0]) + int(
myField.msize.contents[0].split(';')[0])
elif int(
myField.mpos.contents[0].split(';')[0]) < currFieldPos:
#print 'LESS: found pos less than existing: ',myField.mname.contents[0].split(';')[0].replace("(","").replace(")","").replace(" ","_").replace(".","_")
#print "TEST: ", myField.msize.contents[0].split(';')[0],'>',int(myFields[-1][2])
if int(myField.msize.contents[0].split(';')[0]) > int(
myFields[-1][2]):
#print 'RES: replacing because curr is sample pos and bigger than previous'
#print 'before:',myFields[-1]
rpId = myType['id']
rpName = mname.split(';')[0]
rpSize = myField.msize.contents[0].split(';')[0]
rpEnt = myField.mentropy.contents[0].split(';')[0]
rpVal = calcStrOr(
myFields[-1][4], int(myFields[-1][2]),
myField.mvalue.contents[0].split(';')[0],
int(rpSize))
rpPos = myField.mpos.contents[0].split(';')[0]
myFields[-1] = (rpId, rpName, rpSize, rpEnt, rpVal,
rpPos)
currFieldPos = int(rpPos) + int(rpSize)
#print 'after:',myFields[-1]
else:
{} #print 'RES: not bigger'
else:
{
} #print 'IGNORED:',myField.mname.contents[0].split(';')[0].replace("(","").replace(")","").replace(" ","_").replace(".","_")'
hFile = Template('''
#ifndef {{jinjaModelName|upper}}_H
#define {{jinjaModelName|upper}}_H
#include "ns3/application.h"
#include "ns3/traced-callback.h"
#include "ns3/nstime.h"
#include "ns3/average.h"
#include "ns3/simulator.h"
#include <map>
#include "{{jinjaModelName}}-PacketFactory.h"
#include "ns3/{{jinjaModelName}}Grammar.h"
namespace ns3 {
class Socket;
/**
* \\ingroup applications
* \\defgroup {{jinjaModelName}} {{jinjaModelName}}
*/
/**
* \\ingroup {{jinjaModelName}}
* \\brief {{jinjaTodo}}
*
* Note: {{jinjaTodo}}
*/
class {{jinjaModelName}} : public Application
{
public:
/**
* \\brief Get the type ID.
* \\return the object TypeId
*/
static TypeId GetTypeId (void);
/**
* create a {{jinjaTodo}}
*/
{{jinjaModelName}} ();
virtual ~{{jinjaModelName}} ();
private:
// inherited from Application base class.
virtual void StartApplication (void);
virtual void StopApplication (void);
virtual void DoDispose (void);
/**
* \\brief Return the application ID in the node.
* \\returns the application id
*/
uint32_t GetApplicationId (void) const;
/**
* \\brief Receive an {{todo}}
* \\param socket the receiving socket
*
* This function is called by lower layers through a callback.
*/
void Receive (Ptr<Socket> socket);
/**
* \\brief {{jinjaTodo}}
*/
void Send ();
/// Remote address
Ipv4Address m_remote;
/// Wait interval seconds between sending each packet
Time m_interval;
/**
* Specifies the number of data bytes to be sent.
*/
uint32_t m_size;
/// The socket we send packets from
Ptr<Socket> m_socket;
/// ICMP ECHO sequence number
uint16_t m_seq;
/// TracedCallback for RTT measured by ICMP ECHOs
TracedCallback<Time> m_traceRtt;
/// produce extended output if true
bool m_verbose;
/// received packets counter
uint32_t m_recv;
/// Start time (when packet was sent)
Time m_started;
/// Average rtt is ms
Average<double> m_avgRtt;
/// Next packet will be sent
EventId m_next;
/// All sent but not answered packets. Map icmp seqno -> when sent
std::map<uint16_t, Time> m_sent;
/// Grammar state machine associated with the model
StateMachine *sm;
/// will instantiate communication if true
bool m_instantiator;
/// id associated with this model instance
uint32_t m_id;
};
} // namespace ns3
#endif /* {{jinjaModelName|upper}}_H */
''')
ofile = open(filename, 'w')
ofile.write(
hFile.render(jinjaPacketTypes=mid,
jinjaModelName=modelName,
jinjaFieldNames=myFields,
todo='TODO',
defaultDataType='char')) #'UNKNOWN_DataType'))
from jinja2 import Template
from common import *
template = Template('Hello {{ name }}!')
print template.render(name='John Doe')
def render_str(string,dic={}):
tpl = Template(string)
return tpl.render(dic)
def execute_force_invites(trace_id, body_object, organization_id):
pm_logger = common_utils.begin_logger(trace_id, __name__,
inspect.currentframe())
# parse json
try:
body_object_json = json.loads(body_object)
except Exception as e:
return common_utils.error_exception(MsgConst.ERR_REQUEST_202,
HTTPStatus.BAD_REQUEST, e,
pm_logger, True)
caller_service_name = common_utils.get_value("callerServiceName",
body_object_json, None)
mail_lang = common_utils.get_value("mailLang", body_object_json, None)
mail_address = common_utils.get_value("mailAddress", body_object_json,
None)
authority = common_utils.get_value("authority", body_object_json, None)
# validate param execute invite unregistered
list_error = validate_param_invite_unregistered_user(
trace_id, mail_lang, caller_service_name, mail_address, authority)
if list_error:
return common_utils.error_validate(MsgConst.ERR_REQUEST_201,
HTTPStatus.UNPROCESSABLE_ENTITY,
list_error, pm_logger)
# get list cognito users
try:
list_users = aws_common.get_cognito_user_pools(trace_id, mail_address)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_COGNITO_501,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
if list_users:
return common_utils.error_common(MsgConst.ERR_302, HTTPStatus.CONFLICT,
pm_logger)
# regist Cognito UserPools
temporary_password = ''
pattern = re.compile(CommonConst.FORMAT_PASSWORD_TEMPORARY)
while pattern.match(temporary_password) is None:
temporary_password = common_utils.get_password_temporary(
CommonConst.NUMBER_CHARACTERS_PASSWORD_TEMPORARY)
user_attributes = [{"Name": "email", "Value": mail_address}]
user_name = common_utils.get_uuid4()
message_action = MessageAction.Suppress
try:
aws_common.process_admin_create_user_pools(trace_id, user_name,
user_attributes,
temporary_password,
message_action)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_COGNITO_501,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
# enable confirm email
try:
user_attributes = [{'Name': 'email_verified', 'Value': 'true'}]
aws_common.update_cognito_user_attributes(trace_id, user_name,
user_attributes)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_COGNITO_501,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
# get affiliation
try:
affiliation = pm_affiliation.get_affiliation(user_name,
organization_id)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_402,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
if affiliation and affiliation["InvitationStatus"] != InvitationStatus.Deny:
return common_utils.error_common(MsgConst.ERR_302, HTTPStatus.CONFLICT,
pm_logger)
# get organization
try:
organization = pm_organizations.get_organization(
trace_id, organization_id)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_402,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
if len(organization) == 0:
return common_utils.error_common(MsgConst.ERR_301,
HTTPStatus.NOT_FOUND, pm_logger)
# create affiliation
try:
pm_affiliation.create_affiliation(trace_id, mail_address, user_name,
organization_id, authority,
InvitationStatus.Invited)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_DB_403,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
# Get data affiliation
try:
affiliation_result = pm_affiliation.get_affiliation(
user_name, organization_id, True)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_402,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
# Get data user_attribute
try:
user_attribute = pm_userAttribute.query_key(trace_id)
except PmError as e:
return common_utils.error_exception(MsgConst.ERR_402,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
# S3から通知メール送信設定ファイルを取得します。
try:
config = FileUtils.read_yaml(trace_id, CommonConst.S3_SETTING_BUCKET,
CommonConst.NOTIFY_CONFIG_CIS_RESULT_MAIL)
except PmError as e:
pm_logger.error("メール送信設定ファイルの取得に失敗しました。:s3://{0}/{1}".format(
common_utils.get_environ(CommonConst.S3_SETTING_BUCKET),
CommonConst.NOTIFY_CONFIG_CIS_RESULT_MAIL))
return common_utils.error_exception(MsgConst.ERR_S3_702,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
# メッセージ本文を作成します。
path_file_template = config[
CommonConst.KEY_GET_PATH_FILE_TEMPLATE_USER_INVITE_MAIL.format(
language=mail_lang, serviceName=caller_service_name)]
try:
template_body_mail = FileUtils.read_decode(
trace_id, CommonConst.S3_SETTING_BUCKET, path_file_template)
except PmError as e:
pm_logger.error("招待メール本文テンプレートファイルの取得に失敗しました。:s3://{0}/{1}".format(
common_utils.get_environ(CommonConst.S3_SETTING_BUCKET),
path_file_template))
return common_utils.error_exception(MsgConst.ERR_S3_702,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
# SESで通知メールを送信します。
bcc_addresses = [mail_address]
user_name_sign_in = common_utils.get_value("UserName", user_attribute,
None)
if not user_name_sign_in:
try:
affiliation_sign_in = pm_affiliation.get_affiliation(
trace_id, organization_id)
except PmError as e:
return common_utils.error_exception(
MsgConst.ERR_402, HTTPStatus.INTERNAL_SERVER_ERROR, e,
pm_logger, True)
user_name_sign_in = common_utils.get_value("MailAddress",
affiliation_sign_in, None)
organization_name = common_utils.get_value("OrganizationName",
organization, None)
time_zone = date_utils.get_time_zone_by_language(mail_lang)
time_to_live_date = date_utils.get_current_date() + timedelta(days=6)
time_to_live = date_utils.toString(time_to_live_date,
date_utils.PATTERN_YYYYMMDD_SLASH,
time_zone)
template_body_mail = Template(template_body_mail)
context = {
'mailAddress': mail_address,
'userName': user_name_sign_in,
'organizationName': organization_name,
'temporaryPassword': temporary_password,
'timeToLive': time_to_live
}
body_mail = template_body_mail.render(context)
mail_subject = config[CommonConst.KEY_MAIL_SUBJECT_USER_INVITE.format(
language=mail_lang, serviceName=caller_service_name)]
mail_from = config[CommonConst.KEY_INVITE_MAIL_FROM_SERVICE.format(
serviceName=caller_service_name)]
ses_region = config['ses.region']
try:
aws_common.send_email(user_name, ses_region, mail_from, bcc_addresses,
mail_subject, body_mail)
except PmError as e:
pm_logger.error("通知メール送信に失敗しました。")
return common_utils.error_exception(MsgConst.ERR_SES_801,
HTTPStatus.INTERNAL_SERVER_ERROR,
e, pm_logger, True)
response = common_utils.get_response_by_response_body(
HTTPStatus.CREATED, affiliation_result)
# return data response
return common_utils.response(response, pm_logger)
# -*- coding: utf-8 -*-
"""
根据工具类型, 渲染所需表单"""
from __future__ import unicode_literals
import os
from jinja2 import Environment, PackageLoader, Template
here = os.path.dirname(os.path.abspath(__file__))
basic_form_group_template = Template("""
<div class="form-group" name="{{ ARG_NAME }}" {{ addition_info }}>
{{ form_group_content }}
</div>
""")
class FormViewAdapter(object):
def __init__(self, app, templates_dir='templates'):
if hasattr(app, 'config') and 'APP_NAME' in app.config:
self.name = app.config['APP_NAME']
else:
self.name = app
self.env = Environment(loader=PackageLoader(self.name, templates_dir))
def render_js(self, arg_dict):
"""
Render a js."""
js_list = []
the_word = "kenya"
html_file = open("data-hold/word-" + the_word + ".html", "w", encoding = "utf-8")
body_template = Template(
"""
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>My CA Twitter words</title>
<link rel="stylesheet" href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
</head>
<body>
<section class="container">
<h1>Congress folks who tweeted about "{{ word }}"</h1>
<div class="row">
<div class="col-sm-6">
<h2>Democrats</h2>
{{ d_tweets }}
</div>
<div class="col-sm-6">
<h2>Republicans</h2>
{{ r_tweets }}
</div>
</section>
</body>
</html>
""")
# Documentation on Twitter's embed tweet code:
# https://dev.twitter.com/web/embedded-tweets
embed_tweet = Template("""
from pathlib import Path
from jinja2 import Template
__all__ = ('search_result_template', )
with open(Path('wiki_search/static/search_result.html')) as template:
search_result_template = Template(template.read())
{{ agent }}.sinks.{{ name }}_sink.hdfs.minBlockReplicas = 1
{{ agent }}.sinks.{{ name }}_sink.hdfs.rollInterval = 0
{{ agent }}.sinks.{{ name }}_sink.hdfs.rollSize = 0
{{ agent }}.sinks.{{ name }}_sink.hdfs.rollCount = 0
{{ agent }}.sinks.{{ name }}_sink.hdfs.idleTimeout = 5
{{ agent }}.sinks.{{ name }}_sink.hdfs.filePrefix = %{basename}
{{ agent }}.channels.{{ name }}_ch.type = memory
###############################################################
###############################################################
{% endfor %}
'''
if len(argv) > 1:
config = argv[1]
else:
print('#Set Config File to flume_source_sink.ini')
config = 'conf_template/flume_source_sink.ini'
config_info = RawConfigParser()
config_info.optionxform = str
config_info.read(config)
dirdict = {
name: dict(info)
for name, info in dict(config_info).items() if name != 'DEFAULT'
}
agent = config_info['DEFAULT']['agent']
flume_template = Template(text)
rt = flume_template.render(agent=agent, dirdict=dirdict)
stdout.write(rt)
def Sequential(
input_args: str,
modules: List[Union[Tuple[Callable, str], Callable]],
) -> torch.nn.Module:
r"""An extension of the :class:`torch.nn.Sequential` container in order to
define a sequential GNN model.
Since GNN operators take in multiple input arguments,
:class:`torch_geometric.nn.Sequential` expects both global input
arguments, and function header definitions of individual operators.
If omitted, an intermediate module will operate on the *output* of its
preceding module:
.. code-block:: python
from torch.nn import Linear, ReLU
from torch_geometric.nn import Sequential, GCNConv
model = Sequential('x, edge_index', [
(GCNConv(in_channels, 64), 'x, edge_index -> x'),
ReLU(inplace=True),
(GCNConv(64, 64), 'x, edge_index -> x'),
ReLU(inplace=True),
Linear(64, out_channels),
])
where ``'x, edge_index'`` defines the input arguments of :obj:`model`,
and ``'x, edge_index -> x'`` defines the function header, *i.e.* input
arguments *and* return types, of :class:`~torch_geometric.nn.conv.GCNConv`.
In particular, this also allows to create more sophisticated models,
such as utilizing :class:`~torch_geometric.nn.models.JumpingKnowledge`:
.. code-block:: python
from torch.nn import Linear, ReLU, Dropout
from torch_geometric.nn import Sequential, GCNConv, JumpingKnowledge
from torch_geometric.nn import global_mean_pool
model = Sequential('x, edge_index, batch', [
(Dropout(p=0.5), 'x -> x'),
(GCNConv(dataset.num_features, 64), 'x, edge_index -> x1'),
ReLU(inplace=True),
(GCNConv(64, 64), 'x1, edge_index -> x2'),
ReLU(inplace=True),
(lambda x1, x2: [x1, x2], 'x1, x2 -> xs'),
(JumpingKnowledge("cat", 64, num_layers=2), 'xs -> x'),
(global_mean_pool, 'x, batch -> x'),
Linear(2 * 64, dataset.num_classes),
])
Args:
input_args (str): The input arguments of the model.
modules ([(str, Callable) or Callable]): A list of modules (with
optional function header definitions).
"""
input_args = [x.strip() for x in input_args.split(',')]
# We require the first entry of the input list to define arguments:
assert len(modules) > 0 and isinstance(modules[0], (tuple, list))
# A list holding the callable function and the input and output names:
calls: List[Tuple[Callable, List[str], List[str]]] = []
for module in modules:
if isinstance(module, (tuple, list)) and len(module) >= 2:
module, desc = module[:2]
in_desc, out_desc = parse_desc(desc)
elif isinstance(module, (tuple, list)):
module = module[0]
in_desc = out_desc = calls[-1][2]
else:
in_desc = out_desc = calls[-1][2]
calls.append((module, in_desc, out_desc))
root = os.path.dirname(osp.realpath(__file__))
with open(osp.join(root, 'sequential.jinja'), 'r') as f:
template = Template(f.read())
cls_name = f'Sequential_{uuid1().hex[:6]}'
module_repr = template.render(
cls_name=cls_name,
input_args=input_args,
calls=calls,
)
# Instantiate a class from the rendered module representation.
module = class_from_module_repr(cls_name, module_repr)()
for i, (submodule, _, _) in enumerate(calls):
setattr(module, f'module_{i}', submodule)
return module
def execute_config(self,
target_groups,
log_level=1,
out_file=None,
var_tree={}):
"""
:param target_groups: obtained by parsing the targets file by lib.targets_parser.TargetParser
:param log_level: between 0 - 1
:param out_file: output file path. default (datetime.datetime.now().result.log)
:return:
"""
json_result = []
ordered_group_config = self.config_parser.order(self.config_groups)
#print("ordered groups")
#print(ordered_group_config)
#print("\n\n")
host_tree = {}
if var_tree:
for group in var_tree:
for host in var_tree[group]:
host_tree[host] = var_tree[group][host]
for group_config in ordered_group_config:
execution_devices = []
if group_config["name"].split(":")[0] == "all":
for device_list in target_groups.values():
execution_devices += device_list
else:
execution_devices = target_groups[group_config["name"].split(
":")[0]]
for device in execution_devices:
device_log = ""
result_dict = {
"name": device.get("name", "UNSPECIFIED"),
"ip": device["ip"],
"username": device["username"],
}
conn = BaseConnection(ip=device["ip"],
username=device["username"],
password=device["password"],
hostname=device.get("name", ""))
print("connecting to device {}, ip: {}...".format(
device.get("name", "UNSPECIFIED"), device["ip"]))
try:
conn.connect()
device_shell = conn.get_shell()
except Exception as e:
log_line = "execption {} when connecting to device.".format(
str(e))
print(log_line)
result_dict["success"] = False
result_dict["result"] = log_line
json_result.append(result_dict)
continue
# TODO render CMDs with host variables
# From the (to be created) HostConfigRenderer Class
# replace the below group_config with host_config list returned by the HostConfigRenderer Class
config_template = Template("\n".join(group_config["config"]))
if not var_tree:
config_text = config_template.render()
else:
config_text = config_template.render(
**host_tree.get(device["ip"]))
for cmd in config_text.split("\n"):
print("cmd: {}".format(cmd))
try:
out = conn.shell_exec(device_shell, cmd)
print(out)
device_log += out
except Exception as e:
log_line = "failed to execute <{}> due to execption: {}\nskipping this device".format(
cmd, str(e))
print(log_line)
result_dict["success"] = False
result_dict["result"] = device_log
try:
conn.close()
except:
pass
break
result_dict["result"] = device_log
result_dict["success"] = True
json_result.append(result_dict)
try:
conn.close()
except:
pass
with open(out_file, "w") as log:
for result_dict in json_result:
log.write(
"#############################################################################\n"
)
log.write("DEVICE {}, IP {}, USERNAME {}, SUCCESS {}\n".format(
result_dict["name"], result_dict["ip"],
result_dict["username"], result_dict["success"]))
log.write(result_dict["result"])
return json_result
def get_prop_setter_body(self, attribute):
if attribute.attr_assignment:
template = self.SETTER_TEMPLATE_ASSIGN
else:
template = self.SETTER_TEMPLATE_DEFAULT
return Template(template).render(object=self, trim_blocks=True)
# OMF imports
import omf.feeder as feeder
from omf.solvers import nrelsam2013
import random
from omf.weather import zipCodeToClimateName
# Model metadata:
fileName = os.path.basename(__file__)
modelName = fileName[0:fileName.rfind('.')]
tooltip = "The solarCashflow model allows a utility to calculate what impact member owned solar systems will have on their costs."
# Our HTML template for the interface:
with open(pJoin(__neoMetaModel__._myDir, modelName + ".html"),
"r") as tempFile:
template = Template(tempFile.read())
def work(modelDir, inputDict):
''' Run the model in its directory. '''
inputDict["climateName"], latforpvwatts = zipCodeToClimateName(
inputDict["zipCode"])
shutil.copy(
pJoin(__neoMetaModel__._omfDir, "data", "Climate",
inputDict["climateName"] + ".tmy2"),
pJoin(modelDir, "climate.tmy2"))
# Set up SAM data structures.
ssc = nrelsam2013.SSCAPI()
dat = ssc.ssc_data_create()
# Required user inputs.
ssc.ssc_data_set_string(dat, "file_name", modelDir + "/climate.tmy2")
file.write(hostname)
relay = "{\"host\":\"\",\"username\":\"\",\"password\":\"\",\"port\":\"\"}"
oldRelay = ""
relayChanged = 0
if os.path.exists("/var/nomx/relay"):
with open("/var/nomx/relay", "r") as file:
oldRelay = file.read()
if os.path.exists("/etc/relay.json"):
with open("/etc/relay.json", "r") as file:
relay = file.read()
if relay != oldRelay:
print("[%s] Relay has changed. Updating..." % datetime.datetime.now().isoformat())
with open("/etc/postfix/template.jinja2", "r") as templateFile:
template = Template(templateFile.read())
with open("/etc/postfix/main.cf", "w") as conf:
relayVars = json.loads(relay)
relayVars["serial"] = getserial()
conf.write(template.render(relayVars))
call(["/usr/sbin/service", "postfix", "reload"])
with open("/var/nomx/relay", "w") as file:
file.write(relay)
changed = 0
oldIp = ""
if os.path.exists("/var/nomx/ip"):
with open("/var/nomx/ip", 'r') as file:
oldIp = file.read()
if ip != oldIp:
def render(self):
return Template(self.OBJECT_TEMPLATE).render(object=self)
def read_template_html_file(filename):
content = Template(Path(filename).read_text())
return content
# coding: utf-8
import sys
import os
from jinja2 import Template
template = Template("Your input: {}".format(sys.argv[1] if len(sys.argv) > 1 else '<empty>'))
template.globals['os'] = os
print template.render()
# -*- coding: utf-8 -*-
from jinja2 import Template
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
per = Person("Alex", 33)
tm = Template("Мне {{p.age}} лет ривет {{ p.name }}")
msg = tm.render(p=per)
print(msg)
def process_needfilters(app, doctree, fromdocname):
# Replace all needlist nodes with a list of the collected needs.
# Augment each need with a backlink to the original location.
env = app.builder.env
# NEEDFILTER
for node in doctree.traverse(Needfilter):
if not app.config.needs_include_needs:
# Ok, this is really dirty.
# If we replace a node, docutils checks, if it will not lose any attributes.
# But this is here the case, because we are using the attribute "ids" of a node.
# However, I do not understand, why losing an attribute is such a big deal, so we delete everything
# before docutils claims about it.
for att in ('ids', 'names', 'classes', 'dupnames'):
node[att] = []
node.replace_self([])
continue
id = node.attributes["ids"][0]
current_needfilter = env.need_all_needfilters[id]
all_needs = env.needs_all_needs
if current_needfilter["layout"] == "list":
content = []
elif current_needfilter["layout"] == "diagram":
content = []
try:
if "sphinxcontrib.plantuml" not in app.config.extensions:
raise ImportError
from sphinxcontrib.plantuml import plantuml
except ImportError:
content = nodes.error()
para = nodes.paragraph()
text = nodes.Text("PlantUML is not available!",
"PlantUML is not available!")
para += text
content.append(para)
node.replace_self(content)
continue
plantuml_block_text = ".. plantuml::\n" \
"\n" \
" @startuml" \
" @enduml"
puml_node = plantuml(plantuml_block_text, **dict())
puml_node["uml"] = "@startuml\n"
puml_connections = ""
elif current_needfilter["layout"] == "table":
content = nodes.table()
tgroup = nodes.tgroup()
id_colspec = nodes.colspec(colwidth=5)
title_colspec = nodes.colspec(colwidth=15)
type_colspec = nodes.colspec(colwidth=5)
status_colspec = nodes.colspec(colwidth=5)
links_colspec = nodes.colspec(colwidth=5)
tags_colspec = nodes.colspec(colwidth=5)
tgroup += [
id_colspec, title_colspec, type_colspec, status_colspec,
links_colspec, tags_colspec
]
tgroup += nodes.thead(
'',
nodes.row('', nodes.entry('', nodes.paragraph('', 'ID')),
nodes.entry('', nodes.paragraph('', 'Title')),
nodes.entry('', nodes.paragraph('', 'Type')),
nodes.entry('', nodes.paragraph('', 'Status')),
nodes.entry('', nodes.paragraph('', 'Links')),
nodes.entry('', nodes.paragraph('', 'Tags'))))
tbody = nodes.tbody()
tgroup += tbody
content += tgroup
all_needs = list(all_needs.values())
found_needs = procces_filters(all_needs, current_needfilter)
line_block = nodes.line_block()
for need_info in found_needs:
if current_needfilter["layout"] == "list":
para = nodes.line()
description = "%s: %s" % (need_info["id"], need_info["title"])
if current_needfilter["show_status"] and need_info[
"status"] is not None:
description += " (%s)" % need_info["status"]
if current_needfilter["show_tags"] and need_info[
"tags"] is not None:
description += " [%s]" % "; ".join(need_info["tags"])
title = nodes.Text(description, description)
# Create a reference
if not need_info["hide"]:
ref = nodes.reference('', '')
ref['refdocname'] = need_info['docname']
ref['refuri'] = app.builder.get_relative_uri(
fromdocname, need_info['docname'])
ref['refuri'] += '#' + need_info['target_node']['refid']
ref.append(title)
para += ref
else:
para += title
line_block.append(para)
elif current_needfilter["layout"] == "table":
row = nodes.row()
row += row_col_maker(app,
fromdocname,
env.needs_all_needs,
need_info,
"id",
make_ref=True)
row += row_col_maker(app, fromdocname, env.needs_all_needs,
need_info, "title")
row += row_col_maker(app, fromdocname, env.needs_all_needs,
need_info, "type_name")
row += row_col_maker(app, fromdocname, env.needs_all_needs,
need_info, "status")
row += row_col_maker(app,
fromdocname,
env.needs_all_needs,
need_info,
"links",
ref_lookup=True)
row += row_col_maker(app, fromdocname, env.needs_all_needs,
need_info, "tags")
tbody += row
elif current_needfilter["layout"] == "diagram":
# Link calculation
# All links we can get from docutils functions will be relative.
# But the generated link in the svg will be relative to the svg-file location
# (e.g. server.com/docs/_images/sqwxo499cnq329439dfjne.svg)
# and not to current documentation. Therefore we need to add ../ to get out of the image folder.
try:
link = "../" + app.builder.get_target_uri(need_info['docname']) \
+ "?highlight={0}".format(urlParse(need_info['title'])) \
+ "#" \
+ need_info['target_node']['refid'] \
# Gets mostly called during latex generation
except NoUri:
link = ""
diagram_template = Template(env.config.needs_diagram_template)
node_text = diagram_template.render(**need_info)
puml_node[
"uml"] += '{style} "{node_text}" as {id} [[{link}]] {color}\n'.format(
id=need_info["id"],
node_text=node_text,
link=link,
color=need_info["type_color"],
style=need_info["type_style"])
for link in need_info["links"]:
puml_connections += '{id} --> {link}\n'.format(
id=need_info["id"], link=link)
if current_needfilter["layout"] == "list":
content.append(line_block)
if current_needfilter["layout"] == "diagram":
puml_node["uml"] += puml_connections
# Create a legend
if current_needfilter["show_legend"]:
puml_node["uml"] += "legend\n"
puml_node["uml"] += "|= Color |= Type |\n"
for need in app.config.needs_types:
puml_node[
"uml"] += "|<back:{color}> {color} </back>| {name} |\n".format(
color=need["color"], name=need["title"])
puml_node["uml"] += "endlegend\n"
puml_node["uml"] += "@enduml"
puml_node["incdir"] = os.path.dirname(
current_needfilter["docname"])
puml_node["filename"] = os.path.split(
current_needfilter["docname"])[1] # Needed for plantuml >= 0.9
content.append(puml_node)
if len(content) == 0:
nothing_found = "No needs passed the filters"
para = nodes.line()
nothing_found_node = nodes.Text(nothing_found, nothing_found)
para += nothing_found_node
content.append(para)
if current_needfilter["show_filters"]:
para = nodes.paragraph()
filter_text = "Used filter:"
filter_text += " status(%s)" % " OR ".join(
current_needfilter["status"]) if len(
current_needfilter["status"]) > 0 else ""
if len(current_needfilter["status"]) > 0 and len(
current_needfilter["tags"]) > 0:
filter_text += " AND "
filter_text += " tags(%s)" % " OR ".join(
current_needfilter["tags"]) if len(
current_needfilter["tags"]) > 0 else ""
if (len(current_needfilter["status"]) > 0
or len(current_needfilter["tags"]) > 0) and len(
current_needfilter["types"]) > 0:
filter_text += " AND "
filter_text += " types(%s)" % " OR ".join(
current_needfilter["types"]) if len(
current_needfilter["types"]) > 0 else ""
filter_node = nodes.emphasis(filter_text, filter_text)
para += filter_node
content.append(para)
node.replace_self(content)
def get_olfactory_transduction_kernel(self):
template = Template("""
#include "stdio.h"
#define NUM_OF_NEURON {{num_neurons}}
#define cap 4.299e-3 // capacitance, [4.299e-3nF]
#define cc1lin 1.224 // Ca2+ association rate with CaM, [s^-1]
#define cc2 22.89 // CaCaM dissociation rate into Ca and CaM, [s^-1]
#define ck1lin 12.72 // CaMK activation rate by CaCaM, [s^-1]
#define ck2 0.5564 // CaMK deactivation rate, [s^-1]
#define clmax 1.013 // maximal g of Cl(Ca) channels, [1.013nS]
#define cnmax 1.277 // maximal g of CNG channels, [1.277nS]
#define cx1lin 1.171 // IX activation rate by Ca2+, [s^-1]
#define cx2 16.12 // IX deactivation rate, [s^-1]
#define ef 2.162 // Ca2+ extrusion rate constant by NCX, [s^-1]
#define F 9.649e4 // Faraday's constant, [C/mol]
#define Cvol 4.2191e-7 // ciliary volume, []
// Calculated from Fvol=4.071e-2, table 5
#define gl 4.575 // leak current conductance, [4.575nS]
#define Gtot 1 // total number of G-proteins, [part]
#define hmc1 1.23 // cAMP concentration needed to achieve half-maximal
// activation of the CNG channel, [1.23uM]
#define hmc2 2.604 // Ca2+ concentration needed to achieve half-maximal
// activation of the Cl(Ca) channel, [2.604uM]
#define inf 1.26 // CNG current carried by Ca, [1.26uM*pC^-1]
#define inhmax 1.396 // maximal CNG channel inhibition factor
#define k1 0.02351 // odorant binding rate to receptor, [0.02351(uM*s)^-1]
#define k2 9.915 // G-protein activation rate per bound receptor complex, [s^-1]
#define kI 0.7037 // IX concentration needed to exert a half-maximal
// inhibitory effect (IC_50), [0.7037uM]
#define kinh 0.3901 // aCaMK concentration needed for half-maximal
// inhibition (IC_50) of cAMP production, [0.3901uM]
#define kinhcng 0.8951 // CaCaM concentration needed for half-maximal
// inhibition of the CNG channel, [0.8951uM]
#define n1 1.639 // Hill coeff. of the CNG ch. activation function
#define n2 2.276 // Hill coeff. of the Cl(Ca) ch. activation function
#define nI 3.705 // Steepness of the decreasing sigmoid representing
// IX-mediated inhibition
#define ninh 1.372 // Steepness of the decreasing sigmoid representing
// aCaMK-mediated inhibition of cAMP synthesis
#define ninhcng 1.112 // Steepness of the sigmoid inhcng representing
// the fold increase in K_1/2 of the CNG channel
// as a function of CaCaM concentration
#define pd 10.88 // cAMP molecule degradation rate, [s^-1]
#define r1 6.911 // odorant unbinding rate from receptor, [s^-1]
#define r2 4.055 // G-protein deactivation rate, [s^-1]
#define Rtot 1 // total number of receptor, [part]
#define smax 91.09 // maximal cAMP production rate by adenylyl cyclase
// per aG, [91.09uM/s]
#define vcl -11.16 // ClCa channel reversal potential, [11.16mV]
#define vcng 0.002655 // CNG channel reversal potential, [0.002655mV]
#define vl -69.67 // effective leak reversal potential, [69.67mV]
// state variables: bLR,aG,cAMP,Ca,CaCaM,aCaMK,IX,inhcng,I_cng,I_cl,I_ncx,I_leak, V
__global__ void dougherty_transduction({{type}} dt, {{type}}* Ostim, {{type}} *binding_rate, {{type}} (*state)[13], {{type}} *I)
{
int tid = blockIdx.x * blockDim.x + threadIdx.x;
if(tid < NUM_OF_NEURON){
float a1 = 0;
float a2 = 0;
float a3 = 0;
float a4 = 0;
float a5 = 0;
float a6 = 0;
float a7 = 0;
float b1 = 0;
float b2 = 0;
float b3 = 0;
float b4 = 0;
float b5 = 0;
float b6 = 0;
float b7 = 0;
float D1 = 0;
float D2 = 0;
float D3 = 0;
float D4 = 0;
float D5 = 0;
float D6 = 0;
float D7 = 0;
float bLR = state[tid][0];
float aG = state[tid][1];
float cAMP = state[tid][2];
float Ca = state[tid][3];
float CaCaM = state[tid][4];
float aCaMK = state[tid][5];
float IX = state[tid][6];
float inhcng = state[tid][7];
float I_cng = state[tid][8];
float I_cl = state[tid][9];
float I_ncx = state[tid][10];
float I_leak = state[tid][11];
//float I = 0;
float V = state[tid][12];
//numeric method
//CaCaM = 1e-5;
//inhcng = 1;
a1 = k1*binding_rate[tid]*Ostim[tid] * Rtot;
a2 = k2*bLR * Gtot;
a3 = aG*smax / (1 + powf((aCaMK/kinh),ninh));
a4 = inf*I_cng + cc2*CaCaM;
a5 = cc1lin*Ca;
a6 = ck1lin*CaCaM;
a7 = cx1lin * Ca;
b1 = k1*binding_rate[tid]*Ostim[tid] + r1;
b2 = k2*bLR + r2;
b3 = pd;
b4 = cc1lin + ef/(1 + powf((IX/kI),nI));
b5 = cc2;
b6 = ck2;
b7 = cx2;
D1 = exp(-b1*dt);
D2 = exp(-b2*dt);
D3 = exp(-b3*dt);
D4 = exp(-b4*dt);
D5 = exp(-b5*dt);
D6 = exp(-b6*dt);
D7 = exp(-b7*dt);
// feedback model
state[tid][0] = bLR*D1 + (a1/b1)*(1-D1);
state[tid][1] = aG*D2 + (a2/b2)*(1-D2);
// Kurahashi and Menini Experiment
// Don't forget to comment out a3, b3, D3, cAMP
// if ( i< 40001 || i>50001 )
// a3 = aG[:,i-1]*smax / (1 + (aCaMK[:,i-1]/kinh)**ninh);
// b3 = pd;
// D3 = np.math.exp(-b3*dt);
// cAMP[:,i] = cAMP[:,i-1]*D3 + (a3/b3)*(1-D3);
//
// else
// cAMP[:,i] = 1.5;
// end
state[tid][2] = cAMP*D3 + (a3/b3)*(1-D3);
state[tid][3] = Ca*D4 + (a4/b4)*(1-D4);
state[tid][4] = CaCaM*D5 + (a5/b5)*(1-D5);
state[tid][5] = aCaMK*D6 + (a6/b6)*(1-D6);
state[tid][6] = IX*D7 + (a7/b7)*(1-D7);
// calculate cell currents for the feedback model
state[tid][8] = cnmax * powf(cAMP,n1) /( powf(cAMP,n1)+powf((inhcng*hmc1),n1) ) * ( vcng - V );
state[tid][9] = clmax * powf(Ca,n2) / (powf(Ca,n2) + powf(hmc2,n2)) * (vcl - V);
state[tid][10] = F * Cvol * ef*Ca/( 1+powf((IX/kI),nI) );
state[tid][11] = gl * (vl - V);
// get the membrane voltage
state[tid][12] = V + 1/cap*dt*( I[tid] + I_leak );
I[tid] = (I_cng + I_cl + I_ncx);
// calculate the CNG channel inhibition factor
state[tid][7] = 1 + (inhmax-1)*powf(CaCaM,ninhcng) /(powf(CaCaM,ninhcng) + powf(kinhcng,ninhcng));
}
}
""")
dtype = np.double
scalartype = dtype.type if dtype.__class__ is np.dtype else dtype
#mod = SourceModule( template2.render(num_of_neuron=self.num_neuron), options=["--ptxas-options=-v"])
#mod = SourceModule( template, options=["--ptxas-options=-v"])
self.block = (128, 1, 1)
self.grid = ((self.num_neurons - 1) / 128 + 1, 1)
mod = SourceModule(template.render(type=dtype_to_ctype(dtype),
num_neurons=self.num_neurons),
options=["--ptxas-options=-v"])
func = mod.get_function("dougherty_transduction")
func.prepare([
scalartype, #dt
np.intp, #Ostim/I
np.intp, #binding_rate
np.intp, #state
np.intp
]) #I_drive
return func
"url": url,
"method": api_data["method"],
"api_name": url.replace("/", "_")[1:],
"args": args,
"comment": api_data["title"]
})
return api_info
items = []
for id in getAPIList(projectID=projectID, apiID=apiID, tag=tag):
items.append(getAPIInfo(id))
template = '''
{% for item in items %}
@request(url='{{item['url']}}', method='{{item['method']}}')
def {{item['api_name']}}(self{% for a in item['args']%}, {{a}}{% endfor %}):
"""{{item['comment']}}"""
json = {
{% for args in item['args'] -%}
"{{args}}": {{ args }},
{% endfor -%}
}
return {'json': json, 'headers': self.headers}
{% endfor -%}
'''
# 创建api文档
print(Template(template).render(items=items))
print("总共生成{}个接口".format(len(items)))
sys.exit(1)
# TODO: Generate Volfile based on Volinfo stored in Config map
# For now, Generated Volfile is used in configmap
data = {}
with open(os.path.join(info_dir, "%s.info" % volname)) as f:
data = json.load(f)
content = ""
template_file = os.path.join(
templates_dir,
"%s.brick%s.vol.j2" % (data["type"], os.environ["BRICK_INDEX"]))
with open(template_file) as f:
content = f.read()
tmpl = Template(content)
volfile_id = "%s.%s.%s" % (volname, nodename, brick_path_name)
volfile_path = os.path.join(volfiles_dir, "%s.vol" % volfile_id)
tmpl.stream(**data).dump(volfile_path)
# Start glusterfsd process
server_role = os.environ.get("KADALU_SERVER_ROLE", "glusterfsd")
if server_role == "glusterfsd":
os.execv(
"/usr/sbin/glusterfsd",
[
"/usr/sbin/glusterfsd",
"-N",
"--volfile-id",
match = re.match(r"(.+)Dialect", name)
if not match:
continue
name = match.group(1)
data = parse(Dialect.__doc__)
format = {"name": name, "options": []}
for param in data.params:
if param.arg_name.startswith("descriptor"):
continue
type = param.type_name
text = param.description.capitalize()
name = stringcase.titlecase(param.arg_name.replace("?", ""))
format["options"].append({"name": name, "text": text, "type": type})
formats.append(format)
return formats
# Main
source = os.path.join(docs.SOURCE_DIR, "formats-reference.md")
target_dir = os.path.join(docs.TARGET_DIR, "formats-reference")
target_md = os.path.join(target_dir, "README.md")
os.makedirs(target_dir, exist_ok=True)
formats = get_formats()
with open(source) as file:
template = Template(file.read())
document = template.render(formats=formats)
with open(target_md, "wt") as file:
file.write(document)
class Popup(Element):
"""Create a Popup instance that can be linked to a Layer.
Parameters
----------
html: string or Element
Content of the Popup.
parse_html: bool, default False
True if the popup is a template that needs to the rendered first.
max_width: int, default 300
The maximal width of the popup.
show: bool, default False
True renders the popup open on page load.
sticky: bool, default False
True prevents map and other popup clicks from closing.
"""
_template = Template(u"""
var {{this.get_name()}} = L.popup({maxWidth: '{{this.max_width}}'
{% if this.show or this.sticky %}, autoClose: false{% endif %}
{% if this.sticky %}, closeOnClick: false{% endif %}});
{% for name, element in this.html._children.items() %}
var {{name}} = $('{{element.render(**kwargs).replace('\\n',' ')}}')[0];
{{this.get_name()}}.setContent({{name}});
{% endfor %}
{{this._parent.get_name()}}.bindPopup({{this.get_name()}})
{% if this.show %}.openPopup(){% endif %};
{% for name, element in this.script._children.items() %}
{{element.render()}}
{% endfor %}
""") # noqa
def __init__(self, html=None, parse_html=False, max_width=300, show=False, sticky=False):
super(Popup, self).__init__()
self._name = 'Popup'
self.header = Element()
self.html = Element()
self.script = Element()
self.header._parent = self
self.html._parent = self
self.script._parent = self
script = not parse_html
if isinstance(html, Element):
self.html.add_child(html)
elif isinstance(html, text_type) or isinstance(html, binary_type):
self.html.add_child(Html(text_type(html), script=script))
self.max_width = max_width
self.show = show
self.sticky = sticky
def render(self, **kwargs):
"""Renders the HTML representation of the element."""
for name, child in self._children.items():
child.render(**kwargs)
figure = self.get_root()
assert isinstance(figure, Figure), ('You cannot render this Element '
'if it is not in a Figure.')
figure.script.add_child(Element(
self._template.render(this=self, kwargs=kwargs)),
name=self.get_name())
def get_hhn_kernel(self):
template = Template("""
#define g_Na 120.0
#define g_K 36.0
#define g_L 0.3
#define E_K (-12.0)
#define E_Na 115.0
#define E_L 10.613
__global__ void
hhn_model(int *spk, int num_neurons, {{type}} dt, {{type}}* I_pre, \
{{type}}* X_1, {{type}}* X_2, {{type}}* X_3, {{type}}* g_V, {{type}}* V_prev)
{
int cart_id = blockIdx.x * blockDim.x + threadIdx.x;
if(cart_id < num_neurons)
{
{{type}} V = g_V[cart_id];
{{type}} bias = 10;
spk[cart_id] = 0;
{{type}} a[3];
a[0] = (10-V)/(100*(exp((10-V)/10)-1));
X_1[cart_id] = a[0]*dt - X_1[cart_id]*(dt*(a[0] + exp(-V/80)/8) - 1);
a[1] = (25-V)/(10*(exp((25-V)/10)-1));
X_2[cart_id] = a[1]*dt - X_2[cart_id]*(dt*(a[1] + 4*exp(-V/18)) - 1);
a[2] = 0.07*exp(-V/20);
X_3[cart_id] = a[2]*dt - X_3[cart_id]*(dt*(a[2] + 1/(exp((30-V)/10)+1)) - 1);
V = V + dt * (I_pre[cart_id]+bias - \
(g_K * pow(X_1[cart_id], 4) * (V - E_K) + \
g_Na * pow(X_2[cart_id], 3) * X_3[cart_id] * (V - E_Na) + \
g_L * (V - E_L)));
if(V_prev[cart_id] <= g_V[cart_id] && g_V[cart_id] > V) {
spk[cart_id] = 1;
}
V_prev[cart_id] = g_V[cart_id];
g_V[cart_id] = V;
}
}
""")
dtype = np.double
scalartype = dtype.type if dtype.__class__ is np.dtype else dtype
#hhn_update_block = (128,1,1)
#hhn_update_grid = ((num_neurons - 1) / 128 + 1, 1)
self.block = (128, 1, 1)
self.grid = ((self.num_neurons - 1) / 128 + 1, 1)
mod = SourceModule(template.render(type=dtype_to_ctype(dtype)),
options=["--ptxas-options=-v"])
func = mod.get_function("hhn_model")
func.prepare([
np.intp, # spk
np.int32, # num_neurons
scalartype, # dt
np.intp, # I_pre
np.intp, # X1
np.intp, # X2
np.intp, # X3
np.intp, # g_V
np.intp
]) # V_pre
return func
# Read in the command_sets.yml file
# with open("provision/command_sets_16_9.yml") as f:
# commands = yaml.load(f.read())["commands"]
# initial_config = commands["initial_config"]
# nat_vpg_config = commands["nat_config"]
# Read in the entire YAML file for use in various templates
print("Reading in Device Device Details")
with open("provision/device_details.yml") as f:
device_details = yaml.load(f.read())
# Create the NETCONF template for creating interfaces
print("Setting Up NETCONF Templates")
with open("provision/templates/netconf_interface_template.j2") as f:
interface_template = Template(f.read())
# Create the NETCONF template for configuring NAT
# The 'netconf_configs' directory must exist prior to running the script
with open("provision/templates/netconf_nat_template.j2") as f:
nat_template = Template(f.read())
# Create the NETCONF template for configuring hostname
# The 'netconf_configs' directory must exist prior to running the script
with open("provision/templates/netconf_hostname_template.j2") as f:
hostname_template = Template(f.read())
# Create the NETCONF template for configuring acl
# The 'netconf_configs' directory must exist prior to running the script
with open("provision/templates/netconf_acl_template.j2") as f:
acl_template = Template(f.read())
class LayerControl(MacroElement):
"""
Creates a LayerControl object to be added on a folium map.
Parameters
----------
position : str
The position of the control (one of the map corners), can be
'topleft', 'topright', 'bottomleft' or 'bottomright'
default: 'topright'
collapsed : boolean
If true the control will be collapsed into an icon and expanded on
mouse hover or touch.
default: True
autoZIndex : boolean
If true the control assigns zIndexes in increasing order to all of
its layers so that the order is preserved when switching them on/off.
default: True
"""
_template = Template("""
{% macro script(this,kwargs) %}
var {{this.get_name()}} = {
base_layers : { {% for key,val in this.base_layers.items() %}"{{key}}" : {{val}},{% endfor %} },
overlays : { {% for key,val in this.overlays.items() %}"{{key}}" : {{val}},{% endfor %} }
};
L.control.layers(
{{this.get_name()}}.base_layers,
{{this.get_name()}}.overlays,
{position: '{{this.position}}',
collapsed: {{this.collapsed}},
autoZIndex: {{this.autoZIndex}}
}).addTo({{this._parent.get_name()}});
{% for val in this.layers_untoggle %}
{{ val }}.remove();{% endfor %}
{% endmacro %}
""") # noqa
def __init__(self, position='topright', collapsed=True, autoZIndex=True):
super(LayerControl, self).__init__()
self._name = 'LayerControl'
self.position = position
self.collapsed = str(collapsed).lower()
self.autoZIndex = str(autoZIndex).lower()
self.base_layers = OrderedDict()
self.overlays = OrderedDict()
self.layers_untoggle = []
def render(self, **kwargs):
"""Renders the HTML representation of the element."""
self.base_layers = OrderedDict(
[(val.layer_name, val.get_name()) for key, val in
self._parent._children.items() if isinstance(val, Layer)
and not val.overlay and val.control])
self.overlays = OrderedDict(
[(val.layer_name, val.get_name()) for key, val in
self._parent._children.items() if isinstance(val, Layer)
and val.overlay and val.control])
self.layers_untoggle = [
val.get_name() for val in
self._parent._children.values() if isinstance(val, Layer)
and val.overlay and val.control and not val.show]
for additional_base_layer in list(self.base_layers.values())[1:]:
self.layers_untoggle.append(additional_base_layer)
super(LayerControl, self).render()
def make_template_stream(self):
template_obj = self.env.get_template("overview.templ")
ads = serialize.AnalysisDeserializer(
self.database_connection._original_connection,
analysis_id=self.analysis_id)
self.glycan_chromatograms = gcs = ads.load_glycan_composition_chromatograms(
)
# und = ads.load_unidentified_chromatograms()
self.unidentified_chromatograms = und = ChromatogramFilter(
ads.query(serialize.UnidentifiedChromatogram).filter(
serialize.UnidentifiedChromatogram.analysis_id ==
self.analysis_id).all())
if len(gcs) == 0:
self.log(
"No glycan compositions were identified. Skipping report building"
)
templ = Template('''
<html>
<style>
body {
font-family: sans-serif;
}
</style>
<body>
<h3>No glycan compositions were identified</h3>
</body>
</html>
''')
return templ.stream()
summary_plot = summaries.GlycanChromatographySummaryGraphBuilder(
filter(lambda x: x.score > self.threshold, gcs + und))
lcms_plot, composition_abundance_plot = summary_plot.draw(min_score=5)
try:
lcms_plot.ax.legend_.set_visible(False)
except AttributeError:
# The legend may not have been created
pass
lcms_plot.ax.set_title("Glycan Composition\nLC-MS Aggregated EICs",
fontsize=24)
fig = lcms_plot.ax.figure
fig.set_figwidth(fig.get_figwidth() * 2.)
fig.set_figheight(fig.get_figheight() * 2.)
composition_abundance_plot.ax.set_title(
"Glycan Composition\nTotal Abundances", fontsize=24)
composition_abundance_plot.ax.set_xlabel(
composition_abundance_plot.ax.get_xlabel(), fontsize=14)
def resolve_key(key):
match = gcs.find_key(key)
if match is None:
match = und.find_key(key)
return match
template_stream = (template_obj.stream(
analysis=ads.analysis,
lcms_plot=svguri_plot(lcms_plot.ax,
bbox_inches='tight',
patchless=True,
svg_width="100%"),
composition_abundance_plot=svguri_plot(
composition_abundance_plot.ax,
bbox_inches='tight',
patchless=True,
svg_width="100%"),
glycan_chromatograms=gcs,
unidentified_chromatograms=und,
resolve_key=resolve_key))
return template_stream
def _render_with_context(
template_str: str, template: jinja2.Template, **kwargs: Any
) -> str:
"""Store template being rendered in a ContextVar to aid error handling."""
template_cv.set(template_str)
return template.render(**kwargs)
def intplotter(data, isodata, nodata, y, hetclassintdf):
linewidth = 1.5
source = ColumnDataSource(data)
s2 = ColumnDataSource(data=dict(mz=data["mz"],
Error=data["Error"],
RA=data["RA"],
Formula=data["Formula"],
HeteroClass=data["HeteroClass"]))
isosource = ColumnDataSource(isodata)
nosource = ColumnDataSource(nodata)
url = "http://www.chemspider.com/Search.aspx?q=@Formula"
TOOLS = "crosshair,pan,wheel_zoom,box_zoom,reset,tap,previewsave,box_select,poly_select,lasso_select,hover"
figdims = (900, 500) #pixel dimensions for the normal figures
msxlim = [200, 700] #x limits in m/z for the mass spectra
vkxlim = [0, 1]
vkylim = [0, 2]
p1 = figure(tools=TOOLS,
title=y[:-9] + " - Van Krevelen",
width=figdims[0],
height=figdims[1],
x_axis_label='O/C',
y_axis_label='H/C',
webgl=True,
x_range=vkxlim,
y_range=vkylim)
color_mapper = LinearColorMapper(palette=glocmap,
low=msxlim[0],
high=msxlim[1])
p1.scatter(x='OC',
y='HC',
source=source,
size='VKsize',
fill_color={
'field': 'mz',
'transform': color_mapper
},
fill_alpha=0.75,
line_color=None) #use size not radius.
hover = p1.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([('Formula', "@Formula"),
('Mass', "@mz{1.11111}"),
('Error (ppm)', "@Error{1.11}")])
taptool = p1.select(type=TapTool)
taptool.callback = OpenURL(url=url)
color_bar = ColorBar(color_mapper=color_mapper,
title="m/z",
border_line_color=None,
location=(0, 0),
scale_alpha=0.7)
#orientation='horizontal',location='top_left', scale_alpha=0.7)#,ticker=FixedTicker(ticks=[2,6,10,14,18]))
p1.add_layout(color_bar, "right")
dbexlim = [0, 45]
dbeylim = [0, 40]
cmax = max(data["Ono"])
cmax = int(5 * round(float(cmax) / 5))
p2 = figure(tools=TOOLS,
title=y[:-9] + " - DBE vs C# Plot",
width=figdims[0],
height=figdims[1],
x_axis_label='C#',
y_axis_label='DBE',
webgl=True,
x_range=dbexlim,
y_range=dbeylim)
color_mapper2 = LinearColorMapper(palette=glocmap2, low=0, high=cmax)
p2.scatter(x='Cno',
y='DBE',
source=source,
size='VKsize',
fill_color={
'field': 'Ono',
'transform': color_mapper2
},
fill_alpha=0.75,
line_color=None)
hover = p2.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([('Formula', "@Formula"),
('Mass', "@mz{1.11111}"),
('Error (ppm)', "@Error{1.11}")])
taptool = p2.select(type=TapTool)
taptool.callback = OpenURL(url=url)
color_bar2 = ColorBar(
color_mapper=color_mapper2,
title="O#",
border_line_color=None,
location=(0, 0),
scale_alpha=0.7,
ticker=FixedTicker(
ticks=[0, int(cmax / 4),
int(cmax / 2),
int(3 * cmax / 4), cmax]))
p2.add_layout(color_bar2, "right")
aixlim = [0, 45]
aiylim = [0, 1]
p3 = figure(tools=TOOLS,
title=y[:-9] + " - AI(mod) vs C# Plot",
width=figdims[0],
height=figdims[1],
x_axis_label='C#',
y_axis_label='AI(mod)',
webgl=True,
x_range=aixlim,
y_range=aiylim)
color_mapper3 = LinearColorMapper(palette=glocmap2, low=0, high=cmax)
p3.scatter(x='Cno',
y='AImod',
source=source,
size='VKsize',
fill_color={
'field': 'Ono',
'transform': color_mapper3
},
fill_alpha=0.75,
line_color=None)
hover = p3.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([('Formula', "@Formula"),
('Mass', "@mz{1.11111}"),
('Error (ppm)', "@Error{1.11}")])
taptool = p3.select(type=TapTool)
taptool.callback = OpenURL(url=url)
color_bar3 = ColorBar(
color_mapper=color_mapper3,
title="O#",
border_line_color=None,
location=(0, 0),
scale_alpha=0.7,
ticker=FixedTicker(
ticks=[0, int(cmax / 4),
int(cmax / 2),
int(3 * cmax / 4), cmax]))
#orientation='horizontal',location='top_left', scale_alpha=0.7)#,ticker=FixedTicker(ticks=[2,6,10,14,18]))
p3.add_layout(color_bar3, "right")
p4 = figure(tools=TOOLS,
title=y[:-9] + " - Assigned Centroid MS",
width=figdims[0],
height=figdims[1],
x_axis_label='m/z',
y_axis_label='Abundance',
y_range=[min(data["RA"]), max(data["RA"])],
x_range=msxlim)
p4.segment(x0=0, x1=800, y0=0, y1=0, line_width=1, line_color="black")
p4.segment(x0='mz',
y0=0,
x1='mz',
y1='RA',
source=source,
line_width=linewidth,
line_color="black")
p4.scatter(x='mz',
y='RA',
source=source,
fill_color='black',
line_color=None)
hover = p4.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([('Formula', "@Formula"),
('Mass', "@mz{1.11111}"),
('Error (ppm)', "@Error{1.11}")])
taptool = p4.select(type=TapTool)
taptool.callback = OpenURL(url=url)
p4.yaxis[0].formatter = PrintfTickFormatter(format="%4.1e")
"""
#this is me trying to plot a barplot of heteroatomic class distributions...
p7 = figure(tools=TOOLS, title=y[:-9]+"",width=800, height=600, x_axis_label='HeteroClass',y_axis_label='Count',webgl=True)
p7.quad(left="HetClassInts",y=hetclassdf[0],source=source,width=5,height=)
t7 = layouts.Column(hist)
tab7 = Panel(child=t7,title="test")
"""
stretch = msxlim[0] * 0.1
p5 = figure(tools=TOOLS,
title=y[:-9] + " - Assigned Centroid MS",
width=1400,
height=600,
x_axis_label='m/z',
y_axis_label='Abundance',
y_range=[min(data["RA"]), max(data["RA"])],
x_range=(msxlim[0] - stretch, msxlim[1] + stretch))
p5.segment(x0=0, x1=800, y0=0, y1=0, line_width=1, line_color="black")
no1 = p5.segment(x0='mz',
y0=0,
x1='mz',
y1='RA',
source=nosource,
line_width=linewidth,
line_color="red")
no2 = p5.scatter(x='mz',
y='RA',
source=nosource,
fill_color='red',
line_color=None,
legend="Unassigned Peaks")
p5.scatter(x='mz',
y='RA',
source=source,
fill_color='black',
line_color=None,
legend="Assigned Peaks")
p5.segment(x0='mz',
y0=0,
x1='mz',
y1='RA',
source=source,
line_width=linewidth,
line_color="black")
iso1 = p5.segment(x0='mz',
y0=0,
x1='mz',
y1='RA',
source=isosource,
line_width=linewidth,
line_color="green")
iso2 = p5.scatter(x='mz',
y='RA',
source=isosource,
fill_color='green',
line_color=None,
legend="Isotologue Peaks")
hover = p5.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([('Formula', "@Formula"),
('Mass', "@mz{1.11111}"),
('Error (ppm)', "@Error{1.11}")])
taptool = p5.select(type=TapTool)
taptool.callback = OpenURL(url=url)
p5.yaxis[0].formatter = PrintfTickFormatter(format="%4.1e")
js_code1 = "iso1.glyph.visible = false; iso2.glyph.visible = false; no1.glyph.visible = false; no2.glyph.visible = false;"
cb1 = CustomJS(code=js_code1,
args=dict(iso1=iso1, iso2=iso2, no1=no1, no2=no2))
js_code2 = "iso1.glyph.visible = true; iso2.glyph.visible = true; no1.glyph.visible = true; no2.glyph.visible = true;"
cb2 = CustomJS(code=js_code2,
args=dict(iso1=iso1, iso2=iso2, no1=no1, no2=no2))
toggleOn = Button(label="Hide", button_type="success", callback=cb1)
toggleOff = Button(label="Show", button_type="success", callback=cb2)
top = layouts.Row(toggleOn, toggleOff)
t3 = layouts.Column(top, p5)
tab3 = Panel(child=t3, title="Centroid MS with Isotopomers and No Hits")
downloadbutton = Button(label="Download", button_type="success")
downloadbutton.callback = CustomJS(args=dict(s2=s2),
code="""
var data = s2.get('data');
var filetext = 'mz,Error,RA,Formula,HeteroClass\\n';
for (i=0; i < data['mz'].length; i++) {
var currRow = [data['mz'][i].toString(),
data['Error'][i].toString(),
data['RA'][i].toString(),
data['Formula'][i].toString(),
data['HeteroClass'][i].toString().concat('\\n')];
var joined = currRow.join();
filetext = filetext.concat(joined);
}
var filename = 'data_result.csv';
var blob = new Blob([filetext], { type: 'text/csv;charset=utf-8;' });
//addresses IE
if (navigator.msSaveBlob) {
navigator.msSaveBlob(blob, filename);
}
else {
var link = document.createElement("a");
link = document.createElement('a');
link.href = URL.createObjectURL(blob);
link.download = filename;
link.target = "_blank";
link.style.visibility = 'hidden';
link.dispatchEvent(new MouseEvent('click'))
}
""")
columns = [
TableColumn(field="mz",
title="m/z",
formatter=NumberFormatter(format="0.00000")),
TableColumn(field="Error",
title="Error (ppm)",
formatter=NumberFormatter(format="0.00")),
TableColumn(field="RA", title="Abundance"),
TableColumn(field="Formula", title="Formula"),
TableColumn(field="HeteroClass", title="Heteroatomic Class")
]
data_table = DataTable(source=s2,
columns=columns,
width=1400,
row_headers=False,
fit_columns=True)
t4 = layouts.Column(data_table, downloadbutton)
tab4 = Panel(child=t4, title="Selected Data Table")
source.callback = CustomJS(args=dict(s2=s2, dt=data_table),
code="""
var inds = cb_obj.get('selected')['1d'].indices;
var d1 = cb_obj.get('data');
var d2 = s2.get('data');
if (inds.length == 0) {
d2['mz'] = d1['mz']
d2['Error'] = d1['Error']
d2['RA'] = d1['RA']
d2['Formula'] = d1['Formula']
d2['HeteroClass'] = d1['HeteroClass']
}
else if (inds.length != 0) {
d2['mz'] = []
d2['Error'] = []
d2['RA'] = []
d2['Formula'] = []
d2['HeteroClass'] = []
for (i = 0; i < inds.length; i++) {
d2['mz'].push(d1['mz'][inds[i]])
d2['Error'].push(d1['Error'][inds[i]])
d2['RA'].push(d1['RA'][inds[i]])
d2['Formula'].push(d1['Formula'][inds[i]])
d2['HeteroClass'].push(d1['HeteroClass'][inds[i]])
}
}
s2.trigger('change');
dt.trigger('change');
""")
"""
hetclasslist = hetclassintdf["HetClass"].tolist()
hetclasslistnew = []
for x in hetclasslist:
hetclasslistnew.append([x,x])
dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=hetclasslistnew)
"""
t1 = layouts.Row(p1, p4)
t2 = layouts.Row(p2, p3)
t12 = layouts.Column(t1, t2)
tab1 = Panel(child=t12, title="Main")
tabs = Tabs(tabs=[tab1, tab3, tab4])
for figs in [p1, p2, p3, p4, p5]:
figs.xaxis.axis_label_text_font_size = "14pt"
figs.xaxis.major_label_text_font_size = "14pt"
figs.yaxis.axis_label_text_font_size = "14pt"
figs.yaxis.major_label_text_font_size = "14pt"
figs.title.text_font_size = "14pt"
figs.toolbar_location = "above"
with open(outputpath + 'templates/index.html', 'r') as f:
template = Template(f.read())
#js_resources = JSResources(mode='inline')
html = file_html(tabs, (CDN, CDN),
"Interactive Van Krevelen Diagrams",
template=template)
output_file2 = outputpath + y[:-9] + '-plot.html'
with open(output_file2, 'w') as f:
f.write(html)
view(output_file2)
class CMakeFindPackageMultiGenerator(CMakeFindPackageGenerator):
name = "cmake_find_package_multi"
config_template = textwrap.dedent("""
{macros_and_functions}
# Requires CMake > 3.0
if(${{CMAKE_VERSION}} VERSION_LESS "3.0")
message(FATAL_ERROR "The 'cmake_find_package_multi' generator only works with CMake > 3.0")
endif()
include(${{CMAKE_CURRENT_LIST_DIR}}/{filename}Targets.cmake)
{target_props_block}
{build_modules_block}
{find_dependencies_block}
""")
targets_template = textwrap.dedent("""
if(NOT TARGET {name}::{name})
add_library({name}::{name} INTERFACE IMPORTED)
endif()
# Load the debug and release library finders
get_filename_component(_DIR "${{CMAKE_CURRENT_LIST_FILE}}" PATH)
file(GLOB CONFIG_FILES "${{_DIR}}/{filename}Target-*.cmake")
foreach(f ${{CONFIG_FILES}})
include(${{f}})
endforeach()
""")
# This template takes the "name" of the target name::name and configs = ["Release", "Debug"..]
target_properties = Template("""
# Assign target properties
set_property(TARGET {{name}}::{{name}}
PROPERTY INTERFACE_LINK_LIBRARIES
{%- for config in configs %}
$<$<CONFIG:{{config}}>:${{'{'}}{{name}}_LIBRARIES_TARGETS_{{config.upper()}}}
${{'{'}}{{name}}_LINKER_FLAGS_{{config.upper()}}_LIST}>
{%- endfor %})
set_property(TARGET {{name}}::{{name}}
PROPERTY INTERFACE_INCLUDE_DIRECTORIES
{%- for config in configs %}
$<$<CONFIG:{{config}}>:${{'{'}}{{name}}_INCLUDE_DIRS_{{config.upper()}}}>
{%- endfor %})
set_property(TARGET {{name}}::{{name}}
PROPERTY INTERFACE_COMPILE_DEFINITIONS
{%- for config in configs %}
$<$<CONFIG:{{config}}>:${{'{'}}{{name}}_COMPILE_DEFINITIONS_{{config.upper()}}}>
{%- endfor %})
set_property(TARGET {{name}}::{{name}}
PROPERTY INTERFACE_COMPILE_OPTIONS
{%- for config in configs %}
$<$<CONFIG:{{config}}>:${{'{'}}{{name}}_COMPILE_OPTIONS_{{config.upper()}}_LIST}>
{%- endfor %})
""")
build_modules = Template("""
# Build modules
{%- for config in configs %}
foreach(_BUILD_MODULE_PATH {{ '${'+name+'_BUILD_MODULES_PATHS_'+config.upper()+'}' }})
include(${_BUILD_MODULE_PATH})
endforeach()
{%- endfor %}
""")
# https://gitlab.kitware.com/cmake/cmake/blob/master/Modules/BasicConfigVersion-SameMajorVersion.cmake.in
config_version_template = textwrap.dedent("""
set(PACKAGE_VERSION "{version}")
if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
set(PACKAGE_VERSION_COMPATIBLE FALSE)
else()
if("{version}" MATCHES "^([0-9]+)\\\\.")
set(CVF_VERSION_MAJOR "${{CMAKE_MATCH_1}}")
else()
set(CVF_VERSION_MAJOR "{version}")
endif()
if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR)
set(PACKAGE_VERSION_COMPATIBLE TRUE)
else()
set(PACKAGE_VERSION_COMPATIBLE FALSE)
endif()
if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
set(PACKAGE_VERSION_EXACT TRUE)
endif()
endif()
""")
components_target_build_type_tpl = Template(textwrap.dedent("""\
########## MACROS ###########################################################################
#############################################################################################
{{ conan_message }}
{{ conan_find_apple_frameworks }}
{{ conan_package_library_targets }}
########### VARIABLES #######################################################################
#############################################################################################
{{ global_target_variables }}
set({{ pkg_name }}_COMPONENTS_{{ build_type }} {{ pkg_components }})
{%- for comp_name, comp in components %}
########### COMPONENT {{ comp_name }} VARIABLES #############################################
set({{ pkg_name }}_{{ comp_name }}_INCLUDE_DIRS_{{ build_type }} {{ comp.include_paths }})
set({{ pkg_name }}_{{ comp_name }}_INCLUDE_DIR_{{ build_type }} {{ comp.include_path }})
set({{ pkg_name }}_{{ comp_name }}_INCLUDES_{{ build_type }} {{ comp.include_paths }})
set({{ pkg_name }}_{{ comp_name }}_LIB_DIRS_{{ build_type }} {{ comp.lib_paths }})
set({{ pkg_name }}_{{ comp_name }}_RES_DIRS_{{ build_type }} {{ comp.res_paths }})
set({{ pkg_name }}_{{ comp_name }}_DEFINITIONS_{{ build_type }} {{ comp.defines }})
set({{ pkg_name }}_{{ comp_name }}_COMPILE_DEFINITIONS_{{ build_type }} {{ comp.compile_definitions }})
set({{ pkg_name }}_{{ comp_name }}_COMPILE_OPTIONS_C_{{ build_type }} "{{ comp.cflags_list }}")
set({{ pkg_name }}_{{ comp_name }}_COMPILE_OPTIONS_CXX_{{ build_type }} "{{ comp.cxxflags_list }}")
set({{ pkg_name }}_{{ comp_name }}_LIBS_{{ build_type }} {{ comp.libs }})
set({{ pkg_name }}_{{ comp_name }}_SYSTEM_LIBS_{{ build_type }} {{ comp.system_libs }})
set({{ pkg_name }}_{{ comp_name }}_FRAMEWORK_DIRS_{{ build_type }} {{ comp.framework_paths }})
set({{ pkg_name }}_{{ comp_name }}_FRAMEWORKS_{{ build_type }} {{ comp.frameworks }})
set({{ pkg_name }}_{{ comp_name }}_BUILD_MODULES_PATHS_{{ build_type }} {{ comp.build_modules_paths }})
set({{ pkg_name }}_{{ comp_name }}_DEPENDENCIES_{{ build_type }} {{ comp.public_deps }})
set({{ pkg_name }}_{{ comp_name }}_LINKER_FLAGS_LIST_{{ build_type }}
$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:{{ comp.sharedlinkflags_list }}>
$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:{{ comp.sharedlinkflags_list }}>
$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:{{ comp.exelinkflags_list }}>
)
########## COMPONENT {{ comp_name }} FIND LIBRARIES & FRAMEWORKS / DYNAMIC VARS #############
set({{ pkg_name }}_{{ comp_name }}_FRAMEWORKS_FOUND_{{ build_type }} "")
conan_find_apple_frameworks({{ pkg_name }}_{{ comp_name }}_FRAMEWORKS_FOUND_{{ build_type }} "{{ '${'+pkg_name+'_'+comp_name+'_FRAMEWORKS_'+build_type+'}' }}" "{{ '${'+pkg_name+'_'+comp_name+'_FRAMEWORK_DIRS_'+build_type+'}' }}")
set({{ pkg_name }}_{{ comp_name }}_LIB_TARGETS_{{ build_type }} "")
set({{ pkg_name }}_{{ comp_name }}_NOT_USED_{{ build_type }} "")
set({{ pkg_name }}_{{ comp_name }}_LIBS_FRAMEWORKS_DEPS_{{ build_type }} {{ '${'+pkg_name+'_'+comp_name+'_FRAMEWORKS_FOUND_'+build_type+'}' }} {{ '${'+pkg_name+'_'+comp_name+'_SYSTEM_LIBS_'+build_type+'}' }} {{ '${'+pkg_name+'_'+comp_name+'_DEPENDENCIES_'+build_type+'}' }})
conan_package_library_targets("{{ '${'+pkg_name+'_'+comp_name+'_LIBS_'+build_type+'}' }}"
"{{ '${'+pkg_name+'_'+comp_name+'_LIB_DIRS_'+build_type+'}' }}"
"{{ '${'+pkg_name+'_'+comp_name+'_LIBS_FRAMEWORKS_DEPS_'+build_type+'}' }}"
{{ pkg_name }}_{{ comp_name }}_NOT_USED_{{ build_type }}
{{ pkg_name }}_{{ comp_name }}_LIB_TARGETS_{{ build_type }}
"{{ build_type }}"
"{{ pkg_name }}_{{ comp_name }}")
set({{ pkg_name }}_{{ comp_name }}_LINK_LIBS_{{ build_type }} {{ '${'+pkg_name+'_'+comp_name+'_LIB_TARGETS_'+build_type+'}' }} {{ '${'+pkg_name+'_'+comp_name+'_LIBS_FRAMEWORKS_DEPS_'+build_type+'}' }})
{%- endfor %}
"""))
components_targets_tpl = Template(textwrap.dedent("""\
{%- for comp_name, comp in components %}
if(NOT TARGET {{ pkg_name }}::{{ comp_name }})
add_library({{ pkg_name }}::{{ comp_name }} INTERFACE IMPORTED)
endif()
{%- endfor %}
if(NOT TARGET {{ pkg_name }}::{{ pkg_name }})
add_library({{ pkg_name }}::{{ pkg_name }} INTERFACE IMPORTED)
endif()
# Load the debug and release library finders
get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
file(GLOB CONFIG_FILES "${_DIR}/{{ pkg_filename }}Target-*.cmake")
foreach(f ${CONFIG_FILES})
include(${f})
endforeach()
if({{ pkg_name }}_FIND_COMPONENTS)
foreach(_FIND_COMPONENT {{ '${'+pkg_name+'_FIND_COMPONENTS}' }})
list(FIND {{ pkg_name }}_COMPONENTS_{{ build_type }} "{{ pkg_name }}::${_FIND_COMPONENT}" _index)
if(${_index} EQUAL -1)
conan_message(FATAL_ERROR "Conan: Component '${_FIND_COMPONENT}' NOT found in package '{{ pkg_name }}'")
else()
conan_message(STATUS "Conan: Component '${_FIND_COMPONENT}' found in package '{{ pkg_name }}'")
endif()
endforeach()
endif()
"""))
components_config_tpl = Template(textwrap.dedent("""\
########## MACROS ###########################################################################
#############################################################################################
{{ conan_message }}
# Requires CMake > 3.0
if(${CMAKE_VERSION} VERSION_LESS "3.0")
message(FATAL_ERROR "The 'cmake_find_package_multi' generator only works with CMake > 3.0")
endif()
include(${CMAKE_CURRENT_LIST_DIR}/{{ pkg_filename }}Targets.cmake)
########## FIND PACKAGE DEPENDENCY ##########################################################
#############################################################################################
include(CMakeFindDependencyMacro)
{%- for public_dep in pkg_public_deps %}
if(NOT {{ public_dep }}_FOUND)
if(${CMAKE_VERSION} VERSION_LESS "3.9.0")
find_package({{ public_dep }} REQUIRED NO_MODULE)
else()
find_dependency({{ public_dep }} REQUIRED NO_MODULE)
endif()
else()
message(STATUS "Dependency {{ public_dep }} already found")
endif()
{%- endfor %}
########## TARGETS PROPERTIES ###############################################################
#############################################################################################
{%- macro tvalue(pkg_name, comp_name, var, config) -%}
{{'${'+pkg_name+'_'+comp_name+'_'+var+'_'+config.upper()+'}'}}
{%- endmacro -%}
{%- for comp_name, comp in components %}
########## COMPONENT {{ comp_name }} TARGET PROPERTIES ######################################
set_property(TARGET {{ pkg_name }}::{{ comp_name }} PROPERTY INTERFACE_LINK_LIBRARIES
{%- for config in configs %}
$<$<CONFIG:{{config}}>:{{tvalue(pkg_name, comp_name, 'LINK_LIBS', config)}}
{{tvalue(pkg_name, comp_name, 'LINKER_FLAGS_LIST', config)}}>
{%- endfor %})
set_property(TARGET {{ pkg_name }}::{{ comp_name }} PROPERTY INTERFACE_INCLUDE_DIRECTORIES
{%- for config in configs %}
$<$<CONFIG:{{config}}>:{{tvalue(pkg_name, comp_name, 'INCLUDE_DIRS', config)}}>
{%- endfor %})
set_property(TARGET {{ pkg_name }}::{{ comp_name }} PROPERTY INTERFACE_COMPILE_DEFINITIONS
{%- for config in configs %}
$<$<CONFIG:{{config}}>:{{tvalue(pkg_name, comp_name, 'COMPILE_DEFINITIONS', config)}}>
{%- endfor %})
set_property(TARGET {{ pkg_name }}::{{ comp_name }} PROPERTY INTERFACE_COMPILE_OPTIONS
{%- for config in configs %}
$<$<CONFIG:{{config}}>:
{{tvalue(pkg_name, comp_name, 'COMPILE_OPTIONS_C', config)}}
{{tvalue(pkg_name, comp_name, 'COMPILE_OPTIONS_CXX', config)}}>
{%- endfor %})
set({{ pkg_name }}_{{ comp_name }}_TARGET_PROPERTIES TRUE)
{%- endfor %}
########## GLOBAL TARGET PROPERTIES #########################################################
if(NOT {{ pkg_name }}_{{ pkg_name }}_TARGET_PROPERTIES)
set_property(TARGET {{ pkg_name }}::{{ pkg_name }} APPEND PROPERTY INTERFACE_LINK_LIBRARIES
{%- for config in configs %}
$<$<CONFIG:{{config}}>:{{ '${'+pkg_name+'_COMPONENTS_'+config.upper()+'}'}}>
{%- endfor %})
endif()
########## BUILD MODULES ####################################################################
#############################################################################################
{%- for comp_name, comp in components %}
########## COMPONENT {{ comp_name }} BUILD MODULES ##########################################
{%- for config in configs %}
foreach(_BUILD_MODULE_PATH {{ '${'+pkg_name+'_'+comp_name+'_BUILD_MODULES_PATHS_'+config.upper()+'}' }})
include(${_BUILD_MODULE_PATH})
endforeach()
{%- endfor %}
{%- endfor %}
"""))
def __init__(self, conanfile):
super(CMakeFindPackageMultiGenerator, self).__init__(conanfile)
self.configuration = str(self.conanfile.settings.build_type)
self.configurations = [v for v in conanfile.settings.build_type.values_range if v != "None"]
# FIXME: Ugly way to define the output path
self.output_path = os.getcwd()
def generate(self):
generator_files = self.content
for generator_file, content in generator_files.items():
generator_file = os.path.join(self.output_path, generator_file)
save(generator_file, content)
@property
def filename(self):
return None
@property
def content(self):
ret = {}
build_type = str(self.conanfile.settings.build_type).upper()
build_type_suffix = "_{}".format(self.configuration.upper()) if self.configuration else ""
for pkg_name, cpp_info in self.deps_build_info.dependencies:
self._validate_components(cpp_info)
pkg_filename = self._get_filename(cpp_info)
pkg_findname = self._get_name(cpp_info)
pkg_version = cpp_info.version
public_deps = self.get_public_deps(cpp_info)
deps_names = []
for it in public_deps:
name = "{}::{}".format(*self._get_require_name(*it))
if name not in deps_names:
deps_names.append(name)
deps_names = ';'.join(deps_names)
pkg_public_deps_filenames = [self._get_filename(self.deps_build_info[it[0]]) for it in
public_deps]
config_version = self.config_version_template.format(version=pkg_version)
ret[self._config_version_filename(pkg_filename)] = config_version
if not cpp_info.components:
ret[self._config_filename(pkg_filename)] = self._config(
filename=pkg_filename,
name=pkg_findname,
version=cpp_info.version,
public_deps_names=pkg_public_deps_filenames
)
ret["{}Targets.cmake".format(pkg_filename)] = self.targets_template.format(
filename=pkg_filename, name=pkg_findname)
# If any config matches the build_type one, add it to the cpp_info
dep_cpp_info = extend(cpp_info, build_type.lower())
deps = DepsCppCmake(dep_cpp_info, self.name)
find_lib = target_template.format(name=pkg_findname, deps=deps,
build_type_suffix=build_type_suffix,
deps_names=deps_names)
ret["{}Target-{}.cmake".format(pkg_filename, self.configuration.lower())] = find_lib
else:
cpp_info = extend(cpp_info, build_type.lower())
pkg_info = DepsCppCmake(cpp_info, self.name)
components = self._get_components(pkg_name, cpp_info)
# Note these are in reversed order, from more dependent to less dependent
pkg_components = " ".join(["{p}::{c}".format(p=pkg_findname, c=comp_findname) for
comp_findname, _ in reversed(components)])
global_target_variables = target_template.format(name=pkg_findname, deps=pkg_info,
build_type_suffix=build_type_suffix,
deps_names=deps_names)
variables = self.components_target_build_type_tpl.render(
pkg_name=pkg_findname,
global_target_variables=global_target_variables,
pkg_components=pkg_components,
build_type=build_type,
components=components,
conan_find_apple_frameworks=CMakeFindPackageCommonMacros.apple_frameworks_macro,
conan_package_library_targets=CMakeFindPackageCommonMacros.conan_package_library_targets
)
ret["{}Target-{}.cmake".format(pkg_filename, build_type.lower())] = variables
targets = self.components_targets_tpl.render(
pkg_name=pkg_findname,
pkg_filename=pkg_filename,
components=components,
build_type=build_type
)
ret["{}Targets.cmake".format(pkg_filename)] = targets
target_config = self.components_config_tpl.render(
pkg_name=pkg_findname,
pkg_filename=pkg_filename,
components=components,
pkg_public_deps=pkg_public_deps_filenames,
conan_message=CMakeFindPackageCommonMacros.conan_message,
configs=self.configurations
)
ret[self._config_filename(pkg_filename)] = target_config
return ret
def _config_filename(self, pkg_filename):
if pkg_filename == pkg_filename.lower():
return "{}-config.cmake".format(pkg_filename)
else:
return "{}Config.cmake".format(pkg_filename)
def _config_version_filename(self, pkg_filename):
if pkg_filename == pkg_filename.lower():
return "{}-config-version.cmake".format(pkg_filename)
else:
return "{}ConfigVersion.cmake".format(pkg_filename)
def _config(self, filename, name, version, public_deps_names):
# Builds the XXXConfig.cmake file for one package
# The common macros
macros_and_functions = "\n".join([
CMakeFindPackageCommonMacros.conan_message,
CMakeFindPackageCommonMacros.apple_frameworks_macro,
CMakeFindPackageCommonMacros.conan_package_library_targets,
])
# Define the targets properties
targets_props = self.target_properties.render(name=name, configs=self.configurations)
# Add build modules
build_modules_block = self.build_modules.render(name=name, configs=self.configurations)
# The find_dependencies_block
find_dependencies_block = ""
if public_deps_names:
# Here we are generating only Config files, so do not search for FindXXX modules
find_dependencies_block = find_transitive_dependencies(public_deps_names,
find_modules=False)
tmp = self.config_template.format(name=name, version=version,
filename=filename,
target_props_block=targets_props,
build_modules_block=build_modules_block,
find_dependencies_block=find_dependencies_block,
macros_and_functions=macros_and_functions)
return tmp
