def main():
resHTML = '<h2>That resource type does not exist</h2>'
resHistory = ''
useCookies = 1
linkappend = ''
logged_state = 0
currentUser = ''
typeGroup = 'type'
typeID = ''
typeName = ''
uiTheme = ''
# Get current url
try:
url = os.environ['SCRIPT_NAME']
except KeyError:
url = ''
form = cgi.FieldStorage()
# Get Cookies
cookies = Cookie.SimpleCookie()
try:
cookies.load(os.environ['HTTP_COOKIE'])
except KeyError:
useCookies = 0
if useCookies:
try:
currentUser = cookies['userID'].value
except KeyError:
currentUser = ''
try:
loginResult = cookies['loginAttempt'].value
except KeyError:
loginResult = 'success'
try:
sid = cookies['gh_sid'].value
except KeyError:
sid = form.getfirst('gh_sid', '')
try:
uiTheme = cookies['uiTheme'].value
except KeyError:
uiTheme = ''
try:
galaxy = cookies['galaxy'].value
except KeyError:
galaxy = form.getfirst('galaxy', ghShared.DEFAULT_GALAXY)
else:
loginResult = form.getfirst('loginAttempt', '')
sid = form.getfirst('gh_sid', '')
galaxy = form.getfirst('galaxy', ghShared.DEFAULT_GALAXY)
# escape input to prevent sql injection
sid = dbShared.dbInsertSafe(sid)
# Get a session
if loginResult == None:
loginResult = 'success'
sess = dbSession.getSession(sid)
if (sess != ''):
logged_state = 1
currentUser = sess
if (uiTheme == ''):
uiTheme = dbShared.getUserAttr(currentUser, 'themeName')
if (useCookies == 0):
linkappend = 'gh_sid=' + sid
else:
if (uiTheme == ''):
uiTheme = 'crafter'
path = ['']
if os.environ.has_key('PATH_INFO'):
path = os.environ['PATH_INFO'].split('/')[1:]
path = [p for p in path if p != '']
if path[0] != '':
typeID = dbShared.dbInsertSafe(path[0])
try:
conn = dbShared.ghConn()
cursor = conn.cursor()
except Exception:
errorstr = "Error: could not connect to database"
if (cursor):
cursor.execute(
'SELECT resourceTypeName, rg1.groupName, rg2.groupName, rt.containerType, CRmin, CRmax, CDmin, CDmax, DRmin, DRmax, FLmin, FLmax, HRmin, HRmax, MAmin, MAmax, PEmin, PEmax, OQmin, OQmax, SRmin, SRmax, UTmin, UTmax, ERmin, ERmax, rt.resourceCategory, rt.resourceGroup FROM tResourceType rt INNER JOIN tResourceGroup rg1 ON rt.resourceCategory = rg1.resourceGroup INNER JOIN tResourceGroup rg2 ON rt.resourceGroup = rg2.resourceGroup WHERE resourceType="'
+ typeID + '";')
row = cursor.fetchone()
if (row != None):
typeName = row[0]
else:
# look up group info if not found as a type
typeGroup = 'group'
cursor.execute(
'SELECT groupName, (SELECT rg.groupName FROM tResourceGroupCategory rgc INNER JOIN tResourceGroup rg ON rgc.resourceCategory = rg.resourceGroup WHERE rgc.resourceGroup=tResourceGroup.resourceGroup AND rg.groupLevel = tResourceGroup.groupLevel -1) AS resCat, "" AS resourceGroup, Max(tResourceType.containerType) AS contType, Min(CRmin), Max(CRmax), Min(CDmin), Max(CDmax), Min(DRmin), Max(DRmax), Min(FLmin), Max(FLmax), Min(HRmin), Max(HRmax), Min(MAmin), Max(MAmax), Min(PEmin), Max(PEmax), Min(OQmin), Max(OQmax), Min(SRmin), Max(SRmax), Min(UTmin), Max(UTmax), Min(ERmin), Max(ERmax), (SELECT rgc.resourceCategory FROM tResourceGroupCategory rgc INNER JOIN tResourceGroup rg ON rgc.resourceCategory = rg.resourceGroup WHERE rgc.resourceGroup=tResourceGroup.resourceGroup AND rg.groupLevel = tResourceGroup.groupLevel -1) AS catID FROM tResourceGroup, tResourceType WHERE tResourceGroup.resourceGroup="'
+ typeID +
'" AND tResourceType.resourceType IN (SELECT resourceType FROM tResourceTypeGroup WHERE resourceGroup="'
+ typeID + '" GROUP BY resourceType);')
row = cursor.fetchone()
if (row != None):
typeName = row[0]
else:
typeGroup = ''
favHTML = ''
if logged_state > 0:
favCursor = conn.cursor()
favSQL = ''.join((
'SELECT itemID FROM tFavorites WHERE favType=2 AND userID="',
currentUser, '" AND favGroup="', typeID, '" AND galaxy=',
galaxy))
favCursor.execute(favSQL)
favRow = favCursor.fetchone()
if favRow != None:
favHTML = ' <div class="inlineBlock" style="width:3%;float:left;"><a alt="Favorite" title="Favorite" style="cursor: pointer;" onclick="toggleFavorite(this, 2, \'' + typeID + '\', $(\'#galaxySel\').val());"><img src="/images/favorite16On.png" /></a></div>'
else:
favHTML = ' <div class="inlineBlock" style="width:3%;float:left;"><a alt="Favorite" title="Favorite" style="cursor: pointer;" onclick="toggleFavorite(this, 2, \'' + typeID + '\', $(\'#galaxySel\').val());"><img src="/images/favorite16Off.png" /></a></div>'
favCursor.close()
if typeName != '' and typeName != None:
resHTML = '<div style="font-size:16px;font-weight:bold;">' + favHTML + typeName
if row != None and row[3] != None:
if row[1] != typeName:
resHTML += '<div style="float:right;"><img src="/images/resources/' + row[
3] + '.png" /></div></div>'
else:
resHTML += '</div>'
# breadcrumb to resource type if not top level category
if row[1] != typeName:
resHTML += '<h3 style="margin-bottom:12px;">'
if row[26] != 'resource':
resHTML += '<a href="' + ghShared.BASE_SCRIPT_URL + 'resourceType.py/' + str(
row[26]) + '">' + str(row[1]) + '</a>'
else:
resHTML += row[1]
if typeGroup == 'type':
resHTML += ' > <a href="' + ghShared.BASE_SCRIPT_URL + 'resourceType.py/' + row[
27] + '">' + row[2] + '</a>'
resHTML += ' > ' + typeName + '</h3>'
# min/max stats table
resHTML += '<table class="resAttr resourceStats"><tr>'
resHTML += '<td><td class="header"><span>CR</span></td><td class="header"><span>CD</span></td><td class="header"><span>DR</span></td><td class="header"><span>FL</span></td><td class="header"><span>HR</span></td><td class="header"><span>MA</span></td><td class="header"><span>PE</span></td><td class="header"><span>OQ</span></td><td class="header"><span>SR</span></td><td class="header"><span>UT</span></td><td class="header"><span>ER</span></td></tr>'
resHTML += '<tr><td class="header">Min</td><td>' + z2b(
row[4]
) + '</td><td>' + z2b(row[6]) + '</td><td>' + z2b(
row[8]
) + '</td><td>' + z2b(row[10]) + '</td><td>' + z2b(
row[12]) + '</td><td>' + z2b(
row[14]) + '</td><td>' + z2b(
row[16]) + '</td><td>' + z2b(
row[18]) + '</td><td>' + z2b(
row[20]) + '</td><td>' + z2b(
row[22]) + '</td><td>' + z2b(
row[24]) + '</td></tr>'
resHTML += '<tr><td class="header">Max</td><td>' + z2b(
row[5]
) + '</td><td>' + z2b(row[7]) + '</td><td>' + z2b(
row[9]
) + '</td><td>' + z2b(row[11]) + '</td><td>' + z2b(
row[13]) + '</td><td>' + z2b(
row[15]) + '</td><td>' + z2b(
row[17]) + '</td><td>' + z2b(
row[19]) + '</td><td>' + z2b(
row[21]) + '</td><td>' + z2b(
row[23]) + '</td><td>' + z2b(
row[25]) + '</td></tr>'
resHTML += '</table>'
else:
resHTML += '</div>'
cursor.close()
conn.close()
else:
resHTML = '<h1>Resource Type Groups</h1>'
resHTML += '<div id="resTypeInfo">You have reached the resource type page. From here, you can browse to any resource type and view things like: best spawns, schematics, creatures, and min/max stats.</div>'
creature = max([
typeID.find('bone_'),
typeID.find('hide_'),
typeID.find('meat_'),
typeID.find('milk_')
])
if typeID == '':
# Print the plain group list for pre-IE9 because it does not support rotate css
tmpAgent = os.environ.get("HTTP_USER_AGENT", "unknown")
if tmpAgent == 'unknown' or (tmpAgent.find("IE") > -1
and tmpAgent.find("MSIE 9.0") == -1):
resTree = getResourceGroupsPlain()
else:
resTree = getResourceTree()
else:
resTree = ''
pictureName = dbShared.getUserAttr(currentUser, 'pictureName')
# Get reputation to determine editing abilities
stats = dbShared.getUserStats(currentUser, galaxy).split(",")
userReputation = int(stats[2])
print 'Content-type: text/html\n'
env = Environment(loader=FileSystemLoader('templates'))
env.globals['BASE_SCRIPT_URL'] = ghShared.BASE_SCRIPT_URL
env.globals['MOBILE_PLATFORM'] = ghShared.getMobilePlatform(
os.environ['HTTP_USER_AGENT'])
template = env.get_template('resourcetype.html')
print template.render(
uiTheme=uiTheme,
loggedin=logged_state,
currentUser=currentUser,
loginResult=loginResult,
linkappend=linkappend,
url=url,
pictureName=pictureName,
imgNum=ghShared.imgNum,
galaxyList=ghLists.getGalaxyList(),
typeGroup=typeGroup,
typeID=typeID,
resHTML=resHTML,
creature=creature,
resTree=resTree,
editCreatures=(userReputation >=
ghShared.MIN_REP_VALS['ADD_CREATURE']),
resourceType=typeID)
from flask import render_template, Flask, request, redirect, url_for,\
send_from_directory, make_response, send_file, Response
from jinja2 import Environment, FileSystemLoader
import config
import astroph
app = Flask(__name__)
env = Environment(loader=FileSystemLoader('templates'),
extensions=['jinja2.ext.autoescape'])
@app.route("/")
def hello():
return env.get_template('main.html').render(body=astroph.doit())
if __name__ == "__main__":
app.run(debug=config.debug)
import os
import tornado.ioloop
import tornado.web
import tornado.log
import time
from datetime import datetime, date, timedelta
import requests
# import queries
import json
from jinja2 import \
Environment, PackageLoader, select_autoescape
ENV = Environment(loader=PackageLoader('monitor', 'templates'),
autoescape=select_autoescape(['html', 'xml']))
# since the sensors were removed, the database is unavailable now.
# have to use data imported from json file in stead
datafile = []
with open('./monitor/static/json/api_data_final.json', 'r') as f:
datafile = json.load(f)
class TemplateHandler(tornado.web.RequestHandler):
def render_template(self, tpl, context):
template = ENV.get_template(tpl)
self.write(template.render(**context))
def get(self):
self.set_header('Cache-Control',
'no-store, no-cache, must-revalidate, max-age=0')
def generate_conf(cls, log_om, rsyslog_template_name, **kwargs):
jinja2_env = Environment(loader=FileSystemLoader(JINJA_PATH))
template = jinja2_env.get_template(log_om.template)
conf = log_om.to_template(**kwargs, ruleset=rsyslog_template_name)
conf['out_template'] = rsyslog_template_name
return template.render(conf)
def generate_cfg_from_template(TEMPLATE_DIR, template, VARS_FILE):
env = Environment(loader=FileSystemLoader(TEMPLATE_DIR), trim_blocks=True)
template = env.get_template(template)
vars_dict = yaml.load(open(VARS_FILE))
return template.render(vars_dict)
"""
Authors:
Supritha Amudhu
Richa Nahar
"""
from flask import Flask, render_template, send_from_directory, request
import os
from jinja2 import Environment, PackageLoader, select_autoescape
"""
Worked on by Supritha - Snippet to load Jinja2 templates
"""
env = Environment(
loader=PackageLoader('app', 'templates'),
autoescape=select_autoescape(['html', 'xml'])
)
from app.index.elastic_search_helper import init_index, load_documents, query_index, load_blacklist
app = Flask(__name__)
"""
Worked on by Supritha - Route to the index page
"""
@app.route('/')
@app.route('/index')
@app.route('/index/')
def render_static():
return render_template('index.html', index=True)
def main():
module = AnsibleModule(argument_spec=dict(
name=dict(default=None, required=True),
cmd=dict(default=None, required=True),
environments=dict(default=None, type='list'),
environment_file=dict(default=None),
args=dict(default=None),
user=dict(default=None),
description=dict(default=None),
after=dict(default='network.target syslog.target'),
wanted_by=dict(default='multi-user.target'),
alias=dict(default=None),
type=dict(default='simple',
choices=[
'simple', 'forking', 'oneshot', 'dbus', 'notify', 'idle'
]),
restart=dict(default=None,
choices=[
'always', 'on-success', 'on-failure', 'on-abnormal',
'on-abort"', 'on-watchdog'
]),
restart_secs=dict(default=None),
notify_access=dict(default=None, choices=['none', 'main', 'all']),
config_dirs=dict(default=None),
config_files=dict(default=None),
kill_signal=dict(default=None),
state=dict(default='present', choices=['present', 'absent']),
prestart_script=dict(default=None),
timeout_start_secs=dict(default='120'),
timeout_stop_secs=dict(default='120'),
kill_mode=dict(default=None,
choices=['control-group', 'process', 'mixed', 'none']),
pidfile=dict(default=None),
limit_nofile=dict(default=None),
path=dict(default=None)))
try:
changed = False
service_path = None
if not module.params['path']:
service_path = '/etc/systemd/system/%s.service' % module.params[
'name']
else:
service_path = module.params['path']
if module.params['state'] == 'absent':
if os.path.exists(service_path):
os.remove(service_path)
changed = True
if not changed:
module.exit_json(changed=False, result="ok")
else:
os.system('systemctl daemon-reload')
module.exit_json(changed=True, result="changed")
args = ' '
if module.params['args'] or module.params['config_dirs'] or \
module.params['config_files']:
if module.params['args']:
args += module.params['args']
if module.params['config_dirs']:
for directory in module.params['config_dirs'].split(','):
args += '--config-dir %s ' % directory
if module.params['config_files']:
for filename in module.params['config_files'].split(','):
args += '--config-file %s ' % filename
template_vars = module.params
template_vars['args'] = args
env = Environment().from_string(SYSTEMD_TEMPLATE)
rendered_service = env.render(template_vars)
if os.path.exists(service_path):
file_hash = md5(open(service_path, 'rb').read()).hexdigest()
template_hash = md5(rendered_service).hexdigest()
if file_hash == template_hash:
module.exit_json(changed=False, result="ok")
with open(service_path, "w") as fh:
fh.write(rendered_service)
os.system('systemctl daemon-reload')
module.exit_json(changed=True, result="created")
except Exception as e:
formatted_lines = traceback.format_exc()
module.fail_json(msg="creating the service failed: %s" % (str(e)))
from tools.ydt.utils import today
path = os.path.realpath(
os.path.join(os.path.dirname(__file__), '..', 'templates'))
reload(sys) # Python2.5 初始化后会删除 sys.setdefaultencoding 这个方法，我们需要重新载入
sys.setdefaultencoding('utf-8')
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
# path = BASE_DIR + "/templates"
templateLoader = FileSystemLoader(searchpath=path)
# templateLoader = jinja2.PackageLoader('app.dy_client', "templates")
env = Environment(loader=templateLoader, autoescape=True)
logger = logging.getLogger(__name__)
class ProductController(http.Controller):
"""
前端数据接口访问
商品详情
"""
@http.route('/fbb/introduction', type='http', auth='public')
def introduction(self, **post):
"""
商品详情
:param post:
:return:
os.rename(old, new)
except:
return False
return True
def osdelete(filename):
try:
if os.path.exists(filename):
os.remove(filename)
except:
return False
return True
_ENV = Environment(loader=FileSystemLoader('templates/nft'))
def nftupdate():
result = True
try:
pipe = rdbconn.pipeline()
# RTP PORTRANGE
rtpportrange = list(
map(
fieldjsonify,
rdbconn.hmget('cluster:attributes', 'rtp_start_port',
'rtp_end_port')))
# NETALIAS
netaliasnames = rdbconn.smembers('nameset:netalias')
for netaliasname in netaliasnames:
add_periodic_callback)
from .core import BokehServer
from .utils import transpose, without_property_validation
from ..compatibility import WINDOWS
from ..diagnostics.progress_stream import color_of
from ..metrics import time
from ..utils import (log_errors, key_split, format_bytes, format_time)
logger = logging.getLogger(__name__)
with open(os.path.join(os.path.dirname(__file__), 'templates',
'base.html')) as f:
template_source = f.read()
from jinja2 import Environment, FileSystemLoader
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
BOKEH_THEME = Theme(os.path.join(os.path.dirname(__file__), 'theme.yaml'))
template_variables = {'pages': ['main', 'system', 'profile', 'crossfilter']}
class StateTable(DashboardComponent):
""" Currently running tasks """
def __init__(self, worker):
self.worker = worker
names = [
'Stored', 'Executing', 'Ready', 'Waiting', 'Connections', 'Serving'
]
self.source = ColumnDataSource({name: [] for name in names})
addonHandler.initTranslation()
try:
ADDON_SUMMARY = addonHandler.getCodeAddon().manifest["summary"]
ADDON_PANEL_TITLE = str(ADDON_SUMMARY)
except:
ADDON_PANEL_TITLE = ADDON_SUMMARY = 'Access8Math'
try:
from speech import BreakCommand
except:
from speech.commands import BreakCommand
from jinja2 import Environment, FileSystemLoader, select_autoescape
TEMPLATES_PATH = os.path.join(PATH, 'templates')
env = Environment(loader=FileSystemLoader(TEMPLATES_PATH),
variable_start_string='{|{',
variable_end_string='}|}')
#, autoescape=select_autoescape(['html', 'xml']))
def flatten(lines):
"""
convert tree to linear using generator
@param lines:
@type list
@rtype
"""
for line in lines:
if isinstance(line, Iterable) and not isinstance(line, str):
for sub in flatten(line):
yield sub
from jinja2 import Environment
metric_environment = Environment()
class MetricEnvironment:
""" Helper class to facilitate parsing a Metric's name or description in a Score Context """
def render(self, text, score_context):
""" Render the text in the proper Score Context """
return metric_environment.from_string(text).render(score_context.data)
MetricEnvironment = MetricEnvironment()
from random import randrange
import threading
from flask.json import jsonify
from flask import Flask, render_template, request
from jinja2 import Markup, Environment, FileSystemLoader
from pyecharts import options as opts
from pyecharts.charts import Bar, Line
from pyecharts.globals import CurrentConfig
import ecs
import cms
CurrentConfig.GLOBAL_ENV = Environment(loader=FileSystemLoader("./templates"))
app = Flask(__name__, static_folder="templates")
def line_base(): # -> Line:
line = (Line().add_xaxis(["{}".format(i) for i in range(10)]).add_yaxis(
series_name="",
y_axis=[randrange(50, 80) for _ in range(10)],
is_smooth=True,
label_opts=opts.LabelOpts(is_show=False),
).set_global_opts(
title_opts=opts.TitleOpts(title="动态数据"),
xaxis_opts=opts.AxisOpts(type_="value"),
yaxis_opts=opts.AxisOpts(type_="value"),
))
return line
# coding: utf-8
# In[1]:
#!/usr/bin/env python
import os
import re
from jinja2 import Environment, FileSystemLoader
PATH = os.path.dirname(os.path.abspath("__file__"))
TEMPLATE_ENVIRONMENT = Environment(
autoescape=False,
loader=FileSystemLoader(os.path.join(PATH, 'templates')),
trim_blocks=False)
def render_template(template_filename, context):
return TEMPLATE_ENVIRONMENT.get_template(template_filename).render(context)
# ### Rendering Navbar Pages
# In[45]:
#------------------------------------------------------
fname = "index.html"
# iList, actList = new_crawl_directory_for_html('../')
context = {
}
with open(fname, 'w') as f:
# Copyright (c) 2021 The Toltec Contributors
# SPDX-License-Identifier: MIT
"""
Load the Jinja2 templating engine.
"""
from jinja2 import Environment, PackageLoader
env = Environment(
loader=PackageLoader("toltec", "templates"),
autoescape=True,
)
def load_jinja2_environment(script_paths):
try:
from jinja2 import Environment, FileSystemLoader, StrictUndefined, DebugUndefined
except Exception as e:
print('base.py error loading jinja2 environment: {}'.format(e))
raise
# wrap the FileSystemLoader so we can seed it with script paths and record what it requests
class AZCGLoader(FileSystemLoader):
def __init__(self, scripts):
script_paths = scripts.split(',')
paths = []
for script_path in script_paths:
script_dir = os.path.dirname(script_path)
if script_dir not in paths:
paths.append(script_dir)
# feed the unique script dirs as input dirs to FileSystemLoader
super(AZCGLoader, self).__init__(paths)
def get_source(self, environment, template):
for searchpath in self.searchpath:
template_filename = os.path.join(searchpath, template)
template_file = jinja2.utils.open_if_exists(template_filename)
if template_file is None:
continue
try:
contents = template_file.read().decode(self.encoding)
finally:
template_file.close()
mtime = os.path.getmtime(template_filename)
# Record dependency to utility
RegisterDependencyFile(template_filename)
# Allow relative template paths to this template, if not already a search path
template_path = os.path.dirname(template_filename)
if template_path not in self.searchpath:
self.searchpath.append(template_path)
def uptodate():
try:
return os.path.getmtime(template_filename) == mtime
except OSError:
return False
return contents, template_filename, uptodate
raise jinja2.exceptions.TemplateNotFound(template)
jinja_env = Environment(
loader=AZCGLoader(script_paths),
# strip whitespace from templates as much as possible
trim_blocks=True,
lstrip_blocks=True,
# throws an exception if variables are undefined. Setting this to DebugUndefined will print the error message into the generated file instead
undefined=StrictUndefined,
extensions=[jinja_extensions.error.RaiseExtension, "jinja2.ext.do"])
jinja_extensions.template.registerExtensions(jinja_env)
return jinja_env
def project_init(config):
if not os.path.isdir(".git"):
raise click.ClickException(
"You are not in the root of a Git repository")
if os.path.isfile("cumulusci.yml"):
raise click.ClickException(
"This project already has a cumulusci.yml file")
context = {}
# Prep jinja2 environment for rendering files
env = Environment(
loader=PackageLoader("cumulusci",
os.path.join("files", "templates", "project")),
trim_blocks=True,
lstrip_blocks=True,
)
# Project and Package Info
click.echo()
click.echo(click.style("# Project Info", bold=True, fg="blue"))
click.echo(
"The following prompts will collect general information about the project"
)
project_name = os.path.split(os.getcwd())[-1:][0]
click.echo()
click.echo(
"Enter the project name. The name is usually the same as your repository name. NOTE: Do not use spaces in the project name!"
)
context["project_name"] = click.prompt(click.style("Project Name",
bold=True),
default=project_name)
click.echo()
click.echo(
"CumulusCI uses an unmanaged package as a container for your project's metadata. Enter the name of the package you want to use."
)
context["package_name"] = click.prompt(click.style("Package Name",
bold=True),
default=project_name)
click.echo()
context["package_namespace"] = None
if click.confirm(click.style("Is this a managed package project?",
bold=True),
default=False):
click.echo(
"Enter the namespace assigned to the managed package for this project"
)
context["package_namespace"] = click.prompt(click.style(
"Package Namespace", bold=True),
default=project_name)
click.echo()
context["api_version"] = click.prompt(
click.style("Salesforce API Version", bold=True),
default=config.global_config.project__package__api_version,
)
# Dependencies
dependencies = []
click.echo(click.style("# Extend Project", bold=True, fg="blue"))
click.echo(
"CumulusCI makes it easy to build extensions of other projects configured for CumulusCI like Salesforce.org's NPSP and EDA. If you are building an extension of another project using CumulusCI and have access to its Github repository, use this section to configure this project as an extension."
)
if click.confirm(
click.style(
"Are you extending another CumulusCI project such as NPSP or EDA?",
bold=True,
),
default=False,
):
click.echo("Please select from the following options:")
click.echo(" 1: EDA (https://github.com/SalesforceFoundation/EDA)")
click.echo(
" 2: NPSP (https://github.com/SalesforceFoundation/Cumulus)")
click.echo(
" 3: Github URL (provide a URL to a Github repository configured for CumulusCI)"
)
selection = click.prompt(click.style("Enter your selection",
bold=True))
github_url = {
"1": "https://github.com/SalesforceFoundation/EDA",
"2": "https://github.com/SalesforceFoundation/Cumulus",
}.get(selection)
if github_url is None:
print(selection)
github_url = click.prompt(
click.style("Enter the Github Repository URL", bold=True))
dependencies.append({"type": "github", "url": github_url})
context["dependencies"] = dependencies
# Git Configuration
git_config = {}
click.echo()
click.echo(click.style("# Git Configuration", bold=True, fg="blue"))
click.echo(
"CumulusCI assumes your default branch is master, your feature branches are named feature/*, your beta release tags are named beta/*, and your release tags are release/*. If you want to use a different branch/tag naming scheme, you can configure the overrides here. Otherwise, just accept the defaults."
)
git_default_branch = click.prompt(click.style("Default Branch", bold=True),
default="master")
if (git_default_branch and git_default_branch !=
config.global_config.project__git__default_branch):
git_config["default_branch"] = git_default_branch
git_prefix_feature = click.prompt(click.style("Feature Branch Prefix",
bold=True),
default="feature/")
if (git_prefix_feature and git_prefix_feature !=
config.global_config.project__git__prefix_feature):
git_config["prefix_feature"] = git_prefix_feature
git_prefix_beta = click.prompt(click.style("Beta Tag Prefix", bold=True),
default="beta/")
if (git_prefix_beta and
git_prefix_beta != config.global_config.project__git__prefix_beta):
git_config["prefix_beta"] = git_prefix_beta
git_prefix_release = click.prompt(click.style("Release Tag Prefix",
bold=True),
default="release/")
if (git_prefix_release and git_prefix_release !=
config.global_config.project__git__prefix_release):
git_config["prefix_release"] = git_prefix_release
context["git"] = git_config
# test:
click.echo()
click.echo(click.style("# Apex Tests Configuration", bold=True, fg="blue"))
click.echo(
"The CumulusCI Apex test runner uses a SOQL where clause to select which tests to run. Enter the SOQL pattern to use to match test class names."
)
test_name_match = click.prompt(
click.style("Test Name Match", bold=True),
default=config.global_config.project__test__name_match,
)
if (test_name_match and test_name_match
== config.global_config.project__test__name_match):
test_name_match = None
context["test_name_match"] = test_name_match
# Render the cumulusci.yml file
template = env.get_template("cumulusci.yml")
with open("cumulusci.yml", "w") as f:
f.write(template.render(**context))
# Create src directory
if not os.path.isdir("src"):
os.mkdir("src")
# Create sfdx-project.json
if not os.path.isfile("sfdx-project.json"):
sfdx_project = {
"packageDirectories": [{
"path": "force-app",
"default": True
}],
"namespace": context["package_namespace"],
"sourceApiVersion": context["api_version"],
}
with open("sfdx-project.json", "w") as f:
f.write(json.dumps(sfdx_project))
# Create orgs subdir
if not os.path.isdir("orgs"):
os.mkdir("orgs")
template = env.get_template("scratch_def.json")
with open(os.path.join("orgs", "beta.json"), "w") as f:
f.write(
template.render(
package_name=context["package_name"],
org_name="Beta Test Org",
edition="Developer",
managed=True,
))
with open(os.path.join("orgs", "dev.json"), "w") as f:
f.write(
template.render(
package_name=context["package_name"],
org_name="Dev Org",
edition="Developer",
managed=False,
))
with open(os.path.join("orgs", "feature.json"), "w") as f:
f.write(
template.render(
package_name=context["package_name"],
org_name="Feature Test Org",
edition="Developer",
managed=False,
))
with open(os.path.join("orgs", "release.json"), "w") as f:
f.write(
template.render(
package_name=context["package_name"],
org_name="Release Test Org",
edition="Enterprise",
managed=True,
))
# create robot folder structure and starter files
if not os.path.isdir("robot"):
test_folder = os.path.join("robot", context["project_name"], "tests")
resource_folder = os.path.join("robot", context["project_name"],
"resources")
doc_folder = os.path.join("robot", context["project_name"], "doc")
os.makedirs(test_folder)
os.makedirs(resource_folder)
os.makedirs(doc_folder)
test_src = os.path.join(
cumulusci.__location__,
"robotframework",
"tests",
"salesforce",
"create_contact.robot",
)
test_dest = os.path.join(test_folder, "create_contact.robot")
copyfile(test_src, test_dest)
click.echo(
click.style(
"Your project is now initialized for use with CumulusCI",
bold=True,
fg="green",
))
click.echo(
click.style(
"You can use the project edit command to edit the project's config file",
fg="yellow",
))
#!/usr/bin/env python
import json
import re
from pathlib import Path
from subprocess import run, CalledProcessError
import click
from dulwich.repo import Repo
from dulwich.porcelain import active_branch, reset
from jinja2 import Environment, FileSystemLoader
from jsonschema import validate
from packaging.specifiers import SpecifierSet
from packaging.version import parse
env = Environment()
def get_version_identifier(version):
"Get version identifier from version (e.g. refs/tags/v1.0.0 -> v1.0.0)."
if version.startswith('refs/tags/'):
return version[len('refs/tags/'):]
if version.startswith('refs/heads/'):
return version[len('refs/heads/'):]
if version.startswith('refs/remotes/'): # remote branch
return re.sub(r'refs\/remotes\/(.+?)\/', '', version)
return version
def get_requirements_for_ref(repo, ref):
"""Get the requirements (from requirements.txt) for a given ref."""
try:
Environment,
FileSystemLoader,
PackageLoader,
Template,
select_autoescape,
)
from . import LockingDict, config, environment
ENV: Environment = Environment(
loader=ChoiceLoader(
[
FileSystemLoader(
[os.sep.join([environment.APP_DIRS.user_data_dir, "templates"])],
followlinks=True,
),
PackageLoader("mkproj", "templates"),
]
),
autoescape=select_autoescape(["j2"]),
)
def get_template(section: str, template: str) -> Template:
template_path: str = "{0}/{1}.j2".format(section, template)
return ENV.get_template(template_path)
def render(template: Template, task_data: LockingDict) -> str:
return template.render({"config": config.get_config, "data": task_data.get})
def cli(metadata_template):
"""Generate the 'metadata.json' file for this app."""
metadata_dir = Path(__file__).resolve().parent
output_dir = metadata_dir / 'build'
root = metadata_dir.parent
repo = Repo(root)
versions = {
parse(get_version_identifier(ref.decode())): ref
for ref in repo.get_refs()
}
requirements = {
version: get_requirements_for_ref(repo, ref)
for version, ref in versions.items()
}
def get_requirements(spec, version=None):
spec = SpecifierSet(spec)
if version is None:
matching_versions = [
version for version in sorted(versions) if version in spec
]
matching_requirements = {
requirements[version]
for version in matching_versions
}
if len(matching_requirements) == 0:
raise RuntimeError(
f"Unable to determine requirements for specifier '{spec}'."
)
elif len(matching_requirements) > 1:
raise RuntimeError(
f"Requirements for specifier '{spec}' are not uniform.")
reqs = matching_requirements.pop()
else:
reqs = requirements[parse(version)]
return json.dumps({str(spec): reqs})[1:-1]
env = Environment(loader=FileSystemLoader(metadata_dir / 'templates'))
env.filters['get_requirements'] = get_requirements
# Writing output...
output_dir.mkdir(exist_ok=True)
# index.html
index_html = output_dir / 'index.html'
index_html.write_text(env.get_template('index.html').render())
click.echo(f"Write {index_html.relative_to(Path.cwd())}")
# metadata.json
metadata_json = output_dir / 'metadata.json'
metadata_template = env.get_template(metadata_template)
try:
metadata = json.loads(metadata_template.render())
except json.decoder.JSONDecodeError as error:
raise RuntimeError(f"{error}\n{metadata_template.render()}")
validate(
instance=metadata,
schema={
"$ref":
"https://aiidalab.github.io/aiidalab-registry/schemas/v1/metadata.schema.json"
})
metadata_json.write_text(json.dumps(metadata, indent=2))
click.echo(f"Write {metadata_json.relative_to(Path.cwd())}")
import os
import semver
import sys
from .lib.common import BASE_DIR
from invoke import task
try:
from jinja2 import Environment
from jinja2 import FileSystemLoader
HAS_JINJA = True
except ImportError:
HAS_JINJA = False
if HAS_JINJA:
JINJA_ENV = Environment(loader=FileSystemLoader(BASE_DIR +
'/devtools/stubs'))
BUILD_DIR = '{0}/local/ansible_collections/_builds'.format(BASE_DIR)
HELP1 = dict(
version=
"Version of the collection to build, the version must follow in SemVer format.",
collection=
"The collection name to which the modules are upstreamed, DEFAULT: 'f5_modules'."
)
def update_galaxy_file(version, collection):
# updates galaxy.yml file for collection update
galaxy_file = '{0}/local/ansible_collections/F5Networks/{1}/galaxy.yml'.format(
BASE_DIR, collection)
import lorem
from jinja2 import Environment, FileSystemLoader
env = Environment(loader=FileSystemLoader('templates'))
contents = {}
contents['header'] = "My Webpage"
contents['title'] = "Random Page"
contents[
'introduction'] = "This is a random page containing some results for users"
contents['paragraphs'] = []
for i in range(10):
new_p = {}
new_p['title'] = 'Paragraph {}'.format(i)
new_p['text'] = lorem.paragraph()
contents['paragraphs'].append(new_p)
template = env.get_template('main.html')
with open('output.html', 'w') as fh:
fh.write(template.render(contents))
# You could also have written the following:
# fh.write(template.render(**contents))
return 'год'
else:
return 'лет'
parser = argparse.ArgumentParser(
description='''Программа формирует страницу сайта-магазина по продаже крымских вин
на основе шаблона template.html и таблицы со списком вин в формате .xlsx'''
)
parser.add_argument(
'--wine_path', help='''Путь к файлу cо списком продукции''', default='wine.xlsx'
)
wine_path = parser.parse_args().wine_path
env = Environment(
loader=FileSystemLoader('.'),
autoescape=select_autoescape(['html', 'xml'])
)
template = env.get_template('template.html')
foundation_year = 1920
company_age = datetime.datetime.today().year - foundation_year
wines_description = pandas.read_excel(wine_path, keep_default_na=False).to_dict(orient='records')
wines_description_by_categories = defaultdict(list)
for wine in wines_description:
wine_category = wine.pop('Категория')
wines_description_by_categories[wine_category].append(wine)
wines_description_by_categories_sorted = OrderedDict(
def make_site(cls,
searchpath="templates",
outpath=".",
contexts=None,
rules=None,
encoding="utf8",
followlinks=True,
extensions=None,
staticpaths=None,
filters=None,
env_globals=None,
locale=None,
env_kwargs=None,
mergecontexts=False):
"""Create a :class:`Site <Site>` object.
:param searchpath:
A string representing the absolute path to the directory that the
Site should search to discover templates. Defaults to
``'templates'``.
If a relative path is provided, it will be coerced to an absolute
path by prepending the directory name of the calling module. For
example, if you invoke staticjinja using ``python build.py`` in
directory ``/foo``, then *searchpath* will be ``/foo/templates``.
:param outpath:
A string representing the name of the directory that the Site
should store rendered files in. Defaults to ``'.'``.
:param contexts:
A list of *(regex, context)* pairs. The Site will render templates
whose name match *regex* using *context*. *context* must be either
a dictionary-like object or a function that takes either no
arguments or a single :class:`jinja2.Template` as an argument and
returns a dictionary representing the context. Defaults to ``[]``.
:param rules:
A list of *(regex, function)* pairs. The Site will delegate
rendering to *function* if *regex* matches the name of a template
during rendering. *function* must take a
:class:`jinja2.Environment` object, a filename, and a context as
parameters and render the template. Defaults to ``[]``.
:param encoding:
A string representing the encoding that the Site should use when
rendering templates. Defaults to ``'utf8'``.
:param followlinks:
A boolean describing whether symlinks in searchpath should be
followed or not. Defaults to ``True``.
:param extensions:
A list of :ref:`Jinja extensions <jinja-extensions>` that the
:class:`jinja2.Environment` should use. Defaults to ``[]``.
:param staticpaths:
List of directories to get static files from (relative to
searchpath). Defaults to ``None``.
:param filters:
A dictionary of Jinja2 filters to add to the Environment. Defaults
to ``{}``.
:param env_globals:
A mapping from variable names that should be available all the time
to their values. Defaults to ``{}``.
:param env_kwargs:
A dictionary that will be passed as keyword arguments to the
jinja2 Environment. Defaults to ``{}``.
:param mergecontexts:
A boolean value. If set to ``True``, then all matching regex from
the contexts list will be merged (in order) to get the final
context. Otherwise, only the first matching regex is used.
Defaults to ``False``.
"""
# Coerce search to an absolute path if it is not already
if not os.path.isabs(searchpath):
# TODO: Determine if there is a better way to write do this
calling_module = inspect.getmodule(inspect.stack()[-1][0])
# Absolute path to project
project_path = os.path.realpath(
os.path.dirname(calling_module.__file__))
searchpath = os.path.join(project_path, searchpath)
if env_kwargs is None:
env_kwargs = {}
env_kwargs['loader'] = FileSystemLoader(searchpath=searchpath,
encoding=encoding,
followlinks=followlinks)
env_kwargs.setdefault('extensions', extensions or [])
environment = Environment(**env_kwargs)
if filters:
environment.filters.update(filters)
if env_globals:
environment.globals.update(env_globals)
environment.install_gettext_callables(gettext=gettext.gettext,
ngettext=gettext.ngettext,
newstyle=True)
print(outpath)
if locale:
translations = Translations.load('locale', [locale])
environment.install_gettext_translations(translations)
if locale == 'ja_JP':
locale = 'jp'
outpath = './' + locale
print(outpath)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler())
return cls(
environment,
searchpath=searchpath,
outpath=outpath,
encoding=encoding,
logger=logger,
rules=rules,
contexts=contexts,
staticpaths=staticpaths,
mergecontexts=mergecontexts,
)
def load_env():
from jinja2 import Environment, FileSystemLoader, select_autoescape
return Environment(loader=FileSystemLoader('templates/'),
autoescape=select_autoescape(['html']))
def render_from_template(directory, template_name, **kwargs):
loader = FileSystemLoader(directory)
env = Environment(loader=loader)
template = env.get_template(template_name)
return template.render(**kwargs)
def init_settings(self,
ipython_app,
kernel_manager,
contents_manager,
session_manager,
kernel_spec_manager,
config_manager,
log,
base_url,
default_url,
settings_overrides,
jinja_env_options=None):
_template_path = settings_overrides.get(
"template_path",
ipython_app.template_file_path,
)
if isinstance(_template_path, py3compat.string_types):
_template_path = (_template_path, )
template_path = [os.path.expanduser(path) for path in _template_path]
jenv_opt = {"autoescape": True}
jenv_opt.update(jinja_env_options if jinja_env_options else {})
env = Environment(loader=FileSystemLoader(template_path), **jenv_opt)
sys_info = get_sys_info()
if sys_info['commit_source'] == 'repository':
# don't cache (rely on 304) when working from master
version_hash = ''
else:
# reset the cache on server restart
version_hash = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
if ipython_app.ignore_minified_js:
log.warn("""The `ignore_minified_js` flag is deprecated and no
longer works. Alternatively use `npm run build:watch` when
working on the notebook's Javascript and LESS""")
warnings.warn(
"The `ignore_minified_js` flag is deprecated and will be removed in Notebook 6.0",
DeprecationWarning)
settings = dict(
# basics
log_function=log_request,
base_url=base_url,
default_url=default_url,
template_path=template_path,
static_path=ipython_app.static_file_path,
static_custom_path=ipython_app.static_custom_path,
static_handler_class=FileFindHandler,
static_url_prefix=url_path_join(base_url, '/static/'),
static_handler_args={
# don't cache custom.js
'no_cache_paths':
[url_path_join(base_url, 'static', 'custom')],
},
version_hash=version_hash,
ignore_minified_js=ipython_app.ignore_minified_js,
# rate limits
iopub_msg_rate_limit=ipython_app.iopub_msg_rate_limit,
iopub_data_rate_limit=ipython_app.iopub_data_rate_limit,
rate_limit_window=ipython_app.rate_limit_window,
# authentication
cookie_secret=ipython_app.cookie_secret,
login_url=url_path_join(base_url, '/login'),
login_handler_class=ipython_app.login_handler_class,
logout_handler_class=ipython_app.logout_handler_class,
password=ipython_app.password,
# managers
kernel_manager=kernel_manager,
contents_manager=contents_manager,
session_manager=session_manager,
kernel_spec_manager=kernel_spec_manager,
config_manager=config_manager,
# IPython stuff
jinja_template_vars=ipython_app.jinja_template_vars,
nbextensions_path=ipython_app.nbextensions_path,
websocket_url=ipython_app.websocket_url,
mathjax_url=ipython_app.mathjax_url,
config=ipython_app.config,
config_dir=ipython_app.config_dir,
jinja2_env=env,
terminals_available=False, # Set later if terminals are available
)
# allow custom overrides for the tornado web app.
settings.update(settings_overrides)
return settings
def getTemplate(self, dic):
self.env = Environment(loader=PackageLoader(self.module_path, 'app' +
'/' + self.name))
tem = self.env.get_template(self.name + '.html')
return tem.render(dic)
os.system('lftp -c "source conf/' + mirror + '.conf && find -l . && exit" > lists/' + mirror + '.txt')
txt_editor("lists/" + mirror + ".txt", "lists/" + mirror + "_list.txt")
os.system("diff -u lists/original_list.txt lists/" + mirror + "_list.txt > webpage/" + mirrors[mirror]['diffFile'])
if os.stat(mirrors[mirror]['diffFile']).st_size==0:
if mirrors[mirror]['updated'] == False:
mirrors[mirror]['lastUpdate'] = now.strftime("%Y-%m-%d %H:%M")
mirrors[mirror]['updated'] = True
else:
mirrors[mirror]['updated'] = False
# Update time
config_data['lastRun'] = now.strftime("%Y-%m-%d %H:%M")
template_name = config_data['template']
# Save data
file = open('./config.yaml', 'w')
yaml.dump(config_data, file, Dumper=yaml.RoundTripDumper)
# Load Jinja2 template
env = Environment(loader = FileSystemLoader('./'), trim_blocks=True, lstrip_blocks=True)
template = env.get_template('templates/' + template_name +'/template.j2')
# Update template files in the webpage folder
os.system('cp -r templates/' + template_name +'/* webpage/ ; rm webpage/template.j2')
# Render the template with data and save in webpage/index.html
file = open('webpage/index.html', 'w')
file.write(template.render(config_data))
def __init__(self, environment=None):
if environment is None:
environment = Environment()
self.environment = environment
self.register_environment_functions()
