def getSubjTriples(): env = Environment() subjList = getSubjectsWithSvgFiles() # break the list of subjects up into triples # each subject chart will be displayed 4 cols wide # 960.gs provides 12 cols, so 3 subj charts/row subjListTriples = [] counter = 0 subjListTriple = [] for subj in subjList: counter += 1 subjListTriple.append(subj) if counter == 3: subjListTriples.append(subjListTriple) subjListTriple = [] counter = 0 if subjListTriple != []: while len(subjListTriple) < 3: # stuff list triple with Jinja2 undefined objects # template-side code will handle this logic subjListTriple.append(env.undefined()) subjListTriples.append(subjListTriple) return subjListTriples
def render_template(jinja_template, extra_variables, output_options,
jinja_environment):
environment = Environment(
loader=FileSystemLoader([os.path.dirname(jinja_template)]),
block_start_string=jinja_environment.get('BLOCK_START_STRING',
defaults.BLOCK_START_STRING),
block_end_string=jinja_environment.get('BLOCK_END_STRING',
defaults.BLOCK_END_STRING),
variable_start_string=jinja_environment.get(
'VARIABLE_START_STRING', defaults.VARIABLE_START_STRING),
variable_end_string=jinja_environment.get(
'VARIABLE_END_STRING', defaults.VARIABLE_END_STRING),
comment_start_string=jinja_environment.get(
'COMMENT_START_STRING', defaults.COMMENT_START_STRING),
comment_end_string=jinja_environment.get('COMMENT_END_STRING',
defaults.COMMENT_END_STRING),
line_statement_prefix=jinja_environment.get(
'LINE_STATEMENT_PREFIX', defaults.LINE_STATEMENT_PREFIX),
line_comment_prefix=jinja_environment.get(
'LINE_COMMENT_PREFIX', defaults.LINE_COMMENT_PREFIX),
trim_blocks=jinja_environment.get('TRIM_BLOCKS', True),
lstrip_blocks=jinja_environment.get('LSTRIP_BLOCKS', True),
newline_sequence=jinja_environment.get('NEWLINE_SEQUENCE',
defaults.NEWLINE_SEQUENCE),
keep_trailing_newline=jinja_environment.get(
'KEEP_TRAILING_NEWLINE', defaults.KEEP_TRAILING_NEWLINE))
environment.undefined = StrictUndefined
template = environment.get_template(os.path.basename(jinja_template))
return template.render(extra_variables)
def render(template_path,
jerakia_instance,
data,
extensions=None,
strict=False):
"""Renders a jinja2 template using data looked up via Jerakia"""
global jerakia
jerakia = jerakia_instance
if extensions is None:
extensions = []
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
env.globals['environ'] = os.environ.get
env.globals['retrieveJerakia'] = retrieveJerakia
output = env.get_template(os.path.basename(template_path)).render(data)
return output.encode('utf-8')
def render(template_path, data, extensions, strict=False, recurse=False):
from jinja2 import Environment, FileSystemLoader, StrictUndefined
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
env.undefined = StrictUndefined
# Add environ global
env.globals["environ"] = lambda key: force_text(os.environ.get(key))
env.globals["get_context"] = lambda: data
# Get first pass output
output = env.get_template(os.path.basename(template_path)).render(data)
if recurse:
# Recursive option
while True:
# Make it a template for the next pass
template = output
# Get another output using output from previous pass as input
output2 = env.from_string(template).render(data)
# If the output is same as before then no further replacement is
# necessary
if output2 == output:
break
# Otherwise, continue
output = output2
return output.encode('utf-8')
def render_template(jinja_template, extra_variables, output_options, jinja_environment, template_root):
environment = Environment(
loader=FileSystemLoader(template_root),
block_start_string=jinja_environment.get('BLOCK_START_STRING', defaults.BLOCK_START_STRING),
block_end_string=jinja_environment.get('BLOCK_END_STRING', defaults.BLOCK_END_STRING),
variable_start_string=jinja_environment.get('VARIABLE_START_STRING', defaults.VARIABLE_START_STRING),
variable_end_string=jinja_environment.get('VARIABLE_END_STRING', defaults.VARIABLE_END_STRING),
comment_start_string=jinja_environment.get('COMMENT_START_STRING', defaults.COMMENT_START_STRING),
comment_end_string=jinja_environment.get('COMMENT_END_STRING', defaults.COMMENT_END_STRING),
line_statement_prefix=jinja_environment.get('LINE_STATEMENT_PREFIX', defaults.LINE_STATEMENT_PREFIX),
line_comment_prefix=jinja_environment.get('LINE_COMMENT_PREFIX', defaults.LINE_COMMENT_PREFIX),
trim_blocks=jinja_environment.get('TRIM_BLOCKS', True),
lstrip_blocks=jinja_environment.get('LSTRIP_BLOCKS', True),
newline_sequence=jinja_environment.get('NEWLINE_SEQUENCE', defaults.NEWLINE_SEQUENCE),
keep_trailing_newline=jinja_environment.get('KEEP_TRAILING_NEWLINE', defaults.KEEP_TRAILING_NEWLINE)
)
environment.undefined = StrictUndefined
dirname = os.path.dirname(jinja_template)
relpath = os.path.relpath(dirname, template_root)
basename = os.path.basename(jinja_template)
filename = os.path.join(relpath, basename)
template = environment.get_template(filename)
return template.render(extra_variables)
def render(template_path,
data,
extensions,
strict=False,
markdown=False,
md_extensions=[]):
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
# Add environ global
env.globals['environ'] = os.environ.get
if markdown:
# Markdown filter
import markdown
md = markdown.Markdown(extensions=md_extensions)
env.filters['markdown'] = lambda text: jinja2.Markup(md.convert(text))
output = env.get_template(os.path.basename(template_path)).render(data)
return output.encode('utf-8')
def render(template_path, data, extensions, strict=False, opts={}):
from jinja2 import Environment, FileSystemLoader, StrictUndefined
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
env.undefined = StrictUndefined
if opts.block_start_string:
env.block_start_string = opts.block_start_string
if opts.block_end_string:
env.block_end_string = opts.block_end_string
if opts.variable_start_string:
env.variable_start_string = opts.variable_start_string
if opts.variable_end_string:
env.variable_end_string = opts.variable_end_string
if opts.comment_start_string:
env.comment_start_string = opts.comment_start_string
if opts.comment_end_string:
env.comment_end_string = opts.comment_end_string
# Add environ global
env.globals["environ"] = lambda key: force_text(os.environ.get(key))
env.globals["get_context"] = lambda: data
return env.get_template(os.path.basename(template_path)).render(data)
def render(opts, args):
if len(args) == 1:
data = sys.stdin.read()
else:
path = os.path.join(os.getcwd(), os.path.expanduser(args[1]))
data_file = open(path)
data = data_file.read()
data_file.close()
template_path = os.path.abspath(args[0])
try:
data = json.loads(data)
except ValueError as err:
sys.stderr.write(str(err))
sys.exit(1)
# keep_trailing_newline appeared in jinja 2.7, see http://jinja.pocoo.org/docs/dev/api/
# we add a case for this as it can be really important in configuration management context
if StrictVersion(jinja2.__version__) >= StrictVersion("2.7"):
env = Environment(loader=FileSystemLoader(os.path.dirname(template_path)), keep_trailing_newline=True)
else:
env = Environment(loader=FileSystemLoader(os.path.dirname(template_path)))
if opts.strict:
env.undefined = StrictUndefined
output = env.get_template(os.path.basename(template_path)).render(data)
if not PY3:
output = output.decode("utf-8")
sys.stdout.write(output)
def render_template(jinja_template):
jinja_template = os.path.abspath(jinja_template)
paths = [x[0] for x in os.walk(os.path.dirname(jinja_template))]
environment = Environment(loader=FileSystemLoader(paths))
environment.undefined = StrictUndefined
template = environment.get_template(os.path.basename(jinja_template))
return template.render()
def render(template_path, data, extensions, strict=False):
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
else:
env.undefined = LooseUndefined
# Add environ global
env.globals['environ'] = os.environ.get
output = env.get_template(os.path.basename(template_path)).render(data)
return output.encode('utf-8')
def render(opts, args):
if len(args) == 1:
data = sys.stdin.read()
else:
path = os.path.join(os.getcwd(), os.path.expanduser(args[1]))
if PY3:
data_file = open(path, encoding='utf-8')
else:
data_file = open(path)
data = data_file.read()
data_file.close()
template_path = os.path.abspath(args[0])
try:
data = json.loads(data)
except ValueError as err:
sys.stderr.write(str(err))
sys.exit(1)
# keep_trailing_newline appeared in jinja 2.7, see http://jinja.pocoo.org/docs/dev/api/
# we add a case for this as it can be really important in configuration management context
if StrictVersion(jinja2.__version__) >= StrictVersion("2.7"):
env = Environment(loader=FileSystemLoader(
os.path.dirname(template_path)),
keep_trailing_newline=True)
else:
env = Environment(loader=FileSystemLoader(
os.path.dirname(template_path)), )
if opts.strict:
env.undefined = StrictUndefined
# Register customs
sys.path.append(os.path.join(os.path.dirname(__file__), "..",
"extensions"))
custom_filters = pkgutil.find_loader('jinja2_custom') is not None
if custom_filters:
import jinja2_custom # pylint: disable=import-error
if hasattr(jinja2_custom, 'FILTERS'):
from jinja2_custom import FILTERS as CUSTOM_FILTERS # pylint: disable=import-error
env.filters.update(CUSTOM_FILTERS)
if hasattr(jinja2_custom, 'TESTS'):
from jinja2_custom import TESTS as CUSTOM_TESTS # pylint: disable=import-error
env.tests.update(CUSTOM_TESTS)
sys.path.pop()
if PY3:
output = env.get_template(os.path.basename(template_path)).render(data)
else:
output = env.get_template(
os.path.basename(template_path)).render(data).encode("utf-8")
sys.stdout.write(output)
def create(data, template_fp=None, verbose=False):
# pre-process data
xml_escape_dict(data)
# set up jinja2 environment
env = Environment()
env.undefined = SilentUndefined
env.filters['slugify'] = slugify_text
env.filters['remove_url_params'] = remove_url_params
env.filters['format_datetime'] = format_datetime
env.filters['get_2char_lang_code'] = get_2char_lang_code
env.filters['get_language'] = get_language
# get template text
if template_fp is None:
template_fp = default_template_path
with open(template_fp, 'r', encoding='utf8') as f:
template_text = f.read()
# render
j2t = env.from_string(template_text)
render = j2t.render(data=data)
parser = etree.XMLParser(remove_blank_text=True, remove_comments=True)
root = etree.fromstring(bytes(render, encoding='utf8'), parser=parser)
# strip whitespace from text and tail
for elem in root.iter('*'):
if elem.text is not None:
elem.text = elem.text.strip()
if elem.tail is not None:
elem.tail = elem.tail.strip()
if elem.text is not None and not elem.text.strip():
elem.text = None
# remove attribute if empty
for key in elem.keys():
if not elem.get(key):
elem.attrib.pop(key)
# remove empty nodes APART from some that are allowed to be empty
protected_elements = ['audio']
found_protected = 0
while len(root.xpath(".//*[not(node())]")) > found_protected:
for element in root.xpath(".//*[not(node())]"):
if etree.QName(element).localname in protected_elements:
found_protected += 1
continue
element.getparent().remove(element)
if verbose:
print(data)
return etree.tostring(root, pretty_print=True, encoding='UTF-8').decode()
def render(opts, args):
if len(args) == 1:
data = sys.stdin.read()
else:
path = os.path.join(os.getcwd(), os.path.expanduser(args[1]))
data_file = open(path)
data = data_file.read()
data_file.close()
template_path = os.path.abspath(args[0])
try:
data = json.loads(data)
except ValueError as err:
sys.stderr.write(str(err))
sys.exit(1)
# keep_trailing_newline appeared in jinja 2.7, see http://jinja.pocoo.org/docs/dev/api/
# we add a case for this as it can be really important in configuration management context
if StrictVersion(jinja2.__version__) >= StrictVersion("2.7"):
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
keep_trailing_newline=True
)
else:
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
)
if opts.strict:
env.undefined = StrictUndefined
# Register customs
sys.path.append(os.path.join(os.path.dirname(__file__), "..", "extensions"))
custom_filters = pkgutil.find_loader('jinja2_custom') is not None
if custom_filters:
import jinja2_custom # pylint: disable=import-error
if hasattr(jinja2_custom, 'FILTERS'):
from jinja2_custom import FILTERS as CUSTOM_FILTERS # pylint: disable=import-error
env.filters.update(CUSTOM_FILTERS)
if hasattr(jinja2_custom, 'TESTS'):
from jinja2_custom import TESTS as CUSTOM_TESTS # pylint: disable=import-error
env.tests.update(CUSTOM_TESTS)
sys.path.pop()
output = env.get_template(os.path.basename(template_path)).render(data)
if not PY3:
output = output.decode("utf-8")
sys.stdout.write(output)
def render(template_path, data, extensions, strict=False):
from jinja2 import Environment, FileSystemLoader, StrictUndefined
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
env.undefined = StrictUndefined
# Add environ global
env.globals["environ"] = lambda key: force_text(os.environ.get(key))
return env.get_template(os.path.basename(template_path)).render(data)
def render(template_path, data, extensions, strict=False):
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
# Add environ global
env.globals['environ'] = os.environ.get
output = env.get_template(os.path.basename(template_path)).render(data)
return output.encode('utf-8')
def render(template_path, data, extensions, strict=False, includes=[]):
from jinja2 import Environment, FileSystemLoader, StrictUndefined
env = Environment(
loader=FileSystemLoader([os.path.dirname(template_path)] + includes),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
env.undefined = StrictUndefined
# Add environ global
env.globals["environ"] = lambda key: force_text(os.environ.get(key))
return env.get_template(os.path.basename(template_path)).render(data)
def render(template_path, data, strict=False) -> str:
"""Render template."""
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
# Add environ global
env.globals["environ"] = os.environ.get
output = env.get_template(os.path.basename(template_path)).render(data)
return output
def render(template_path, data, strict=False) -> str:
"""Render template."""
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
# Add environ global
env.globals["environ"] = os.environ.get
output = env.get_template(os.path.basename(template_path)).render(data)
return output
def render(template_path, data=None, extensions=None, strict=False):
data = data or {}
extensions = extensions or []
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
# Add environ global
env.globals['environ'] = os.environ.get
return env.get_template(os.path.basename(template_path)).render(data)
def render_template(jinja_template, extra_variables, output_options, jinja_environment):
environment = Environment(
loader=FileSystemLoader([os.path.dirname(jinja_template)]),
block_start_string=jinja_environment.get('BLOCK_START_STRING', BLOCK_START_STRING),
block_end_string=jinja_environment.get('BLOCK_END_STRING', BLOCK_END_STRING),
variable_start_string=jinja_environment.get('VARIABLE_START_STRING', VARIABLE_START_STRING),
variable_end_string=jinja_environment.get('VARIABLE_END_STRING', VARIABLE_END_STRING),
comment_start_string=jinja_environment.get('COMMENT_START_STRING', COMMENT_START_STRING),
comment_end_string=jinja_environment.get('COMMENT_END_STRING', COMMENT_END_STRING),
line_statement_prefix=jinja_environment.get('LINE_STATEMENT_PREFIX', LINE_STATEMENT_PREFIX),
line_comment_prefix=jinja_environment.get('LINE_COMMENT_PREFIX', LINE_COMMENT_PREFIX),
trim_blocks=jinja_environment.get('TRIM_BLOCKS', True),
lstrip_blocks=jinja_environment.get('LSTRIP_BLOCKS', True),
newline_sequence=jinja_environment.get('NEWLINE_SEQUENCE', NEWLINE_SEQUENCE),
keep_trailing_newline=jinja_environment.get('KEEP_TRAILING_NEWLINE', KEEP_TRAILING_NEWLINE)
)
environment.undefined = StrictUndefined
template = environment.get_template(os.path.basename(jinja_template))
return template.render(extra_variables)
def render(template_path, configfile_path, data, extensions=JerakiaExtension, strict=False):
"""Renders a jinja2 template using data looked up via Jerakia"""
global jerakia
if jerakia.get_config() is None:
jerakia.set_config(configfile_path)
if extensions is None:
extensions = []
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
output = env.get_template(os.path.basename(template_path)).render(data)
return output.encode('utf-8')
def render(template_path, data, extensions, strict=False, encoding='utf-8'):
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True
)
if strict:
from jinja2 import StrictUndefined
env.undefined = StrictUndefined
# Add environ global
env.globals['environ'] = os.environ.get
output = env.get_template(os.path.basename(template_path)).render(data)
output = output.encode(encoding)
if isinstance(output, binary_type):
output = output.decode(encoding)
return output
def render(template_path, data, extensions, strict=False, env_opts={}):
from jinja2 import Environment, FileSystemLoader, StrictUndefined
env = Environment(
loader=FileSystemLoader(os.path.dirname(template_path)),
extensions=extensions,
keep_trailing_newline=True,
)
if strict:
env.undefined = StrictUndefined
for key in env_opts:
if hasattr(env, key):
target_type = type(getattr(env, key))
new_value = convert_value(env_opts[key], target_type)
setattr(env, key, new_value)
else:
raise MalformedEnv("unsupported environment option: %s" % key)
# Add environ global
env.globals["environ"] = lambda key: force_text(os.environ.get(key))
env.globals["get_context"] = lambda: data
return env.get_template(os.path.basename(template_path)).render(data)
def render(opts, args):
if len(args) == 1:
data = sys.stdin.read()
else:
path = os.path.join(os.getcwd(), os.path.expanduser(args[1]))
data_file = open(path)
data = data_file.read()
data_file.close()
template_path = os.path.abspath(args[0])
try:
data = json.loads(data)
except ValueError as err:
sys.stderr.write(str(err))
sys.exit(1)
# keep_trailing_newline appeared in jinja 2.7, see http://jinja.pocoo.org/docs/dev/api/
# we add a case for this as it can be really important in configuration management context
if StrictVersion(jinja2.__version__) >= StrictVersion("2.7"):
env = Environment(loader=FileSystemLoader(
os.path.dirname(template_path)),
keep_trailing_newline=True)
else:
env = Environment(loader=FileSystemLoader(
os.path.dirname(template_path)), )
if opts.strict:
env.undefined = StrictUndefined
output = env.get_template(os.path.basename(template_path)).render(data)
if not PY3:
output = output.decode("utf-8")
sys.stdout.write(output)
class SilentUndefined(Undefined):
'''
Don't break pageloads because vars arent there!
'''
def _fail_with_undefined_error(self, *args, **kwargs):
return ''
if __name__ == '__main__':
template_text = open(
'/Users/home/Downloads/youtube-dl/youtube_mott_metadata_template.xml',
'r').read()
env = Environment()
env.undefined = SilentUndefined
j2t = env.from_string(template_text)
data = {
'assets': [{
'id': '1231231231',
'title_list': [{
'text': 'Title Text'
}],
'asset_type': 'movie'
}],
'material': {
'material_refs': [{
'text':
'https://emptestdata.blob.core.windows.net/sources/Sintel/sintel.mp4'
}]
}
import sys
import cherrypy
#from ws4py.server.cherrypyserver import WebSocketPlugin, WebSocketTool
#from ws4py.websocket import WebSocket
import threading
from babel.support import Translations
import locale
import jinja2
from jinja2 import Environment, FileSystemLoader
from webtools.ajax import is_xhr
#from webtools.templateddlforms import *
from webtools.angular import TriangleUndefined, angular_filter
env = Environment(loader=FileSystemLoader(''),extensions=['jinja2.ext.i18n','jinja2.ext.with_','jinja2.ext.do','jinja2.ext.loopcontrols','jinja2.ext.autoescape'])
env.undefined = TriangleUndefined
env.filters['angular'] = angular_filter
env.globals['pylist'] = __builtins__.list
env.globals['pydict'] = __builtins__.dict
translations = Translations.load('translations', locale.getdefaultlocale())
env.install_gettext_translations(translations)
#WebSocketPlugin(cherrypy.engine).subscribe()
#cherrypy.tools.websocket = WebSocketTool()
class Root(object):
def __init__(self):
pwd = os.getcwd()
CONFIG_FILE = opj(pwd,'conf/webserver.conf')
from optparse import OptionParser
## templates
from jinja2 import Template, Environment, FileSystemLoader, StrictUndefined
env = Environment(loader=FileSystemLoader("."))
env.undefined = StrictUndefined
def render(template, args):
''' return a string with a rendered template '''
t = env.from_string(template)
return t.render(args)
bird_private = """
log syslog { debug, trace, info, remote, warning, error, auth, fatal, bug };
router id 1.0.{{ octet }}.1;
roa4 table roa_v4;
roa6 table roa_v6;
protocol device DEVICE { }
protocol direct DIRECT {
ipv4 { export all; };
ipv6 { export all; };
interface "-private*";
interface "*";
}
protocol kernel KERNEL4 {
learn;
merge paths;
persist;
ipv4 { import all; export all; };
def gen_files(required_files, selected_features, selected_keywords,
output_path):
"""Generate templated files for selected features.
Args:
required_files (list)
selected_features (list)
selected_keywords (dict)
{
'FS_KEYWORD': SelectedKeyWordValue,
'FS_KEYWORD': ...,
}
output_path (str)
"""
if not path.exists(output_path):
makedirs(output_path)
# Save the config used to generate
config = {
'selected_features': selected_features,
'selected_keywords': selected_keywords,
}
config['generator_info'] = {
'previous': {
'selected_features': selected_features,
'selected_keywords': selected_keywords,
'version': VERSION,
},
}
config_path = path.join(output_path, '.fill-stack_config.json')
with open(config_path, "w") as config_file:
config_file.write(json.dumps(config, indent=4, sort_keys=True))
# Create templated versions of the files that are needed
file_loader = FileSystemLoader(TEMPLATE_PATH)
jinja_env = Environment(loader=file_loader,
trim_blocks=True,
lstrip_blocks=True)
jinja_env.undefined = StrictUndefined
selected_keywords.update({
k: v(selected_keywords)
for k, v in config_feature_keywords_derived.items()
})
template_values = selected_keywords
template_values['render_features'] = {
feature: feature in selected_features
for feature in ALL_FEATURES
}
for required_file in required_files:
required_file_templated_path = get_templated(
config_feature_paths[required_file]['template'], template_values)
new_path = path.join(output_path, required_file_templated_path)
if (new_path[-1] == '/'):
if not path.exists(new_path):
makedirs(new_path)
elif (config_feature_paths[required_file]['binary']):
copyfile(path.join(TEMPLATE_PATH, required_file), new_path)
else:
with open(new_path, 'w') as output_file:
template = jinja_env.get_template(required_file)
templated_file = template.render(template_values)
output_file.write(templated_file)
gen_env_template(selected_features, path.join(output_path, '.env'))
