# -*- coding: utf-8 -*-
###########################################################################
# Copyright (c), The AiiDA team. All rights reserved. #
# This file is part of the AiiDA code. #
# #
# The code is hosted on GitHub at https://github.com/aiidateam/aiida-core #
# For further information on the license, see the LICENSE.txt file #
# For further information please visit http://www.aiida.net #
###########################################################################
"""Top level functions that can be used to launch a Process."""
from aiida.common import InvalidOperation
from aiida.manage import manager
from .processes.functions import FunctionProcess
from .processes.process import Process
from .utils import is_process_function, is_process_scoped, instantiate_process
__all__ = ('run', 'run_get_pk', 'run_get_node', 'submit')
[docs]def run(process, *args, **inputs):
"""Run the process with the supplied inputs in a local runner that will block until the process is completed.
:param process: the process class or process function to run
:type process: :class:`aiida.engine.Process`
:param inputs: the inputs to be passed to the process
:type inputs: dict
:return: the outputs of the process
:rtype: dict
"""
if isinstance(process, Process):
runner = process.runner
else:
runner = manager.get_manager().get_runner()
return runner.run(process, *args, **inputs)
[docs]def run_get_node(process, *args, **inputs):
"""Run the process with the supplied inputs in a local runner that will block until the process is completed.
:param process: the process class or process function to run
:type process: :class:`aiida.engine.Process`
:param inputs: the inputs to be passed to the process
:type inputs: dict
:return: tuple of the outputs of the process and the process node
:rtype: (dict, :class:`aiida.orm.ProcessNode`)
"""
if isinstance(process, Process):
runner = process.runner
else:
runner = manager.get_manager().get_runner()
return runner.run_get_node(process, *args, **inputs)
[docs]def run_get_pk(process, *args, **inputs):
"""Run the process with the supplied inputs in a local runner that will block until the process is completed.
:param process: the process class or process function to run
:type process: :class:`aiida.engine.Process`
:param inputs: the inputs to be passed to the process
:type inputs: dict
:return: tuple of the outputs of the process and process node pk
:rtype: (dict, int)
"""
if isinstance(process, Process):
runner = process.runner
else:
runner = manager.get_manager().get_runner()
return runner.run_get_pk(process, *args, **inputs)
[docs]def submit(process, **inputs):
"""Submit the process with the supplied inputs to the daemon immediately returning control to the interpreter.
.. warning: this should not be used within another process. Instead, there one should use the `submit` method of
the wrapping process itself, i.e. use `self.submit`.
.. warning: submission of processes requires `store_provenance=True`
:param process: the process class to submit
:type process: :class:`aiida.engine.Process`
:param inputs: the inputs to be passed to the process
:type inputs: dict
:return: the calculation node of the process
:rtype: :class:`aiida.orm.ProcessNode`
"""
assert not is_process_function(process), 'Cannot submit a process function'
# Submitting from within another process requires `self.submit` unless it is a work function, in which case the
# current process in the scope should be an instance of `FunctionProcess`
if is_process_scoped() and not isinstance(Process.current(), FunctionProcess):
raise InvalidOperation('Cannot use top-level `submit` from within another process, use `self.submit` instead')
runner = manager.get_manager().get_runner()
controller = manager.get_manager().get_process_controller()
process = instantiate_process(runner, process, **inputs)
# If a dry run is requested, simply forward to `run`, because it is not compatible with `submit`. We choose for this
# instead of raising, because in this way the user does not have to change the launcher when testing.
if process.metadata.get('dry_run', False):
_, node = run_get_node(process)
return node
if not process.metadata.store_provenance:
raise InvalidOperation('cannot submit a process with `store_provenance=False`')
runner.persister.save_checkpoint(process)
process.close()
# Do not wait for the future's result, because in the case of a single worker this would cock-block itself
controller.continue_process(process.pid, nowait=False, no_reply=True)
return process.node
# Allow one to also use run.get_node and run.get_pk as a shortcut, without having to import the functions themselves
run.get_node = run_get_node
run.get_pk = run_get_pk