def cli_main():
"""
Enable mdstudio_cli as a command line tool
Main entry point function called from the mdstudio-cli command line tool
created by Python setuptools upon package installation.
"""
# Override txaio logger to print result to stdout
lg = logging.getLogger('clilogger')
lg.setLevel(logging.INFO)
lg.addHandler(logging.StreamHandler(sys.stdout))
# Parse command line arguments
config = mdstudio_cli_parser()
main(CliWampApi,
auto_reconnect=False,
log_level=config['log_level'],
extra=config,
daily_log=False)
from mdstudio.runner import main
from mdstudio_amber.wamp_services import AmberWampApi
if __name__ == '__main__':
main(AmberWampApi)
from mdstudio.runner import main
from lie_ti.ti_endpoints import Gromacs_ti_wamp_api
if __name__ == '__main__':
main(Gromacs_ti_wamp_api)
})
print("promised job: ", data)
print("running sequential version")
output = yield self.call(
"mdgroup.mdstudio_gromacs.endpoint.gromacs_ligand", {
"cerise_file": create_path_file_obj(cerise_file),
"ligand_file": create_path_file_obj(ligand_file),
"protein_file": None,
"protein_top": create_path_file_obj(protein_top),
"topology_file": create_path_file_obj(topology_file),
"include": list(map(create_path_file_obj, include)),
"workdir": workdir,
"clean_remote_workdir": False,
"parameters": {
"sim_time": 0.001,
"residues": residues
}
})
print("output sequential: ", output)
output2 = yield self.call(
"mdgroup.mdstudio_gromacs.endpoint.query_gromacs_results", data)
print("MD output async: ", output2)
if __name__ == "__main__":
main(Run_md)
# -*- coding: utf-8 -*-
from mdstudio.runner import main
from mdstudio_workflow.wamp_services import WorkflowWampApi
if __name__ == '__main__':
main(WorkflowWampApi)
@chainable
def on_run(self):
# Convert SMILES string into 1D mol2 file
# Note: the SMILES string is defined as 'path_file' object
mol = yield self.call('mdgroup.mdstudio_structures.endpoint.convert',
{"output_format": "mol2",
"mol": {"content": "O1[C@@H](CCC1=O)CCC",
"extension": "smi",
"path": None}
})
# Convert 1D mol2 file into 3D PDB file
# Note: the returned 'mol' path_file object is used as input for make3D
pdb = yield self.call(
'mdgroup.mdstudio_structures.endpoint.make3d',
{'input_format': 'mol2',
'output_format': 'pdb',
'mol': mol['mol']})
print(pdb['mol']['content'])
# Disconnect from broker and stop reactor event loop
self.disconnect()
reactor.stop()
if __name__ == '__main__':
main(PythonExample, daily_log=False)
raise AssertionError('Structures are not the same')
print('successful creation of a 3D structure for {}'.format(
dict_convert['mol']))
addh = yield self.call(
'mdgroup.mdstudio_structures.endpoint.addh', dict_addh)
if not compare_molecules(addh['mol']['content'], join(root, 'files/structureHs.mol2')):
raise AssertionError('Structures are not the same')
print('added hydrogens sucessfully!')
info = yield self.call('mdgroup.mdstudio_structures.endpoint.info', dict_info)
print('info', info)
atts = info['attributes']
if not all((atts['formula'] == 'C7H12O2', atts['exactmass'] - 128.083729624 < 1e-5)):
raise AssertionError('Structures are not the same')
print('attributes information successfully retrieved!')
rotate = yield self.call('mdgroup.mdstudio_structures.endpoint.rotate', dict_rotate)
if not compare_molecules(rotate['mol']['content'], join(root, 'files/rotations.mol2')):
raise AssertionError('Structures are not the same')
print('rotatation method succeeded!')
similarity = yield self.call('mdgroup.mdstudio_structures.endpoint.chemical_similarity', dict_similarity)
if not similarity['results']['idx_max_sim']['0'] == 20:
raise AssertionError('Similarity not the same')
print('Similarity method succeeded!')
if __name__ == '__main__':
main(RunStructures)
from mdstudio.runner import main
from mdstudio_plants_docking.wamp_services import DockingWampApi
if __name__ == '__main__':
main(DockingWampApi)
init_time = None
def authorize_request(self, uri, claims):
return True
def append(self, result, number):
result = result['number']
print('Result {0} for {1} after {2} seconds'.format(result, number, int(time.time()) - self.init_time))
@chainable
def on_run(self):
# Register start time
self.init_time = int(time.time())
# Run a few numbers through the roundrobin endpoint.
# These are async calls, we process the results in a separate 'callback'
# function.
# - Use 'parallel' endpoint to speed things up by round robin load
# balancing over multiple instances of the roundrobin microservice.
# - Use 'sequential' endpoint to run the code sequential.
for number in range(4):
response = self.call('mdgroup.roundrobin.endpoint.sequential', {"number": number})
response.addCallback(self.append, number)
if __name__ == '__main__':
main(UserSession, daily_log=False)
# -*- coding: utf-8 -*
import os
import sys
modulepath = os.path.abspath(os.path.join(os.path.dirname(__file__), '../'))
sys.path.insert(0, modulepath)
from mdstudio.runner import main
from roundrobin.application import RoundrobinComponent
if __name__ == '__main__':
main(RoundrobinComponent, daily_log=False)
uri='mdgroup.lie_pylie.endpoint.adan_residue_decomp',
inline_files=False)
t23.set_input(model_pkl=modelpicklefile,
decompose_files=decompose_files)
wf.connect_task(t18.nid, t23.nid)
# Applicability domain: 3. deltaG energy range
t24 = wf.add_task('AD3 dene yrange',
task_type='WampTask',
uri='mdgroup.lie_pylie.endpoint.adan_dene_yrange')
t24.set_input(ymin=modelfile['AD']['Yrange']['min'],
ymax=modelfile['AD']['Yrange']['max'])
wf.connect_task(t21.nid, t24.nid, 'liedeltag_file', liedeltag_file='dataframe')
# Applicability domain: 4. deltaG energy distribution
t25 = wf.add_task('AD4 dene distribution',
task_type='WampTask',
uri='mdgroup.lie_pylie.endpoint.adan_dene')
t25.set_input(model_pkl=modelpicklefile,
center=list(modelfile['AD']['Dene']['Xmean']),
ci_cutoff=modelfile['AD']['Dene']['Maxdist'])
wf.connect_task(t21.nid, t25.nid, 'liedeltag_file', liedeltag_file='dataframe')
wf.run()
while wf.is_running:
yield sleep(1)
if __name__ == "__main__":
main(LIEPredictionWorkflow)
import os
workdir = "/tmp/mdstudio_amber"
structure_path = os.path.join(os.getcwd(), "input.mol2")
with open(structure_path, 'r') as f:
amber_input = f.read()
structure = {
"path": structure_path,
"content": amber_input,
"extension": "mol2"
}
class Run_acpype(ComponentSession):
def authorize_request(self, uri, claims):
return True
@chainable
def on_run(self):
result = yield self.call("mdgroup.mdstudio_amber.endpoint.acpype", {
"structure": structure,
"workdir": workdir
})
print(result)
# assert all(os.path.isfile(p) or os.path.isdir(p) for p in result.values())
if __name__ == "__main__":
main(Run_acpype)
def on_run(self):
result = yield self.call(
u"mdgroup.mdstudio_plants_docking.endpoint.docking", {
u"protein_file":
protein_file,
u"ligand_file":
ligand_file,
u"min_rmsd_tolerance":
3.0,
u"cluster_structures":
100,
u"bindingsite_radius":
12.0,
u"bindingsite_center":
[4.926394772324452, 19.079624537618873, 21.98915631296689],
u"workdir":
workdir
})
if result['status'] != 'completed':
raise AssertionError('Docking failed, status: {0}'.format(
result['status']))
if not all('path' in val for _, val in result['output'].items()):
raise AssertionError('Not all expected output files created')
print("Docking finished successfully!")
if __name__ == "__main__":
main(Run_docking)
def copy_to_workdir(file_path, workdir):
# shutil.copy(file_path, workdir)
base = os.path.basename(file_path)
return os.path.join(workdir, base)
workdir = "/tmp/mdstudio/mdstudio_haddock"
project_file = copy_to_workdir(
os.path.join(os.getcwd(), "easy_run_server_ref.web"), workdir)
class Run_haddock(ComponentSession):
def authorize_request(self, uri, claims):
return True
@chainable
def on_run(self):
result = yield self.call(
"mdgroup.mdstudio_haddock.endpoint.submit_project", {
"project_id": project_file,
"haddock_username": "",
"haddock_password": ""
})
print(result['project_id'])
if __name__ == "__main__":
main(Run_haddock)
result_average = yield self.call(
"mdgroup.mdstudio_pylie.endpoint.calculate_lie_average",
dict_average)
assert compare_csv_files(result_average["averaged"]['content'],
dict_deltag["dataframe"]['content'])
print("method calculate_lie_average succeeded!")
result_liedeltag = yield self.call(
"mdgroup.mdstudio_pylie.endpoint.liedeltag", dict_deltag)
assert compare_csv_files(result_liedeltag["liedeltag_file"]['content'],
dict_adan_yrange["dataframe"]['content'])
print("method liedeltag succeeded!")
result_adan_yrange = yield self.call(
"mdgroup.mdstudio_pylie.endpoint.adan_dene_yrange",
dict_adan_yrange)
assert compare_dictionaries(result_adan_yrange["decomp"],
expected_adan_yrange_results)
print("method adan_dene_yrange succeeded!")
result_adan_dene = yield self.call(
"mdgroup.mdstudio_pylie.endpoint.adan_dene", dict_adan_dene)
assert compare_dictionaries(result_adan_dene["decomp"],
expected_adan_results)
print("method adan_dene succeeded!")
if __name__ == "__main__":
main(Run_pylie)
# -*- coding: utf-8 -*-
import os
import sys
from mdstudio.runner import main
# Try import package
try:
from mdstudio_gromacs.wamp_services import MDWampApi
except ImportError:
# Add modules in package to path
modulepath = os.path.abspath(os.path.join(os.path.dirname(__file__),
'../'))
if modulepath not in sys.path:
sys.path.insert(0, modulepath)
from mdstudio_gromacs.wamp_services import MDWampApi
if __name__ == '__main__':
main(MDWampApi)
from mdstudio.deferred.chainable import chainable
from mdstudio.component.session import ComponentSession
from mdstudio.runner import main
import os
import shutil
workdir = "/tmp/propka"
if os.path.exists(workdir):
shutil.rmtree(workdir)
class Run_propka(ComponentSession):
def authorize_request(self, uri, claims):
return True
@chainable
def on_run(self):
with self.group_context('mdgroup'):
self.call('mdgroup.mdstudio_propka.endpoint.propka',
{"workdir": workdir})
if __name__ == "__main__":
main(Run_propka)
# mol2 If 'output_format' is not specified it is deduced from
# the input wich is mol2 in this case. There are circumstances
# where conversion to 3D fails, retry upto 3 times.
t4 = wf.add_task('Make_3D',
task_type='WampTask',
uri='mdgroup.mdstudio_structures.endpoint.make3d',
retry_count=3)
wf.connect_task(t3.nid, t4.nid, 'mol')
wf.connect_task(t1.nid, t4.nid, 'steps')
# Task 5: Empty task that server as a collector for all results
# obtained during iteration.
t5 = wf.add_task('Collector')
wf.connect_task(t4.nid, t5.nid, 'mol')
# Set the array of input SMILES string to task 1
wf.input(t1.nid,
smiles=[
'O1[C@@H](CCC1=O)CCC',
'C[C@]12CC[C@H]3[C@@H](CC=C4CCCC[C@]34CO)[C@@H]1CCC2=O',
'CC12CCC3C(CC=C4C=CCCC34C)C1CCC2=O'
])
wf.run()
while wf.is_running:
yield sleep(1)
if __name__ == "__main__":
main(LoopDemonstrationWorkflow, auto_reconnect=False, daily_log=False)
wf.save('workflow_spec.jgf')
# Lets run the workflow specification for a number of ligand SMILES
# The current microservice instance (self) is passed as task_runner to the workflow
# it will be used to make calls to other microservice endpoints when task_type equals WampTask.
wf.task_runner = self
currdir = os.getcwd()
for i, ligand in enumerate([
'O1[C@@H](CCC1=O)CCC',
'C[C@]12CC[C@H]3[C@@H](CC=C4CCCC[C@]34CO)[C@@H]1CCC2=O',
'CC12CCC3C(CC=C4C=CCCC34C)C1CCC2=O'
],
start=1):
wf.load('workflow_spec.jgf')
wf.input(t1.nid,
mol={
'content': ligand,
'path': None,
'extension': ligand_format
})
wf.run(project_dir='./ligand-{0}'.format(i))
while wf.is_running:
yield sleep(1)
os.chdir(currdir)
if __name__ == "__main__":
main(ExampleWorkflow, auto_reconnect=False, daily_log=False)
from mdstudio.runner import main
from mdstudio_propka.wamp_services import PropkaWampApi
if __name__ == '__main__':
main(PropkaWampApi)
from mdstudio.runner import main
from mdstudio_atb.wamp_services import ATBWampApi
if __name__ == '__main__':
main(ATBWampApi)
# -*- coding: utf-8 -*
import os
import sys
modulepath = os.path.abspath(os.path.join(os.path.dirname(__file__), '../'))
sys.path.insert(0, modulepath)
from mdstudio.runner import main
from hello_world.application import HelloWorldComponent
if __name__ == '__main__':
main(HelloWorldComponent)
if args.base_work_dir:
# Set dynamic base_work_dir as environmental variable accessible from else where
os.environ['BASE_WORK_DIR'] = args.base_work_dir
# Start results cleanup event if 'base_work_dir' and 'result_storage_time' are set
if args.result_storage_time > 0:
p = PeriodicCleanup(args.base_work_dir, args.result_storage_time)
p.start()
# Start service REST or WAMP API
if args.api_mode == 'wamp':
logging.debug('Start {0} WAMP interface at {1}'.format(
__module__, __package_path__))
main(SmartCypWampApi)
else:
logging.debug('Start {0} REST interface at {1}'.format(
__module__, __package_path__))
app = connexion.App(__name__, specification_dir='./rest/')
app.add_api('smartcyp_openapi.yaml',
arguments={'title': 'MDStudio SMARTCyp REST API'})
CORS(app.app)
# Serve app using production ready gevent WSGIServer
http_server = WSGIServer(('', args.http_port), app)
http_server.serve_forever()
# -*- coding: utf-8 -*-
import sys
import os
modulepath = os.path.abspath(os.path.join(os.path.dirname(__file__), '../'))
if modulepath not in sys.path:
sys.path.insert(0, modulepath)
from mdstudio.runner import main
from common_resources.resources_endpoints import Common_resources
if __name__ == '__main__':
main(Common_resources)
from mdstudio.deferred.chainable import chainable
from mdstudio.component.session import ComponentSession
from mdstudio.runner import main
import os
cwd = os.path.dirname(os.path.abspath(__file__))
path_test_file = os.path.join(cwd, "files/input.mol2")
with open(path_test_file, 'r') as f:
content = f.read()
dict_path_file = {
"content": content,
"path": path_test_file,
"extension": ".mol2"
}
class Run_test_resources(ComponentSession):
def authorize_request(self, uri, claims):
return True
@chainable
def on_run(self):
yield self.call("mdgroup.common_resources.endpoint.call_path_file",
{"path_file": dict_path_file})
if __name__ == "__main__":
main(Run_test_resources)
t23.set_input(model_pkl=modelpicklefile)
wf.connect_task(t17.nid, t23.nid, 'decomp_files')
# Applicability domain: 3. deltaG energy range
t24 = wf.add_task('AD3 dene yrange',
task_type='WampTask',
uri='mdgroup.lie_pylie.endpoint.adan_dene_yrange')
t24.set_input(ymin=modelfile['AD']['Yrange']['min'],
ymax=modelfile['AD']['Yrange']['max'])
wf.connect_task(t21.nid, t24.nid, liedeltag_file='dataframe')
# Applicability domain: 4. deltaG energy distribution
t25 = wf.add_task('AD4 dene distribution',
task_type='WampTask',
uri='mdgroup.lie_pylie.endpoint.adan_dene')
t25.set_input(model_pkl=modelpicklefile,
center=list(modelfile['AD']['Dene']['Xmean']),
ci_cutoff=modelfile['AD']['Dene']['Maxdist'])
wf.connect_task(t21.nid, t25.nid, liedeltag_file='dataframe')
# Save the workflow specification
wf.save('workflow_spec.jgf')
wf.run()
while wf.is_running:
yield sleep(1)
if __name__ == "__main__":
main(LIEWorkflow, auto_reconnect=False, daily_log=False)
u'mdgroup.mdstudio_smartcyp.endpoint.docking_structures', {
'paths': means,
'create_ensemble': False
})
self.assertEqual(len(result['result']), len(means))
print('Test SPORES get info endpoint')
result = yield self.call(
u'mdgroup.mdstudio_smartcyp.endpoint.spores_info', {})
self.assertEqual(result['status'], 'completed')
self.assertIsInstance(result['info'], dict)
self.assertItemsEqual(result['info'].keys(),
(u'version', u'default_settings', u'citation'))
print('Test SPORES run')
request = {
'mol': create_path_file_obj(os.path.join(root, "ligand.mol2")),
'input_format': 'mol2'
}
result = yield self.call(u'mdgroup.mdstudio_smartcyp.endpoint.spores',
request)
self.assertEqual(result['status'], 'completed')
self.assertIsInstance(result['result'], dict)
self.assertEqual(result['result']['content'].startswith('@<TRIPOS>'),
True)
if __name__ == "__main__":
main(MDStudioSMARTCypWAMPTests)
# Applicability domain: 3. deltaG energy range
t24 = wf.add_task('AD3 dene yrange',
task_type='WampTask',
uri='mdgroup.lie_pylie.endpoint.adan_dene_yrange')
t24.set_input(ymin=modelfile['AD']['Yrange']['min'],
ymax=modelfile['AD']['Yrange']['max'])
wf.connect_task(t21.nid,
t24.nid,
'liedeltag_file',
liedeltag_file='dataframe')
# Applicability domain: 4. deltaG energy distribution
t25 = wf.add_task('AD4 dene distribution',
task_type='WampTask',
uri='mdgroup.lie_pylie.endpoint.adan_dene')
t25.set_input(model_pkl=modelpicklefile,
center=list(modelfile['AD']['Dene']['Xmean']),
ci_cutoff=modelfile['AD']['Dene']['Maxdist'])
wf.connect_task(t21.nid,
t25.nid,
'liedeltag_file',
liedeltag_file='dataframe')
wf.run()
while wf.is_running:
yield sleep(1)
if __name__ == "__main__":
main(LIEPredictionWorkflow, auto_reconnect=False, daily_log=False)
from mdstudio.runner import main
from mdstudio_structures.wamp_services import StructuresWampApi
if __name__ == '__main__':
main(StructuresWampApi)
from mdstudio.runner import main
from pylie.wamp_services import PylieWampApi
if __name__ == '__main__':
main(PylieWampApi)
