async def _run_docking(self):
receptor = self._selected_receptor
ligands = self._selected_ligands
site = None
if self._selected_site:
site = self._selected_site
if not receptor or not ligands:
if self._selected_site is None:
Logs.warning(
"Trying to run docking without having one receptor, one site and at least one ligand selected"
)
return
self.loading_bar.percentage = 0
self.enable_loading_bar()
self.make_plugin_usable(False)
try:
await self._plugin.run_docking(self._selected_receptor, ligands,
site, self.get_params())
except Exception as e:
message = f'{type(e).__name__}: {next(iter(e.args), "Error Occurred. Please Check Logs.")}'
Logs.error(message)
self._plugin.send_notification(NotificationTypes.error, message)
self.make_plugin_usable(True)
self.enable_loading_bar(False)
def _receive(self):
payload = None
try:
has_data = self._process_conn.poll()
if has_data:
payload = self._process_conn.recv()
except BrokenPipeError:
Logs.debug("Pipe has been closed, exiting process")
self._plugin._on_stop()
return False
if payload:
if payload == stop_bytes:
Logs.debug("Pipe has been closed, exiting process")
self._plugin._on_stop()
return False
received_object, command_hash, request_id = self._serializer.deserialize_command(
payload, self.__version_table)
if received_object == None and command_hash == None and request_id == None:
return True # Happens if deserialize_command returns None, an error message is already displayed in that case
try:
callback = self._serializer._command_callbacks[command_hash]
except:
Logs.error("Received a command without callback associated:",
command_hash)
return True
callback(self, received_object, request_id)
return True
def __start_process(self):
entry = self.__pending.popleft()
entry.send(_ProcessManager.process_data_type_starting, [])
request = entry.request
args = [request.executable_path] + request.args
has_text = entry.output_text
def enqueue_output(out, err, queue_out, queue_err, text):
if text:
sentinel = ''
else:
sentinel = b''
for line in iter(err.readline, sentinel):
queue_err.put(line)
err.close()
for line in iter(out.readline, sentinel):
queue_out.put(line)
out.close()
try:
entry.process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1, cwd=request.cwd_path, universal_newlines=has_text, close_fds=POSIX)
Logs.debug("Process started:", request.executable_path, "for session", entry.session._session_id)
except:
Logs.error("Couldn't execute process", request.executable_path, "Please check if executable is present and has permissions:\n", traceback.format_exc())
entry.send(_ProcessManager.process_data_type_done, [-1])
return
entry.stdout_queue = Queue()
entry.stderr_queue = Queue()
thread = Thread(target=enqueue_output, args=(entry.process.stdout, entry.process.stderr, entry.stdout_queue, entry.stderr_queue, has_text))
thread.daemon = True
thread.start()
self.__running.append(entry)
def init_hashes():
hashes = dict()
i = -1
for command in _Commands:
i += 1
hash = hash_command(command.name)
if hash in hashes:
Logs.error("Command hash collision detected:", command.name, "and",
hashes[hash])
continue
hashes[hash] = command.name
_Hashes.CommandHashes[i] = hash
hashes.clear()
i = -1
for command in _Messages:
i += 1
hash = hash_command(command.name)
if hash in hashes:
Logs.error("Message hash collision detected:", command.name, "and",
hashes[hash])
continue
hashes[hash] = command.name
_Hashes.MessageHashes[i] = hash
def write_json(helper, content):
if (content is None):
return None
elif (isinstance(content, _Button)):
type_name = "Button"
_button_json.write_json(helper, content)
elif (isinstance(content, _Mesh)):
type_name = "Mesh"
_mesh_json.write_json(helper, content)
elif (isinstance(content, _Slider)):
type_name = "Slider"
_slider_json.write_json(helper, content)
elif (isinstance(content, _TextInput)):
type_name = "TextInput"
_text_input_json.write_json(helper, content)
elif (isinstance(content, _Label)):
type_name = "Label"
_label_json.write_json(helper, content)
elif (isinstance(content, _UIList)):
type_name = "List"
_ui_list_json.write_json(helper, content)
elif (isinstance(content, _Image)):
type_name = "Image"
_image_json.write_json(helper, content)
elif (isinstance(content, _LoadingBar)):
type_name = "LoadingBar"
_loading_bar_json.write_json(helper, content)
else:
Logs.error("unknown content type: " + str(type(content)))
return None
helper.write("type_name", type_name)
def load_molecule(self, code):
url_to_load = url.replace("{{NAME}}", code)
response = requests.get(url_to_load)
file = tempfile.NamedTemporaryFile(delete=False)
self._name = code
try:
file.write(response.text.encode("utf-8"))
file.close()
if type == "PDB":
complex = nanome.structure.Complex.io.from_pdb(path=file.name)
self.add_bonds([complex], self.bonds_ready)
elif type == "SDF":
complex = nanome.structure.Complex.io.from_sdf(path=file.name)
self.bonds_ready([complex])
elif type == "MMCIF":
complex = nanome.structure.Complex.io.from_mmcif(
path=file.name)
self.add_bonds([complex], self.bonds_ready)
else:
Logs.error("Unknown file type")
except: # Making sure temp file gets deleted in case of problem
self._loading = False
Logs.error("Error while loading molecule:\n",
traceback.format_exc())
os.remove(file.name)
def on_stream_creation(stream, error):
if error != StreamCreationError.NoError:
Logs.error("Error while creating stream")
return
self.__stream = stream
self.__data_queue = deque()
cwd_path = self.__nanobabel_dir
exe = 'nanobabel.exe' if IS_WIN else 'nanobabel'
exe_path = os.path.join(cwd_path, exe)
args = [
'minimize', '-h', '-l', '20', '-n',
str(steps), '-ff', ff, '-i', input_file.name, '-cx',
constraints_file.name, '-o', output_file.name
]
if IS_WIN:
args += ['-dd', 'data']
if steepest:
args.append('-sd')
Logs.debug(args)
p = Process(exe_path, args, True)
p.on_error = self.__on_process_error
p.on_output = self.__on_process_output
p.on_done = self.__on_process_done
p.start()
self.__process = p
self.__process_running = True
self._is_running = True
def deserialize(self, version, context):
ui_type = _UIBaseSerializer.ContentType(context.read_uint())
try:
serializer = _UIBaseSerializer.registered_serializers[ui_type]
except:
Logs.error("Trying to deserialize unknown UI type:", ui_type)
return
return context.read_using_serializer(serializer)
def parse_value(str, parser):
if parser == None:
return str
try:
return parser(str)
except:
Logs.error("Wrong value:", str, "\nExpected:", parser)
sys.exit(1)
def main():
if not NANOBABEL:
Logs.error('Error: nanobabel not found, please set NANOBABEL env var')
sys.exit(1)
plugin = nanome.Plugin("Minimization", "Run minimization on selected structures. See Advanced Parameters for forcefield, number of steps, and steepest descent", "Minimization", True)
plugin.set_plugin_class(Minimization)
plugin.run()
def _receive_create_stream_result(network, result, request_id):
if result[0] != StreamCreationError.NoError:
network._call(request_id, None, result[0])
if result[0] == StreamCreationError.UnsupportedStream:
Logs.error("Tried to create an unsupported type of stream")
return
stream = Stream(network, result[1], result[2], result[3])
network._call(request_id, stream, StreamCreationError.NoError)
def _receive_interrupt_stream(network, result, request_id):
try:
stream = Stream._streams[result[1]]
except:
Logs.error(
"Got an error for an unknown stream. Probably tried to update an unknown stream:",
result[1])
return
stream._interrupt(result[0])
def to_json(self, path):
helper = _JsonHelper()
_menu_json.write_json(helper, self.base_object)
menu_string = json.dumps(helper.get_dict())
try:
with open(path, "w") as f:
f.write(menu_string)
except:
Logs.error("Could not write to file: " + path)
raise
def run_test(test, counter):
try:
Logs.debug("\trunning test", test.__name__)
counter.total += 1
test()
except Exception as err:
Logs.error("\ttest failed.")
print(traceback.format_exc())
else:
counter.passed += 1
def __bonding_done(self, result_code):
if result_code == -1:
Logs.error("Couldn't execute openbabel to generate bonds. Is it installed?")
self.__callback(self.__complexes)
return
with open(self.__output.name) as f:
lines = f.readlines()
content = _sdf.parse_lines(lines)
result = _sdf.structure(content)
self.__match_and_bond(result)
self.__next()
def __dssp_done(self, result_code):
if result_code != 0:
Logs.error("DSSP failed, code:", result_code)
self.__callback(self.__complexes)
return
with open(self.__output.name) as f:
lines = f.readlines()
secondary = self.__parse_dssp(lines)
Logs.debug(secondary)
self.__current_complex_result.append(secondary)
self.__next()
def _parse_lines(lines):
lines = [line.rstrip() for line in lines]
# Content structure
lines = _CIF_Lines(lines)
try:
parsed_file = ParseLines(lines)
except Exception:
Logs.error("\tParse failed. Error on line:", lines.get_line_number())
Logs.error(traceback.format_exc())
content = raw_to_formatted(parsed_file)
return content
def get_data_category(line):
match = re.match(category_regex, line)
if (match == None):
Logs.error(line)
return
category = match.group(1)
key = match.group(2)
value = match.group(3)
if category == None:
category = "Misc"
return category, key, value
def on_directory_received(self, result):
# If API couldn't access directory, display error
if result.error_code != nanome.util.DirectoryErrorCode.no_error:
Logs.error('Directory request error:', str(result.error_code))
return
# For each entry in directory, display name and if directory
for entry in result.entry_array:
Logs.debug(entry.name, 'Is Directory?', entry.is_directory)
if entry.name == 'temp':
self.request_files(['/temp/matryx_wallet.json'],
self.on_files_received) # Read matryx.txt
def connect(self, host, port):
try:
self._connection.connect((host, port))
self._connection.setblocking(False)
Logs.message("Connected to server", host, port)
except (ssl.SSLError, socket.error) as e:
self._socket = None
self._context = None
self._connection = None
Logs.error("Cannot connect to plugin server at", host, port, e)
return False
return True
def on_stream_creation(self, stream, error):
self.__waiting_for_complexes = False
if error == StreamCreationError.AtomNotFound:
Logs.error("Tried to create a stream with bad atoms")
self.stop_simulation()
return
self.__stream = stream
self.__process.set_stream(stream)
end = timer()
Logs.debug("Stream creation:", end - self.__start)
self.__run_simulation(self.__complex_list)
def _received_request(self, data, session):
type = data[0]
if type == _ProcessManager._CommandType.start:
request = data[1]
entry = _ProcessEntry(request, session)
self.__pending.append(entry)
session.send_process_data(
[_ProcessManager._DataType.queued, request])
elif type == _ProcessManager._CommandType.stop:
self.__stop_process(data[1])
else:
Logs.error("Received unknown process command type")
def workspace_received(workspace):
try:
self.save_workspace(workspace, file)
except:
self.send_notification(
NotificationTypes.error,
"Failed to save workspace, check plugin")
Logs.error("Failed to save workspace", traceback.format_exc())
self.btn_save.unusable = False
self.update_content(self.btn_save)
file.close()
self.refresh_menu()
self.__timer = timer()
def serialize(self, version, value, context):
if value == None:
return
try:
ui_type = _UIBaseSerializer.registered_classes[type(
value).__name__]
serializer = _UIBaseSerializer.registered_serializers[ui_type]
except:
Logs.error("Trying to serialize unknown UI type:",
type(value).__name__)
return
context.write_uint(ui_type)
context.write_using_serializer(serializer, value)
async def run(self, src_complex: Complex):
with tempfile.TemporaryDirectory() as work_dir:
pdb_path = path.join(work_dir, "mol.pdb")
pqr_path = path.join(work_dir, "mol.pqr")
map_path = path.join(work_dir, "map")
src_complex.io.to_pdb(pdb_path)
try:
pqr_struct = await self.run_pdb2pqr(pdb_path, pqr_path)
volume = await self.run_apbs(work_dir, pqr_struct, pqr_path,
map_path)
return [pqr_parser.structure_to_complex(pqr_struct), volume]
except Exception as e:
Logs.error(e)
return None
def from_json(self, path):
try:
with open(path, "r") as f:
menu_string = f.read()
menu_json = json.loads(menu_string)
except:
Logs.error("Could not read json file: " + path)
raise
try:
json_helper = _JsonHelper(menu_json)
return _menu_json.parse_json(json_helper)
except:
Logs.error("Json does not correctly represent a menu.")
raise
def set_complexes(complex_list):
self._respond_to_update = True
self._complexes = complex_list
self._ligand_names = []
self._ligand_atom_counts = {}
self._ligand_frames = {}
atom_counts = [0 for _ in range(len(complex_list))]
for complex_i in range(0, len(complex_list)):
complex = complex_list[complex_i]
complex.locked = True
complex = complex_list[complex_i].convert_to_frames()
complex.index = complex_list[complex_i].index
complex_list[complex_i] = complex
molecule_list = list(complex.molecules)
atom_counts[complex_i] = len(
list(molecule_list[complex.current_frame].atoms))
for atom in complex_list[complex_i].atoms:
atom._old_position = atom.position
if complex_i > 0:
if (atom_counts[complex_i] > atom_counts[0]):
err_msg = "Error with receptor/ligand combination. Ligand cannot be larger than receptor."
Logs.error(err_msg)
self.send_notification(NotificationTypes.error,
err_msg)
self.stop_scoring()
return
self._ligand_frames[complex.index] = complex.current_frame
self._ligand_atom_counts[
complex.index] = atom_counts[complex_i]
self._ligand_names.append(
complex_list[complex_i].full_name)
for residue in complex_list[complex_i].residues:
residue.labeled = False
for atom in complex_list[complex_i].atoms:
atom.labeled = self.settings._labels
complex_updated_callback = functools.partial(
self.complex_updated, complex_list[1:])
complex_list[complex_i].register_complex_updated_callback(
complex_updated_callback)
self.unfreeze_button("Stop scoring")
self.hide_scores(True)
self._respond_to_update = False
self.update_structures_deep(
complex_list[0:],
functools.partial(self.request_complexes, index_list[1:],
self.setup_spheres))
def to_json(self, path):
helper = _JsonHelper()
helper.write("is_menu", False)
helper.write("title", "node")
child = helper.make_instance()
_layout_node_json.write_json(child, self.base_object)
helper.write("effective_root", child)
node_string = json.dumps(helper.get_dict())
try:
with open(path, "w") as f:
f.write(node_string)
except:
Logs.error("Could not write to file: " + path)
raise
def receive(self):
try:
data = self._connection.recv(4096)
except ssl.SSLWantReadError:
time.sleep(0.01)
except ssl.SSLEOFError:
Logs.error("Connection closed by plugin server")
return False
except KeyboardInterrupt:
raise
except:
Logs.error(traceback.format_exc())
return False
else:
self._received_data(data)
return True
def from_json(self, path):
try:
with open(path) as f:
node_string = f.read()
node_json = json.loads(node_string)
except:
Logs.error("Could not read json file: " + path)
raise
try:
json_helper = _JsonHelper(node_json)
assert (json_helper.read("is_menu", False) == False)
return _layout_node_json.parse_json(
json_helper.read_object("effective_root"))
except:
Logs.error("Json does not correctly represent a layout node.")
raise