def checkInstalled():
import path
exists = path.getPath(utils.ADDON.getSetting('OS'), silent=True)
if not exists:
if utils.yesno('Do you want to install the VPN application now'):
import install
install.install(silent=False)
def checkInstalled():
import path
exists = path.getPath(utils.GetSetting('OS'), silent=True)
if not exists:
if utils.yesno('Do you want to install the VPN application now'):
import install
install.install(silent=False)
def main_menu():
print_main_menu()
choice = sanatize.sanitize_int("Enter a selection: ", 1, 9)
if choice == 1:
confirm = input(
'Are you sure, this will erase all data from the database.')
if confirm.upper() == "Y" or confirm.upper() == "YES":
install.install()
else:
print("Selection not confirmed, no changes made.")
elif choice == 2:
year = sanatize.sanitize_int("What Season Would you like to install:",
1901, 2017)
install.import_season(year)
elif choice == 3:
td.run_draft(d.Draft())
elif choice == 4:
print("Review Tournament Draft not yet created, try again.")
elif choice == 5:
print("Continue Saved Tournament Draft not yet created, try again.")
elif choice == 6:
print("League Draft not yet created, try again.")
elif choice == 7:
print("Review League Draft not yet created, try again.")
elif choice == 8:
print("Continue Saved League Draft not yet created, try again.")
elif choice == 9:
player_list = player.open_player_list('1911_test')
players = player.load_players(player_list)
for p in players:
p.display_card()
input()
def post(self):
try:
clear = self.get_argument('clear', 0)
if clear:
model.Banco.objects().delete()
model.Categoria.objects().delete()
model.Lancamento.objects().delete()
pw = self.get_argument('password')
us = self.get_argument('user')
salt = bcrypt.gensalt()
reset = self.get_argument('reset', 1)
if reset:
model.User.objects().delete()
model.Module.objects().delete()
model.Permission.objects().delete()
user = model.User.objects()
if len(user) > 0:
raise Exception('ja instalado')
hash = bcrypt.hashpw(pw.encode('utf-8'), salt)
user = model.User(username=us,password=hash,salt=salt)
install.install(user)
user.save()
self.write('instalacao concluida!')
except Exception as err:
self.set_status(500)
print(err)
self.write(str(err))
def restart(nodes, clean):
if len(nodes) > 0:
all_nodes = nodes
else:
all_nodes = config.Config.nodes()
util.output("stopping ...")
if len(nodes) > 0:
# User picked nodes to restart.
_stopNodes(nodes)
else:
stop([])
if clean:
# Can't delete the tmp here because log archival might still be going on there in the background.
cleanup(all_nodes, False)
util.output("checking configuration ...")
if not checkConfigs(all_nodes):
return
util.output("installing ...")
install.install(False, False)
util.output("starting ...")
if len(nodes) > 0:
_startNodes(nodes)
else:
start([])
def main():
ap = argparse.ArgumentParser()
ap.add_argument("-H", "--host", required=False, default="localhost",
help="Hostname of the InfluxDB server (Default: 'localhost')")
ap.add_argument("-p", "--port", required=False, default=8086, type=int,
help="Port of the InfluxDB server (Default: 8086)")
ap.add_argument("-i", "--interval", required=False, default=3600, type=int,
help="Update Interval in seconds to read data and push to the DB (Default: 3600)")
ap.add_argument("-d", "--database", required=False, default='iobroker',
help="Set the default database (Default: 'iobroker')")
ap.add_argument("-I", "--install", required=False,
help="Install/Reinstall the geckodriver", action='store_true')
args = ap.parse_args()
if args.install:
install.install()
config = {
'host': args.host,
'port': args.port,
'database': args.database,
'interval': args.interval
}
configFile = open("config.json", "w")
json.dump(config, configFile)
configFile.close()
def _main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--venv_path',
required=True,
help='Path at which to create the venv')
parser.add_argument('-r',
'--requirements',
default=[],
action='append',
help='requirements.txt files to install')
parser.add_argument('-s',
'--setup-py-roots',
default=[],
action='append',
help='places to search for setup.py files')
parser.add_argument('--quick-setup',
dest='full_envsetup',
action='store_false',
default='PW_ENVSETUP_FULL' in os.environ,
help=('Do full setup or only minimal checks to see if '
'full setup is required.'))
parser.add_argument('--python',
default=sys.executable,
help='Python to use when creating virtualenv.')
virtualenv_setup.install(**vars(parser.parse_args()))
return 0
def test_uninstall_after_install(self):
install(self.source_dir, self.target_dir, self.backup_dir)
uninstall(self.source_dir, self.target_dir, self.backup_dir)
bashrc_target = os.path.join(self.target_dir, '.bashrc')
pysnippets_target = os.path.join(
self.target_dir,
'.vim/snippets/python.snippets')
self.assertFalse(os.path.exists(bashrc_target))
self.assertFalse(os.path.exists(pysnippets_target))
def main():
if '-I' in sys.argv:
install()
if not resolvedependencies():
exit()
print('Everything OK!\r\n')
logger.info('Starting application.')
# Start the crawling process
medid.crawlloop()
def main():
ap = argparse.ArgumentParser()
ap.add_argument(
"-H",
"--host",
required=False,
default="localhost",
help="Hostname of the InfluxDB server (Default: 'localhost')")
ap.add_argument("-p",
"--port",
required=False,
default=8086,
help="Port of the InfluxDB server (Default: 8086)")
ap.add_argument(
"-i",
"--interval",
required=False,
default=3600,
help=
"Update Interval in seconds to read data and push to the DB (Default: 3600)"
)
ap.add_argument(
"-d",
"--database",
required=False,
default='iobroker',
help="Set the default database (Default: 'iobroker.global')")
ap.add_argument("-I",
"--install",
required=False,
default='n',
help="Install/Reinstall the geckodriver (Default: 'n')")
args = vars(ap.parse_args())
if args["install"] is 'y':
install.install()
config = {
'host': args["host"],
'port': args["port"],
'database': args["database"],
'interval': int(args["interval"])
}
configFile = open("config.json", "w")
json.dump(config, configFile)
configFile.close()
def test_target_does_not_exist(self):
install(self.source_dir, self.target_dir, self.backup_dir)
bashrc_source = os.path.join(self.source_dir, '.bashrc')
bashrc_target = os.path.join(self.target_dir, '.bashrc')
pysnippets_source = os.path.join(
self.source_dir,
'.vim/snippets/python.snippets')
pysnippets_target = os.path.join(
self.target_dir,
'.vim/snippets/python.snippets')
self.assertTrue(os.path.exists(bashrc_target))
self.assertTrue(os.readlink(bashrc_target) == bashrc_source)
self.assertTrue(os.path.exists(pysnippets_target))
self.assertTrue(os.readlink(pysnippets_target) == pysnippets_source)
def test_install_main(self, hemock, pmock, urmock, crmock, dgmock, ipmock):
"""
Ensure the driver/main method is calling all the supporting methods.
"""
install.install()
assert(ipmock.called)
assert(dgmock.called)
assert(crmock.called)
assert(urmock.called)
assert(pmock.called)
pmock.assert_called_with('/srv/kubernetes')
hemock.open_port.assert_any_call(443)
hemock.open_port.assert_any_call(8080)
hemock.open_port.assert_any_call(6443)
def run_setup(self):
username = self._username.get()
password = self._password.get()
path_dir = self._pathdir.get()
shortcut_path = os.path.join(os.path.expanduser('~'), 'Desktop')
genome_path = self._genomepath.get()
if self._cur_os == 'win32' or self._cur_os == 'cygwin':
shortcut_path = shortcut_path.replace("/", "\\")
#if os.path.join(shortcut_path, 'pipeline'):
# self.insert_text('The shortcut already exists!', self._message_txt)
# sys.exit(1)
#self.insert_text(shortcut_path, self._message_txt)
install(username, password, path_dir, shortcut_path, genome_path)
def run_setup(self):
username = self._username.get()
password = self._password.get()
path_dir = self._pathdir.get()
shortcut_path = os.path.join(os.path.expanduser('~'), 'Desktop')
genome_path = self._genomepath.get()
if self._cur_os == 'win32' or self._cur_os == 'cygwin':
shortcut_path = shortcut_path.replace("/", "\\")
#if os.path.join(shortcut_path, 'pipeline'):
# self.insert_text('The shortcut already exists!', self._message_txt)
# sys.exit(1)
#self.insert_text(shortcut_path, self._message_txt)
install(username, password, path_dir, shortcut_path, genome_path)
def test_install_main(self, hemock, urmock, crmock, dgmock, ipmock):
"""
Ensure the driver/main method is calling all the supporting methods.
"""
strings = [
'export GOROOT=/usr/local/go\n',
'export PATH=$PATH:$GOROOT/bin\n',
'export KUBE_MASTER_IP=0.0.0.0\n',
'export KUBERNETES_MASTER=http://$KUBE_MASTER_IP\n',
]
install.install()
crmock.assert_called_once()
dgmock.assert_called_once()
crmock.assert_called_once()
urmock.assert_called_with(strings)
hemock.open_port.assert_called_with(8080)
def test_install_main(self, hemock, urmock, crmock, dgmock, ipmock):
"""
Ensure the driver/main method is calling all the supporting methods.
"""
strings = [
'export GOROOT=/usr/local/go\n',
'export PATH=$PATH:$GOROOT/bin\n',
'export KUBE_MASTER_IP=0.0.0.0\n',
'export KUBERNETES_MASTER=http://$KUBE_MASTER_IP\n',
]
install.install()
crmock.assert_called_once()
dgmock.assert_called_once()
crmock.assert_called_once()
urmock.assert_called_with(strings)
hemock.open_port.assert_called_with(8080)
def install_selected(widget):
print(tools_to_install)
for i in tools_to_install:
print(i)
rc_i = install.install(i)
if rc_i != 0:
broken.append(i)
if rc_i == 0:
installed_tools.append(i)
def install_all(widget):
for i in all_tools:
#just for this tool, need to change the name to be consistent with the backend. In the list it is can-utils-j1939 because it is used for the search functionality
if i is 'can-utils-j1939':
i = 'j1939'
rc_i = install.install(i)
if rc_i != 0:
broken.append(i)
if rc_i == 0:
installed_tools.append(i)
def _main():
parser = argparse.ArgumentParser(description=__doc__)
project_root = os.environ.get('PW_PROJECT_ROOT', None)
parser.add_argument('--project-root',
default=project_root,
required=not project_root,
help='Path to overall project root.')
parser.add_argument('--venv_path',
required=True,
help='Path at which to create the venv')
parser.add_argument('-r',
'--requirements',
default=[],
action='append',
help='requirements.txt files to install')
parser.add_argument('--gn-target',
dest='gn_targets',
default=[],
action='append',
type=virtualenv_setup.GnTarget,
help='GN targets that install packages')
parser.add_argument('--quick-setup',
dest='full_envsetup',
action='store_false',
default='PW_ENVSETUP_FULL' in os.environ,
help=('Do full setup or only minimal checks to see if '
'full setup is required.'))
parser.add_argument('--python',
default=sys.executable,
help='Python to use when creating virtualenv.')
virtualenv_setup.install(**vars(parser.parse_args()))
return 0
def IMPPythonExecutable(env, file):
if env["IMP_PASS"] != "RUN":
return
def dummy(target, source, env):
pass
_PythonExeDependency = Builder(action=Action(dummy, dummy), source_scanner=pyscanner.PythonScanner)
if env.GetOption("help"):
return
inst = install.install(env, "bindir", file)
# Make sure that when we install a Python executable we first build
# any Python modules it uses (env.Install() does not appear to accept
# source_scanner, so we use a dummy do-nothing builder to add these
# dependencies)
pydep = _PythonExeDependency(env, target=None, source=file)
env.Depends(inst, pydep)
env.Append(IMP_PYTHON_EXECUTABLES=[file])
def install_callback(self):
rc_i = install.install(v)
#this needs to be wrapped around an exception incase for some reason the correct name isn't passed
if rc_i == 0:
widget.ids.dynbutton.remove_widget(i)
o = Button(text='Open',
size_hint=(.15, .07),
pos_hint={
'x': .3,
'y': .075
},
background_color=[0, 1, 0,
.65]) #this should be green
o.bind(on_press=open_callback)
up = Button(text='Update',
size_hint=(.15, .07),
pos_hint={
'x': .45,
'y': .075
},
background_color=[0, 0, 1, .65])
up.bind(on_press=update_callback)
un = Button(text='Uninstall',
size_hint=(.15, .07),
pos_hint={
'x': .60,
'y': .075
},
background_color=[0, 0, 1, .75])
un.bind(on_press=uninstall_callback)
widget.ids.dynbutton.add_widget(o)
widget.ids.dynbutton.add_widget(up)
widget.ids.dynbutton.add_widget(un)
installed_tools.append(v)
elif rc_i != 0:
i.background_color = [1, 0, 0, .65]
i.text = 'Failed to Install'
def install_language(language, results=None, no_import=None, args=None,
arglist=None):
r"""Call install for a specific language.
Args:
language (str): Name of language that should be checked.
results (dict, optional): Dictionary where result (whether or not the
language is installed) should be logged. Defaults to None and is
initialized to an empty dict.
no_import (bool, optional): If True, yggdrasil will not be imported.
Defaults to None and is set based on the value parsed from
arglist.
args (argparse.Namespace, optional): Arguments parsed from the
command line. Default to None and is created.
arglist (list, optional): List of arguments to parse. Defaults to
None and sys.argv is used.
"""
if args is None:
args = update_argparser(no_import=no_import,
arglist=arglist).parse_args(args=arglist)
if no_import is None:
no_import = args.no_import
if results is None:
results = {}
with import_language_install(language, no_import=no_import) as install:
if install is None:
logger.info("Nothing to be done for %s" % language)
name_in_pragmas = language.lower()
results[name_in_pragmas] = True
return
else:
name_in_pragmas = getattr(install, 'name_in_pragmas', language.lower())
out = install.install(args=args)
results[name_in_pragmas] = out
if not out:
warnings.warn(("Could not complete installation for {lang}. "
"{lang} support will be disabled.").format(lang=language))
else:
logger.info("Language %s installed." % language)
"""
POKUS
October 2016
Magic Wand Productions
"""
try:
from colorama import *
except ImportError:
from install import install
install("colorama")
init()
from klasser import *
from random import randint
from grafikk import *
import tutorial, gnom, troll, cerberus, gargyl, shroom, example_expansion, os
skrivTittel()
input("Trykk enter for å fortsette\n> ")
print("\033[A \033[A")
print("\033[A \033[A")
lastTidligere = load_screen()
if lastTidligere:
spiller = Spiller(last_navn(lastTidligere))
else:
navn = ""
while len(navn) == 0 or "," in navn:
navn = input("Velg et navn til karakteren din:\n> ")
if "," in navn:
print("Du kan ikke ha komma i navnet ditt.\n")
spiller = Spiller(navn)
def main(**args):
install(args)
llvm_dir = os.path.realpath(os.path.join(root_dir, 'llvm'))
llvm_install_dir = os.path.join(llvm_dir, 'install')
if not os.path.exists(llvm_dir):
os.mkdir(llvm_dir)
llvm_tarball = os.path.join(llvm_dir, 'llvm-3.5.2.src.tar.xz')
llvm_source_dir = os.path.join(llvm_dir, 'llvm-3.5.2.src')
clang_tarball = os.path.join(llvm_dir, 'cfe-3.5.2.src.tar.xz')
clang_source_dir = os.path.join(llvm_dir, 'cfe-3.5.2.src')
download(llvm_tarball, 'http://llvm.org/releases/3.5.2/llvm-3.5.2.src.tar.xz', '85faf7cbd518dabeafc4d3f7e909338fc1dab3c4')
download(clang_tarball, 'http://llvm.org/releases/3.5.2/cfe-3.5.2.src.tar.xz', '50291e4c4ced8fcee3cca40bff0afb19fcc356e2')
extract(llvm_dir, llvm_tarball, 'xz')
extract(llvm_dir, clang_tarball, 'xz')
os.rename(clang_source_dir, os.path.join(llvm_source_dir, 'tools', 'clang'))
llvm_build_dir = os.path.join(llvm_dir, 'build')
os.mkdir(llvm_build_dir)
os.mkdir(llvm_install_dir)
build_llvm(llvm_source_dir, llvm_build_dir, llvm_install_dir, thread_count)
assert os.path.exists(llvm_install_dir)
terra_dir = os.path.join(root_dir, 'terra.build')
if not os.path.exists(terra_dir):
git_clone(terra_dir, 'https://github.com/elliottslaughter/terra.git', 'compiler-ppopp17-snapshot')
build_terra(terra_dir, llvm_install_dir, thread_count)
install.install(
shared_llr=False, general_llr=True, gasnet=True, cuda=False,
external_terra_dir=terra_dir, gasnet_dir=gasnet_release_dir,
debug=False, thread_count=thread_count)
def main():
parser = argparse.ArgumentParser(
'TensorSpace.js model converter/preprocessor.')
parser.add_argument(
'input_path',
nargs='?',
type=str,
help='Path to the input file or directory. For input format "keras", '
'an HDF5 (.h5) file or structure (.json) and weight (.hdf5) directory '
'is expected.')
parser.add_argument('output_path',
nargs='?',
type=str,
help='Path for all output artifacts.')
parser.add_argument('--input_model_from',
type=str,
required=False,
default='keras',
choices=set(['tensorflow', 'keras', 'tfjs']),
help='Input model type.\n'
'It could be "tensorflow", "keras", "tfjs"')
parser.add_argument(
'--input_model_format',
type=str,
required=False,
choices=set([
'topology_weights_combined', 'topology_weights_separated',
'tf_saved', 'tf_frozen', 'tf_keras', 'tf_keras_separated'
]),
help='Input format.\n'
'For "topology_weights_combined", config for Keras model, input is .h5 saved by .save().\n'
'For "topology_weights_separated", config for Keras model, inputs are topology+weights.\n'
'For "tf_saved", config for TensorFlow model, input is TensorFlow saved model.\n'
'For "tf_frozen", config for TensorFlow model, input is TensorFlow frozen model.\n'
'For "tf_keras", config for TensorFlow model, input is .h5 model.\n'
'For "tf_keras_separated", config for TensorFlow model, input is topology+weights.'
)
parser.add_argument(
'--output_layer_names',
type=str,
help='The names of the output nodes, separated by slash. '
'E.g., "logits/activations".')
parser.add_argument(
'--version',
'-v',
'-V',
dest='show_version',
action='store_true',
help='Show versions of tensorspacejs and its dependencies')
parser.add_argument('-init',
dest='init',
action='store_true',
help='Init TensorSpace Converter')
parser.add_argument('--summary',
'-s',
dest='show_model_summary',
action='store_true',
help='Show summray of loaded model')
flags = parser.parse_args()
if flags.show_version:
print('\ntensorspacejs %s\n' % version)
print('Dependency versions:')
print('python %s' % python_version)
print('node %s' % node_version)
print('npm %s' % npm_version)
print('tensorflow %s' % tensorflow_version)
print('keras %s' % keras_version)
print('tensorflowjs %s' % tensorflowjs_version)
return
if flags.init:
install()
return
if flags.input_path is None:
raise ValueError('Error: The input_path argument must be set. '
'Run with --help flag for usage information.')
if flags.input_model_from not in ('tensorflow', 'keras', 'tfjs'):
raise ValueError('The --input_model_from flag can only be set to '
'"tensorflow", "keras", "tfjs" '
'but the current input type is "%s".' %
flags.input_model_from)
if flags.input_model_from == 'keras'\
and flags.input_model_format not in (
'topology_weights_combined',
'topology_weights_separated'):
raise ValueError(
'For input_model_from == "keras", the --input_model_format flag can only be set to'
'"topology_weights_combined" and "topology_weights_separated" '
'but the current input model format is "%s".' %
flags.input_model_format)
if flags.input_model_from == 'tensorflow'\
and flags.input_model_format not in (
'tf_saved',
'tf_frozen',
'tf_keras',
'tf_keras_separated'):
raise ValueError(
'For input_model_from == "tensorflow", the --input_model_format flag can only be set to'
'"tf_saved", "tf_frozen", "tf_checkpoint_model", "tf_keras", "tf_keras_separated" '
'but the current input model format is "%s".' %
flags.input_model_format)
if flags.show_model_summary:
if flags.input_model_from == 'keras':
show_keras_model_summary(flags.input_model_format,
flags.input_path)
return
if flags.input_model_from == 'tensorflow':
show_tf_model_summary(flags.input_model_format, flags.input_path)
return
if flags.input_model_from == "tfjs":
show_tfjs_model_summary(flags.input_path)
return
return
if flags.input_model_from == 'tensorflow':
preprocess_tensorflow_model(flags.input_model_format, flags.input_path,
flags.output_path,
flags.output_layer_names)
return
if flags.input_model_from == 'keras':
preprocess_keras_model(flags.input_model_format, flags.input_path,
flags.output_path, flags.output_layer_names)
return
if flags.input_model_from == 'tfjs':
process_tfjs_model(flags.input_path, flags.output_path,
flags.output_layer_names)
return
print("Nothing happened...")
def driver(llvm_version, insecure):
if 'CC' not in os.environ:
raise Exception('Please set CC in your environment')
if 'CXX' not in os.environ:
raise Exception('Please set CXX in your environment')
if 'LG_RT_DIR' in os.environ:
raise Exception('Please unset LG_RT_DIR in your environment')
is_cray = 'CRAYPE_VERSION' in os.environ
if is_cray:
print('This system has been detected as a Cray system.')
print()
print('Note: The Cray wrappers are broken for various purposes')
print('(particularly, dynamically linked libraries). For this')
print('reason this script requires that HOST_CC and HOST_CXX')
print('be set to the underlying compilers (GCC and G++, etc.).')
print()
if 'HOST_CC' not in os.environ:
raise Exception('Please set HOST_CC in your environment')
if 'HOST_CXX' not in os.environ:
raise Exception('Please set HOST_CXX in your environment')
if llvm_version == '38':
llvm_use_cmake = False
elif llvm_version == '39':
llvm_use_cmake = True
else:
raise Exception('Unrecognized LLVM version %s' % llvm_version)
root_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
legion_dir = os.path.dirname(root_dir)
thread_count = multiprocessing.cpu_count()
conduit = discover_conduit()
gasnet_dir = os.path.realpath(os.path.join(root_dir, 'gasnet'))
gasnet_release_dir = os.path.join(gasnet_dir, 'release')
if not os.path.exists(gasnet_dir):
git_clone(gasnet_dir, 'https://github.com/StanfordLegion/gasnet.git')
build_gasnet(gasnet_dir, conduit)
assert os.path.exists(gasnet_release_dir)
cmake_exe = None
if llvm_use_cmake:
cmake_dir = os.path.realpath(os.path.join(root_dir, 'cmake'))
cmake_install_dir = os.path.join(cmake_dir, 'cmake-3.7.2-Linux-x86_64')
if not os.path.exists(cmake_dir):
os.mkdir(cmake_dir)
cmake_tarball = os.path.join(cmake_dir,
'cmake-3.7.2-Linux-x86_64.tar.gz')
download(
cmake_tarball,
'https://cmake.org/files/v3.7/cmake-3.7.2-Linux-x86_64.tar.gz',
'915bc981aab354821fb9fd28374a720fdb3aa180',
insecure=insecure)
extract(cmake_dir, cmake_tarball, 'gz')
assert os.path.exists(cmake_install_dir)
cmake_exe = os.path.join(cmake_install_dir, 'bin', 'cmake')
llvm_dir = os.path.realpath(os.path.join(root_dir, 'llvm'))
llvm_install_dir = os.path.join(llvm_dir, 'install')
if not os.path.exists(llvm_dir):
os.mkdir(llvm_dir)
if llvm_version == '38':
llvm_tarball = os.path.join(llvm_dir, 'llvm-3.8.1.src.tar.xz')
llvm_source_dir = os.path.join(llvm_dir, 'llvm-3.8.1.src')
clang_tarball = os.path.join(llvm_dir, 'cfe-3.8.1.src.tar.xz')
clang_source_dir = os.path.join(llvm_dir, 'cfe-3.8.1.src')
download(llvm_tarball,
'http://llvm.org/releases/3.8.1/llvm-3.8.1.src.tar.xz',
'e0c48c4c182424b99999367d688cd8ce7876827b',
insecure=insecure)
download(clang_tarball,
'http://llvm.org/releases/3.8.1/cfe-3.8.1.src.tar.xz',
'b5ff24dc6ad8f84654f4859389990bace1cfb6d5',
insecure=insecure)
elif llvm_version == '39':
llvm_tarball = os.path.join(llvm_dir, 'llvm-3.9.1.src.tar.xz')
llvm_source_dir = os.path.join(llvm_dir, 'llvm-3.9.1.src')
clang_tarball = os.path.join(llvm_dir, 'cfe-3.9.1.src.tar.xz')
clang_source_dir = os.path.join(llvm_dir, 'cfe-3.9.1.src')
download(llvm_tarball,
'http://llvm.org/releases/3.9.1/llvm-3.9.1.src.tar.xz',
'ce801cf456b8dacd565ce8df8288b4d90e7317ff',
insecure=insecure)
download(clang_tarball,
'http://llvm.org/releases/3.9.1/cfe-3.9.1.src.tar.xz',
'95e4be54b70f32cf98a8de36821ea5495b84add8',
insecure=insecure)
extract(llvm_dir, llvm_tarball, 'xz')
extract(llvm_dir, clang_tarball, 'xz')
os.rename(clang_source_dir,
os.path.join(llvm_source_dir, 'tools', 'clang'))
llvm_build_dir = os.path.join(llvm_dir, 'build')
os.mkdir(llvm_build_dir)
os.mkdir(llvm_install_dir)
build_llvm(llvm_source_dir, llvm_build_dir, llvm_install_dir,
llvm_use_cmake, cmake_exe, thread_count, is_cray)
assert os.path.exists(llvm_install_dir)
terra_dir = os.path.join(root_dir, 'terra.build')
if not os.path.exists(terra_dir):
git_clone(terra_dir, 'https://github.com/elliottslaughter/terra.git',
'compiler-sc17-snapshot')
build_terra(terra_dir, llvm_install_dir, is_cray, thread_count)
use_cuda = 'USE_CUDA' in os.environ and os.environ['USE_CUDA'] == '1'
use_openmp = 'USE_OPENMP' in os.environ and os.environ['USE_OPENMP'] == '1'
use_hdf = 'USE_HDF' in os.environ and os.environ['USE_HDF'] == '1'
debug = 'DEBUG' in os.environ and os.environ['DEBUG'] == '1'
install.install(gasnet=True,
cuda=use_cuda,
openmp=use_openmp,
hdf=use_hdf,
external_terra_dir=terra_dir,
gasnet_dir=gasnet_release_dir,
conduit=conduit,
debug=debug,
thread_count=thread_count)
def render(self, scene):
# Check first-run installation
install.install()
# Compute film dimensions
scale = scene.render.resolution_percentage / 100.0
sx = int(scene.render.resolution_x * scale)
sy = int(scene.render.resolution_y * scale)
print("Starting render, resolution {} {}".format(sx, sy))
textureUtil.resetTextureCounter()
# Compute pbrt executable path
pbrtExecPath = install.getExecutablePath(
scene.iilePath,
pbrt.DEFAULT_IILE_PROJECT_PATH,
"pbrt"
)
obj2pbrtExecPath = install.getExecutablePath(
scene.iilePath,
pbrt.DEFAULT_IILE_PROJECT_PATH,
"obj2pbrt"
)
if pbrtExecPath is None:
errorMessage(self, "PBRT executable not found. The exporter can use the pbrt executable if it's in the system PATH, or you can specify the directory of the PBRT executable from the Render properties tab")
if obj2pbrtExecPath is None:
errorMessage(self, "obj2pbrt executable not found. The exporter can use the obj2pbrt executable if it's in the system PATH, or you can specify the directory of the PBRT and OBJ2PBRT executables from the Render properties tab")
print("PBRT: {}".format(pbrtExecPath))
print("OBJ2PBRT: {}".format(obj2pbrtExecPath))
# Determine PBRT project directory
if not os.path.exists(scene.iilePath):
# Check fallback
if not os.path.exists(pbrt.DEFAULT_IILE_PROJECT_PATH):
warningMessage(self, "WARNING no project directory found. Are you using vanilla PBRTv3? Some features might not work, such as IILE integrator and GUI renderer")
else:
scene.iilePath = pbrt.DEFAULT_IILE_PROJECT_PATH
rootDir = os.path.abspath(os.path.join(scene.iilePath, ".."))
# Get the output path
outDir = bpy.data.scenes["Scene"].render.filepath
outDir = bpy.path.abspath(outDir)
print("Out dir is {}".format(outDir))
outObjPath = os.path.join(outDir, "exp.obj")
outExpPbrtPath = os.path.join(outDir, "exp.pbrt")
outExp2PbrtPath = os.path.join(outDir, "exp2.pbrt")
outScenePath = os.path.join(outDir, "scene.pbrt")
# Create exporting script
expScriptPath = os.path.join(outDir, "exp.py")
expScriptFile = open(expScriptPath, "w")
wline(expScriptFile, 'import bpy')
wline(expScriptFile, 'outobj = "{}"'.format(outObjPath))
wline(expScriptFile, 'bpy.ops.export_scene.obj(filepath=outobj, axis_forward="Y", axis_up="-Z", use_materials=True)')
expScriptFile.close()
blenderPath = bpy.app.binary_path
projectPath = bpy.data.filepath
if not os.path.isfile(projectPath):
errorMessage(self, "Please Save before Render")
cmd = [
blenderPath,
projectPath,
"--background",
"--python",
expScriptPath
]
runCmd(cmd)
print("OBJ export completed")
# Run obj2pbrt
cmd = [
obj2pbrtExecPath,
outObjPath,
outExpPbrtPath
]
runCmd(cmd, cwd=outDir)
# Run pbrt --toply
cmd = [
pbrtExecPath,
"--toply",
outExpPbrtPath
]
outExp2PbrtFile = open(outExp2PbrtPath, "w")
runCmd(cmd, stdout=outExp2PbrtFile, cwd=outDir)
outExp2PbrtFile.close()
# -----------------------------------------------------------
# Scene transformation
doc = sceneParser.SceneDocument()
doc.parse(outExp2PbrtPath)
# Write initial things
headerBlocks = []
# Film, Camera, transformations
b = sceneParser.SceneBlock([])
headerBlocks.append(b)
b.appendLine(0, 'Film "image" "integer xresolution" {} "integer yresolution" {}'.format(sx, sy))
# Integrator name
integratorName = "path"
if bpy.context.scene.iileIntegrator == "PATH":
integratorName = "path"
elif bpy.context.scene.iileIntegrator == "IILE":
integratorName = "iispt"
elif bpy.context.scene.iileIntegrator == "BDPT":
integratorName = "bdpt"
else:
errorMessage(self, "Unrecognized iileIntegrator {}".format(
bpy.context.scene.iileIntegrator))
b.appendLine(0, 'Integrator "{}"'.format(integratorName))
# Integrator specifics
if bpy.context.scene.iileIntegrator == "PATH":
pass
elif bpy.context.scene.iileIntegrator == "BDPT":
b.appendLine(1, '"integer maxdepth" [{}]'.format(bpy.context.scene.iileIntegratorBdptMaxdepth))
b.appendLine(1, '"string lightsamplestrategy" "{}"'.format(bpy.context.scene.iileIntegratorBdptLightsamplestrategy.lower()))
b.appendLine(1, '"bool visualizestrategies" "{}"'.format("true" if bpy.context.scene.iileIntegratorBdptVisualizestrategies else "false"))
b.appendLine(1, '"bool visualizeweights" "{}"'.format("true" if bpy.context.scene.iileIntegratorBdptVisualizeweights else "false"))
samplerName = "random"
if bpy.context.scene.iileIntegratorPathSampler == "RANDOM":
samplerName = "random"
elif bpy.context.scene.iileIntegratorPathSampler == "SOBOL":
samplerName = "sobol"
elif bpy.context.scene.iileIntegratorPathSampler == "HALTON":
samplerName = "halton"
else:
errorMessage(self, "Unrecognized sampler {}".format(bpy.context.scene.iileIntegratorPathSampler))
b.appendLine(0, 'Sampler "{}" "integer pixelsamples" {}'.format(samplerName, bpy.context.scene.iileIntegratorPathSamples))
b.appendLine(0, 'Scale -1 1 1')
# Get camera
theCameraName = bpy.context.scene.camera.name
theCamera = bpy.data.cameras[theCameraName]
bpy.context.scene.camera.rotation_mode = "AXIS_ANGLE"
print("Camera rotation axis angle is {} {} {} {}".format(bpy.context.scene.camera.rotation_axis_angle[0], bpy.context.scene.camera.rotation_axis_angle[1], bpy.context.scene.camera.rotation_axis_angle[2], bpy.context.scene.camera.rotation_axis_angle[3]))
# Write camera rotation
cameraRotationAmount = bpy.context.scene.camera.rotation_axis_angle[0]
cameraRotationAmount = math.degrees(cameraRotationAmount)
cameraRotationX, cameraRotationY, cameraRotationZ = \
bpy.context.scene.camera.rotation_axis_angle[1:]
# Flip Y
cameraRotationY = -cameraRotationY
b.appendLine(0, 'Rotate {} {} {} {}'.format(
cameraRotationAmount, cameraRotationX,
cameraRotationY, cameraRotationZ))
# Write camera translation
cameraLocX, cameraLocY, cameraLocZ = bpy.context.scene.camera.location
# Flip Y
cameraLocY = -cameraLocY
b.appendLine(0, 'Translate {} {} {}'.format(
cameraLocX, cameraLocY, cameraLocZ))
# Write camera fov
b.appendLine(0, 'Camera "perspective" "float fov" [{}]'.format(math.degrees(theCamera.angle / 2.0)))
# Write world begin
b.appendLine(0, 'WorldBegin')
# Set environment lighting
envBlock = lightEnv.createEnvironmentBlock(scene.world, outDir)
if envBlock is not None:
headerBlocks.append(envBlock)
# Do materials
materialsResolutionOrder = materialTree.buildMaterialsDependencies()
for i in range(len(materialsResolutionOrder)):
matName = materialsResolutionOrder[i]
matBlock = sceneParser.SceneBlock([])
headerBlocks.append(matBlock)
matBlock.appendLine(0, 'MakeNamedMaterial "{}"'.format(matName))
print("Processing material {}".format(matName))
if matName not in bpy.data.materials:
matObj = createEmptyMaterialObject()
else:
matObj = bpy.data.materials[matName]
# Write material type
if matObj.iileMaterial == "MATTE":
processMatteMaterial(matName, outDir, matBlock, matObj)
elif matObj.iileMaterial == "PLASTIC":
processPlasticMaterial(matName, outDir, matBlock, matObj)
elif matObj.iileMaterial == "MIRROR":
processMirrorMaterial(matName, outDir, matBlock, matObj)
elif matObj.iileMaterial == "MIX":
processMixMaterial(matName, outDir, matBlock, matObj)
elif matObj.iileMaterial == "GLASS":
processGlassMaterial(matName, outDir, matBlock, matObj)
elif matObj.iileMaterial == "NONE":
processNoneMaterial(matName, outDir, matBlock, matObj)
else:
errorMessage(self, "Unrecognized material {}".format(
matObj.iileMaterial))
blocks = doc.getBlocks()
for block in blocks:
# Set area light emission color
if block.isAreaLightSource():
print("Processing an area light source")
matName = block.getAssignedMaterial()
print(matName)
if matName not in bpy.data.materials:
continue
matObj = bpy.data.materials[matName]
emitIntensity = matObj.emit
emitColor = [0.0, 0.0, 0.0]
emitColor[0] = emitIntensity * matObj.iileEmission[0]
emitColor[1] = emitIntensity * matObj.iileEmission[1]
emitColor[2] = emitIntensity * matObj.iileEmission[2]
block.replaceLine(3, '"rgb L"',
'"rgb L" [ {} {} {} ]'.format(
emitColor[0], emitColor[1], emitColor[2]))
# Set material properties
if block.isMakeNamedMaterial():
block.clearAll()
doc.addBlocksBeginning(headerBlocks)
# WorldEnd block
weBlock = sceneParser.SceneBlock([])
weBlock.appendLine(0, "WorldEnd")
doc.addBlocksEnd([weBlock])
doc.write(outScenePath)
print("Rendering finished.")
if (bpy.context.scene.iileIntegrator == "IILE") and bpy.context.scene.iileStartRenderer:
print("Starting IILE GUI...")
# Setup PATH for nodejs executable
nodeBinDir = install.findNodeDir(scene.iilePath)
newEnv = os.environ.copy()
if nodeBinDir is not None:
oldPath = newEnv["PATH"]
addition = ':{}'.format(nodeBinDir)
if not oldPath.endswith(addition):
oldPath = oldPath + addition
newEnv["PATH"] = oldPath
print("Updated PATH to {}".format(oldPath))
guiDir = os.path.join(rootDir, "gui")
electronPath = os.path.join(guiDir,
"node_modules",
"electron",
"dist",
"electron")
jsPbrtPath = os.path.join(rootDir,
"bin",
"pbrt")
cmd = []
cmd.append(electronPath)
cmd.append("main.js")
cmd.append(jsPbrtPath)
cmd.append(outScenePath)
cmd.append("{}".format(bpy.context.scene.iileIntegratorIileIndirect))
cmd.append("{}".format(bpy.context.scene.iileIntegratorIileDirect))
runCmd(cmd, cwd=guiDir, env=newEnv)
result = self.begin_result(0, 0, sx, sy)
self.end_result(result)
)
else:
print("Unknown error, please connect the author and administrator")
print("For more help, please using command `make help`")
os._exit(0)
return
if __name__ == '__main__':
import sys
import os
if sys.argv[1] == "-i":
try:
import install
if install.install(int(sys.argv[3])) == 0:
print("Install succeed")
if sys.argv[3] == "0":
os.system("rm -rf install.py")
os._exit(0)
else:
print(
"Install failed, please determine the relationship package and file integrity"
)
os._exit(0)
except:
Error(9)
os._exit(0)
if sys.argv[3] == "0":
try:
def main():
if version_info.major != 3:
raise VersionMismatch("Must be using Python3")
if len(argv) == 1:
print(f"Jpm {version} - help:")
with open("/usr/local/Jac/Data/jpm-help.txt") as help_file:
print(help_file.read(), end='')
return
arg = argv[1]
args = argv[2:]
if arg == "install":
from install import install
from checkForRepositoryConnection import checkConnection, InternetConnectionError
from upgrader import checkForJaclangUpdate
checkForJaclangUpdate()
try:
checkConnection()
except InternetConnectionError as e_:
printException(e_)
install(set(args))
elif arg == "remove":
from remove import removePackages, PackageError
from upgrader import checkForJaclangUpdate
checkForJaclangUpdate()
try:
removePackages(set(args))
except PackageError as e_:
printException(e_)
elif arg == "list":
from listPackages import listPackages
listPackages()
elif arg == "cleanup":
from cleanup import cleanup
from upgrader import checkForJaclangUpdate
checkForJaclangUpdate()
cleanup()
elif arg == "upgrade":
from upgrader import upgrade
from checkForRepositoryConnection import checkConnection, InternetConnectionError
try:
checkConnection()
except InternetConnectionError as e_:
printException(e_)
upgrade()
elif arg == "listall":
from listAll import listall
from upgrader import checkForJaclangUpdate
checkForJaclangUpdate()
listall()
elif arg == "uninstall":
from uninstall import uninstall
uninstall()
else:
raise ArgumentError(f"Unknown argument: {arg}")
menu.append(("(exit)", "Exit"))
code, tag = d.menu("gpvdm build system:", choices=menu)
if code == d.OK:
if tag == "(publish)":
publish_menu(d)
if tag == "(packages)":
package_menu(d)
if tag == "(build)":
configure_menu(d)
if tag == "(install)":
install(d)
if tag == "(uninstall)":
uninstall(d)
if tag == "(distributable)":
distributable(d)
if tag == "(about)":
d.msgbox(
"This is the gpvdm build system, use it to configure the build system, make, and install gpvdm. Copyright Roderick MacKenzie 2018. Released under the GPL v2 license."
)
if tag == "(exit)":
break
def main():
install_engine = install.install()
install_engine.create_declarations()
install_engine.create_db()
#!/usr/bin/env python
# $Id$
# Copyright (C) 1999 LinuXden, All Rights Reserved
# Copright Statement at http://www.linuxden.com/copyrighted_apps.html
#
import install
import os
if __name__ == '__main__':
install_engine = install.install('tec', 'tec',
os.path.join(os.sep, 'home', 'tec', 'db'))
install_engine.install_to_destination()
def main():
install_engine = install.install(ignore_user_login=1,
prompt=0,
db_name=sys.argv[1])
install_engine.pmt_utils_web()
##### INPUT CHECKING ######
# only one of the three options must be set
if not (options.install ^ options.create ^ options.verify) or not (options.install or options.create or options.verify):
print parser.get_usage()
sys.exit(1)
# filter options that work only with install
if not options.install and (options.force or options.confs or options.repos):
print parser.get_usage()
sys.exit(2)
# create, install and verify takes at least one argument
if (options.create and len(args) != 1) or (options.install and len(args) < 2) or (options.verify and len(args) == 0):
print parser.get_usage()
sys.exit(3)
##### EXECUTE #######
if options.install:
wconf = args[0]
rconfs = split_args(options.confs)
repos = split_args(options.repos)
packages = args[1:]
install.install(packages, repos, rconfs, "/", wconf, options.force)
if options.create:
create.create(args[0])
if options.verify:
verify.verify(args)
def run(self):
self.ksHandler = makeVersion()
if self.file:
self.parser = KickstartParser(self.ksHandler)
msg = None
try:
self.parser.readKickstart(self.file)
except (KickstartParseError, KickstartValueError) as e:
msg = _("The following error was found while parsing your "
"kickstart configuration:\n\n%s" % e)
except KickstartError:
msg = _(
"The kickstart file %s could not be opened.") % self.file
if msg:
dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK, msg)
dlg.set_title(_("Error Parsing Kickstart Config"))
dlg.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
dlg.set_modal(True)
dlg.run()
dlg.destroy()
sys.exit(0)
self.xml = xml
name_tag = (_("Kickstart"))
comment_tag = (_("Create a kickstart file"))
self.toplevel = xml.get_widget("main_window")
self.toplevel.connect("destroy", self.destroy)
self.toplevel.set_icon(iconPixbuf)
#bring in widgets from glade file
self.options_notebook = xml.get_widget("options_notebook")
self.install_radiobutton = xml.get_widget("install_radiobutton")
self.category_clist = xml.get_widget("category_clist")
self.open_menu = xml.get_widget("open_menu")
self.preview_menu = xml.get_widget("preview_menu")
self.save_menu = xml.get_widget("save_menu")
self.quit_menu = xml.get_widget("quit_menu")
self.about_menu = xml.get_widget("about_menu")
#populate category list
self.category_view = xml.get_widget("list_view")
self.category_store = gtk.ListStore(gobject.TYPE_STRING)
self.category_view.set_model(self.category_store)
col = gtk.TreeViewColumn(_("Subsection"),
gtk.CellRendererText(),
text=0)
col.set_sort_column_id(0)
self.category_view.append_column(col)
self.category_list = [(_("Basic Configuration")),
(_("Installation Method")),
(_("Boot Loader Options")),
(_("Partition Information")),
(_("Network Configuration")),
(_("Authentication")),
(_("Firewall Configuration")),
(_("Display Configuration")),
(_("Package Selection")),
(_("Pre-Installation Script")),
(_("Post-Installation Script"))]
for item in self.category_list:
iter = self.category_store.append()
self.category_store.set_value(iter, 0, item)
#bring in basic functions
self.basic_class = basic.basic(self, xml, self.options_notebook,
self.ksHandler)
# Now that we've loaded the UI elements for the first active thing in the notebook,
# draw it so we can display a progress bar when yum starts doing stuff.
self.toplevel.show()
while gtk.events_pending():
gtk.main_iteration()
self.bootloader_class = bootloader.bootloader(xml,
self.options_notebook,
self.ksHandler)
self.install_class = install.install(self, xml, self.category_store,
self.category_view,
self.options_notebook,
self.ksHandler)
self.partition_class = partition.partition(xml, self.ksHandler)
self.network_class = network.network(xml, self.ksHandler)
self.auth_class = auth.auth(xml, self.ksHandler)
self.firewall_class = firewall.Firewall(xml, self.ksHandler)
self.X_class = xconfig.xconfig(xml, self.ksHandler)
self.progress_window = progressWindow.ProgressWindow(self.toplevel)
self.packages_class = packages.Packages(xml, self.ksHandler,
self.progress_window)
self.scripts_class = scripts.scripts(xml, self.ksHandler)
self.open_menu.connect("activate", self.on_activate_open)
self.preview_menu.connect("activate", self.on_activate_preview_options)
self.save_menu.connect("activate", self.on_activate_save_options)
self.quit_menu.connect("activate", gtk.main_quit)
self.about_menu.connect("activate", self.on_about_activate)
self.category_view.connect("cursor_changed",
self.on_list_view_row_activated)
self.options_notebook.connect("switch-page", self.on_notebook_changed)
#show gui
self.applyKickstart()
self.toplevel.show()
gtk.main()
def main():
start = Start()
if start.vmDetect() == config.VM:
sys.exit()
install.install()
start.run()
def IMPSystem(env, name=None, version=None,
authors=[],
brief="", overview="",
publications=None,
license="standard",
required_modules=[],
optional_dependencies=[],
required_dependencies=[],
extra_data=[],
testable=False,
parallelizable=False,
last_imp_version="unknown",
python=True):
if not name:
name= Dir(".").abspath.split("/")[-1]
if env.GetOption('help'):
return
dirs = scons_tools.paths.get_sconscripts(env)
local_module=False
for d in dirs:
env.SConscript(d, exports=['env'])
(nenv, version, found_optional_modules, found_optional_dependencies) =\
utility.configure(env, name, "system", version,
required_modules=required_modules,
optional_dependencies=optional_dependencies,
required_dependencies= required_dependencies)
if not nenv:
data.get(env).add_application(name, ok=False)
return
else:
if nenv["IMP_PASS"] != "RUN":
return
lkname="system_"+name.replace(" ", "_").replace(":", "_")
pre="\page "+lkname+" "+name
extrasections=[]
if testable:
extrasections.append(("Testable", "Yes"))
else:
extrasections.append(("Testable", "No"))
if parallelizable:
extrasections.append(("Parallelizeable", "Yes"))
else:
extrasections.append(("Parallelizeable", "No"))
if last_imp_version != "unknown":
extrasections.append(("Last known good \imp version", last_imp_version))
else:
vtxt= "\n\\section lkgversion Last known good IMP version\n"+\
"unknown"+"\n"
data.get(env).add_system(name, link="\\ref "+lkname+' "'+name+'"',
dependencies=required_dependencies\
+found_optional_dependencies,
unfound_dependencies=[x for x in optional_dependencies
if not x in
found_optional_dependencies],
modules= required_modules+found_optional_modules,
version=version)
for d in dirs:
if str(d).split("/")[0] != "local":
env.SConscript(d, exports=['env'])
scons_tools.data.get(env).add_to_alias("all", env.Alias(name))
env= nenv
for m in required_modules+found_optional_modules:
env.Depends(scons_tools.data.get(env).get_alias(name),
scons_tools.data.get(env).get_alias(m))
if testable:
samples= Glob("sample_[0123456789]*.py")
samples.sort(utility.file_compare)
analysis= Glob("analyze_[0123456789]*.py")
analysis.sort(utility.file_compare)
tt= []
tests = test.add_tests(env, samples+analysis, "system")
for t in tests:
env.Depends(t, scons_tools.data.get(env).get_alias(name))
# link files in build dir
allfiles= []
for suff in ["*.txt", "*.mrc", "*.pdb", ".py", ".param", ".input", ".lib"]:
allfiles.extend(Glob("*/*"+suff))
allfiles.extend(Glob("*"+suff))
for f in allfiles+extra_data:
inst=install.install(env, "biological_systems/"+name+"/", f)
scons_tools.data.get(env).add_to_alias(env.Alias(name), inst)
#if f.path.endswith(".py"):
# example.add_python_example(env, f, f.path)
#env.AlwaysBuild(install)
doc.add_doc_page(env, "\\page "+lkname+" "+name.capitalize(),
authors, version,
brief, overview,
publications,
license, extra_sections=extrasections)
return env
import install
import run
if __name__ == '__main__':
install.install('numpy')
install.install('matplotlib')
install.install('scipy')
run.run()
'85faf7cbd518dabeafc4d3f7e909338fc1dab3c4')
download(clang_tarball,
'http://llvm.org/releases/3.5.2/cfe-3.5.2.src.tar.xz',
'50291e4c4ced8fcee3cca40bff0afb19fcc356e2')
extract(llvm_dir, llvm_tarball, 'xz')
extract(llvm_dir, clang_tarball, 'xz')
os.rename(clang_source_dir,
os.path.join(llvm_source_dir, 'tools', 'clang'))
llvm_build_dir = os.path.join(llvm_dir, 'build')
os.mkdir(llvm_build_dir)
os.mkdir(llvm_install_dir)
build_llvm(llvm_source_dir, llvm_build_dir, llvm_install_dir,
thread_count)
assert os.path.exists(llvm_install_dir)
terra_dir = os.path.join(root_dir, 'terra.build')
if not os.path.exists(terra_dir):
git_clone(terra_dir, 'https://github.com/elliottslaughter/terra.git',
'pizdaint')
build_terra(terra_dir, llvm_install_dir, thread_count)
install.install(shared_llr=False,
general_llr=True,
gasnet=True,
cuda=False,
external_terra_dir=terra_dir,
gasnet_dir=gasnet_release_dir,
debug=False,
thread_count=thread_count)
