`aiida.engine`#

Package Contents#

Functions#

`append_`
`assign_`
`calcfunction`
`construct_awaitable`
`get_object_loader`
`interruptable_task`
`is_process_function`
`process_handler`
`run`
`run_get_node`
`run_get_pk`
`submit`
`workfunction`

Data#

`OutputPort`
`PORT_NAMESPACE_SEPARATOR`
`ToContext`

External#

`ProcessState`
`if_`
`return_`
`while_`

API#

class aiida.engine.AiiDAPersister#

Bases: plumpy.persistence.Persister

save_checkpoint(process: aiida.engine.processes.process.Process, tag: Optional[str] = None)#

load_checkpoint(pid: Hashable, tag: Optional[str] = None) → plumpy.persistence.Bundle#

get_checkpoints()#

get_process_checkpoints(pid: Hashable)#

delete_checkpoint(pid: Hashable, tag: Optional[str] = None) → None#

delete_process_checkpoints(pid: Hashable)#

class aiida.engine.Awaitable#: Bases: plumpy.utils.AttributesDict

class aiida.engine.AwaitableAction(*args, **kwds)#

Bases: enum.Enum

Initialization

ASSIGN = 'assign'#

APPEND = 'append'#

class aiida.engine.AwaitableTarget(*args, **kwds)#

Bases: enum.Enum

Initialization

PROCESS = 'process'#

class aiida.engine.BaseRestartWorkChain(*args, **kwargs)#

Bases: aiida.engine.processes.workchains.workchain.WorkChain

Initialization

_process_class: Optional[Type[aiida.engine.processes.Process]] = None#

_considered_handlers_extra = 'considered_handlers'#

property process_class: Type[aiida.engine.processes.process.Process]#

classmethod define(spec: aiida.engine.processes.ProcessSpec) → None#

setup() → None#

should_run_process() → bool#

run_process() → aiida.engine.processes.workchains.context.ToContext#

inspect_process() → Optional[aiida.engine.processes.ExitCode]#

get_outputs(node) → Mapping[str, aiida.orm.Node]#

results() → Optional[aiida.engine.processes.ExitCode]#

classmethod is_process_handler(process_handler_name: Union[str, types.FunctionType]) → bool#

classmethod get_process_handlers() → List[types.FunctionType]#

get_process_handlers_by_priority() → List[Tuple[int, types.FunctionType]]#

on_terminated()#

_wrap_bare_dict_inputs(port_namespace: aiida.engine.processes.PortNamespace, inputs: Dict[str, Any]) → aiida.common.AttributeDict#

class aiida.engine.CalcJob(*args, **kwargs)#

Bases: aiida.engine.processes.process.Process

Initialization

_node_class = None#

_spec_class = None#

link_label_retrieved: str = 'retrieved'#

classmethod define(spec: aiida.engine.processes.process_spec.CalcJobProcessSpec) → None#

spec_options()#

classmethod get_importer(entry_point_name: str | None = None) → aiida.engine.processes.calcjobs.importer.CalcJobImporter#

property options: aiida.common.AttributeDict#

classmethod get_state_classes() → Dict[Hashable, Type[plumpy.process_states.State]]#

property node: aiida.orm.CalcJobNode#

on_terminated() → None#

run() → Union[plumpy.process_states.Stop, int, plumpy.process_states.Wait]#

abstract prepare_for_submission(folder: aiida.common.folders.Folder) → aiida.common.datastructures.CalcInfo#

_setup_metadata(metadata: dict) → None#

_setup_inputs() → None#

_perform_dry_run()#

_perform_import()#

parse(retrieved_temporary_folder: Optional[str] = None, existing_exit_code: aiida.engine.processes.exit_code.ExitCode | None = None) → aiida.engine.processes.exit_code.ExitCode#

static terminate(exit_code: aiida.engine.processes.exit_code.ExitCode) → aiida.engine.processes.exit_code.ExitCode#

parse_scheduler_output(retrieved: aiida.orm.Node) → Optional[aiida.engine.processes.exit_code.ExitCode]#

parse_retrieved_output(retrieved_temporary_folder: Optional[str] = None) → Optional[aiida.engine.processes.exit_code.ExitCode]#

presubmit(folder: aiida.common.folders.Folder) → aiida.common.datastructures.CalcInfo#

class aiida.engine.CalcJobImporter#

Bases: abc.ABC

abstract static parse_remote_data(remote_data: aiida.orm.RemoteData, **kwargs) → Dict[str, Union[aiida.orm.Node, Dict]]#

class aiida.engine.CalcJobOutputPort(*args, **kwargs)#

Bases: plumpy.ports.OutputPort

Initialization

property pass_to_parser: bool#

class aiida.engine.CalcJobProcessSpec#

Bases: aiida.engine.processes.process_spec.ProcessSpec

Initialization

OUTPUT_PORT_TYPE = None#

property default_output_node: Optional[str]#

class aiida.engine.DaemonClient(profile: aiida.manage.configuration.profile.Profile)#

Initialization

DAEMON_ERROR_NOT_RUNNING = 'daemon-error-not-running'#

DAEMON_ERROR_TIMEOUT = 'daemon-error-timeout'#

_DAEMON_NAME = 'aiida-{name}'#

_ENDPOINT_PROTOCOL = None#

property profile: aiida.manage.configuration.profile.Profile#

property daemon_name: str#

property _verdi_bin: str#

cmd_start_daemon(number_workers: int = 1, foreground: bool = False) → list[str]#

property cmd_start_daemon_worker: list[str]#

property loglevel: str#

property virtualenv: str | None#

property circus_log_file: str#

property circus_pid_file: str#

property circus_port_file: str#

property circus_socket_file: str#

property circus_socket_endpoints: dict[str, str]#

property daemon_log_file: str#

property daemon_pid_file: str#

get_circus_port() → int#

static get_env() → dict[str, str]#

get_circus_socket_directory() → str#

get_daemon_pid() → int | None#

property is_daemon_running: bool#

delete_circus_socket_directory() → None#

classmethod get_available_port()#

get_controller_endpoint()#

get_pubsub_endpoint()#

get_stats_endpoint()#

get_ipc_endpoint(endpoint)#

get_tcp_endpoint(port=None)#

get_client() → circus.client.CircusClient#

call_client(command: aiida.engine.daemon.client.JsonDictType) → aiida.engine.daemon.client.JsonDictType#

get_status() → aiida.engine.daemon.client.JsonDictType#

get_numprocesses() → aiida.engine.daemon.client.JsonDictType#

get_worker_info() → aiida.engine.daemon.client.JsonDictType#

get_daemon_info() → aiida.engine.daemon.client.JsonDictType#

increase_workers(number: int) → aiida.engine.daemon.client.JsonDictType#

decrease_workers(number: int) → aiida.engine.daemon.client.JsonDictType#

stop_daemon(wait: bool = True, timeout: int = 5) → aiida.engine.daemon.client.JsonDictType#

restart_daemon(wait: bool) → aiida.engine.daemon.client.JsonDictType#

start_daemon(number_workers: int = 1, foreground: bool = False, timeout: int = 5) → None#

static _await_condition(condition: Callable, exception: Exception, timeout: int = 5, interval: float = 0.1)#

_start_daemon(number_workers: int = 1, foreground: bool = False) → None#

class aiida.engine.ExitCode#

Bases: typing.NamedTuple

status: int = 0#

message: Optional[str] = None#

invalidates_cache: bool = False#

format(**kwargs: str) → aiida.engine.processes.exit_code.ExitCode#

class aiida.engine.ExitCodesNamespace(dictionary=None)#

Bases: aiida.common.extendeddicts.AttributeDict

Initialization

__call__(identifier: Union[int, str]) → aiida.engine.processes.exit_code.ExitCode#

class aiida.engine.FunctionProcess(*args, **kwargs)#

Bases: aiida.engine.processes.process.Process

Initialization

_func_args: Sequence[str] = ()#

static _func(*_args, **_kwargs) → dict#

static build(func: Callable[..., Any], node_class: Type[aiida.orm.ProcessNode]) → Type[aiida.engine.processes.functions.FunctionProcess]#

classmethod validate_inputs(*args: Any, **kwargs: Any) → None#

classmethod create_inputs(*args: Any, **kwargs: Any) → Dict[str, Any]#

classmethod args_to_dict(*args: Any) → Dict[str, Any]#

classmethod get_or_create_db_record() → aiida.orm.ProcessNode#

property process_class: Callable[..., Any]#

execute() → Optional[Dict[str, Any]]#

_setup_db_record() → None#

run() → Optional[aiida.engine.processes.exit_code.ExitCode]#

class aiida.engine.InputPort(*args, **kwargs)#

Bases: aiida.engine.processes.ports.WithSerialize, aiida.engine.processes.ports.WithNonDb, plumpy.ports.InputPort

Initialization

get_description() → Dict[str, str]#

class aiida.engine.InterruptableFuture(*, loop=None)#

Bases: asyncio.Future

Initialization

interrupt(reason: Exception) → None#

async with_interrupt(coro: Awaitable[Any]) → Any#

class aiida.engine.JobManager(transport_queue: aiida.engine.transports.TransportQueue)#

Initialization

get_jobs_list(authinfo: aiida.orm.AuthInfo) → aiida.engine.processes.calcjobs.manager.JobsList#

request_job_info_update(authinfo: aiida.orm.AuthInfo, job_id: Hashable) → Iterator[asyncio.Future[JobInfo]]#

class aiida.engine.JobsList(authinfo: aiida.orm.AuthInfo, transport_queue: aiida.engine.transports.TransportQueue, last_updated: Optional[float] = None)#

Initialization

property logger: logging.Logger#

get_minimum_update_interval() → float#

property last_updated: Optional[float]#

async _get_jobs_from_scheduler() → Dict[Hashable, aiida.schedulers.datastructures.JobInfo]#

async _update_job_info() → None#

request_job_info_update(job_id: Hashable) → Iterator[asyncio.Future[JobInfo]]#

_ensure_updating() → None#

static _has_job_state_changed(old: Optional[aiida.schedulers.datastructures.JobInfo], new: Optional[aiida.schedulers.datastructures.JobInfo]) → bool#

_get_next_update_delay() → float#

_update_requests_outstanding() → bool#

_get_jobs_with_scheduler() → List[str]#

class aiida.engine.ObjectLoader#

Bases: plumpy.loaders.DefaultObjectLoader

load_object(identifier: str) → Any#

aiida.engine.OutputPort = None#

aiida.engine.PORT_NAMESPACE_SEPARATOR = '__'#

exception aiida.engine.PastException#

Bases: aiida.common.exceptions.AiidaException

Initialization

class aiida.engine.PortNamespace(*args, **kwargs)#

Bases: aiida.engine.processes.ports.WithNonDb, plumpy.ports.PortNamespace

Initialization

__setitem__(key: str, port: plumpy.ports.Port) → None#

static validate_port_name(port_name: str) → None#

serialize(mapping: Optional[Dict[str, Any]], breadcrumbs: Sequence[str] = ()) → Optional[Dict[str, Any]]#

class aiida.engine.Process(inputs: Optional[Dict[str, Any]] = None, logger: Optional[logging.Logger] = None, runner: Optional[aiida.engine.runners.Runner] = None, parent_pid: Optional[int] = None, enable_persistence: bool = True)#

Bases: plumpy.processes.Process

Initialization

_node_class = None#

_spec_class = None#

SINGLE_OUTPUT_LINKNAME: str = 'result'#

class SaveKeys(*args, **kwds)#

Bases: enum.Enum

Initialization

CALC_ID: str = 'calc_id'#

classmethod spec() → aiida.engine.processes.process_spec.ProcessSpec#

classmethod define(spec: aiida.engine.processes.process_spec.ProcessSpec) → None#

classmethod get_builder() → aiida.engine.processes.builder.ProcessBuilder#

classmethod get_or_create_db_record() → aiida.orm.ProcessNode#

init() → None#

classmethod get_exit_statuses(exit_code_labels: Iterable[str]) → List[int]#

exit_codes() → aiida.engine.processes.exit_code.ExitCodesNamespace#

spec_metadata() → aiida.engine.processes.ports.PortNamespace#

property node: aiida.orm.ProcessNode#

property uuid: str#

property metadata: aiida.common.extendeddicts.AttributeDict#

_save_checkpoint() → None#

save_instance_state(out_state: MutableMapping[str, Any], save_context: Optional[plumpy.persistence.LoadSaveContext]) → None#

get_provenance_inputs_iterator() → Iterator[Tuple[str, Union[aiida.engine.processes.ports.InputPort, aiida.engine.processes.ports.PortNamespace]]]#

load_instance_state(saved_state: MutableMapping[str, Any], load_context: plumpy.persistence.LoadSaveContext) → None#

kill(msg: Union[str, None] = None) → Union[bool, plumpy.futures.Future]#

out(output_port: str, value: Any = None) → None#

out_many(out_dict: Dict[str, Any]) → None#

on_create() → None#

on_entered(from_state: Optional[plumpy.process_states.State]) → None#

on_terminated() → None#

on_except(exc_info: Tuple[Any, Exception, types.TracebackType]) → None#

on_finish(result: Union[int, aiida.engine.processes.exit_code.ExitCode], successful: bool) → None#

on_paused(msg: Optional[str] = None) → None#

on_playing() → None#

on_output_emitting(output_port: str, value: Any) → None#

set_status(status: Optional[str]) → None#

submit(process: Type[aiida.engine.processes.process.Process], **kwargs) → aiida.orm.ProcessNode#

property runner: aiida.engine.runners.Runner#

get_parent_calc() → Optional[aiida.orm.ProcessNode]#

classmethod build_process_type() → str#

report(msg: str, *args, **kwargs) → None#

_create_and_setup_db_record() → Union[int, uuid.UUID]#

encode_input_args(inputs: Dict[str, Any]) → str#

decode_input_args(encoded: str) → Dict[str, Any]#

update_outputs() → None#

_build_process_label() → str#

_setup_db_record() → None#

_setup_version_info() → None#

_setup_metadata(metadata: dict) → None#

_setup_inputs() → None#

_flat_inputs() → Dict[str, Any]#

_flat_outputs() → Dict[str, Any]#

_flatten_inputs(port: Union[None, aiida.engine.processes.ports.InputPort, aiida.engine.processes.ports.PortNamespace], port_value: Any, parent_name: str = '', separator: str = PORT_NAMESPACE_SEPARATOR) → List[Tuple[str, Any]]#

_flatten_outputs(port: Union[None, aiida.engine.processes.ports.OutputPort, aiida.engine.processes.ports.PortNamespace], port_value: Any, parent_name: str = '', separator: str = PORT_NAMESPACE_SEPARATOR) → List[Tuple[str, Any]]#

exposed_inputs(process_class: Type[aiida.engine.processes.process.Process], namespace: Optional[str] = None, agglomerate: bool = True) → aiida.common.extendeddicts.AttributeDict#

exposed_outputs(node: aiida.orm.ProcessNode, process_class: Type[aiida.engine.processes.process.Process], namespace: Optional[str] = None, agglomerate: bool = True) → aiida.common.extendeddicts.AttributeDict#

static _get_namespace_list(namespace: Optional[str] = None, agglomerate: bool = True) → List[Optional[str]]#

classmethod is_valid_cache(node: aiida.orm.ProcessNode) → bool#

class aiida.engine.ProcessBuilder(process_class: Type[aiida.engine.processes.process.Process])#

Bases: aiida.engine.processes.builder.ProcessBuilderNamespace

Initialization

property process_class: Type[aiida.engine.processes.process.Process]#

_repr_pretty_(p, _) → str#

class aiida.engine.ProcessBuilderNamespace(port_namespace: aiida.engine.processes.ports.PortNamespace)#

Bases: collections.abc.MutableMapping

Initialization

__setattr__(attr: str, value: Any) → None#

__repr__()#

__dir__()#

__iter__()#

__len__()#

__getitem__(item)#

__setitem__(item, value)#

__delitem__(item)#

__delattr__(item)#

_recursive_merge(dictionary, key, value)#

_merge(*args, **kwds)#

_update(*args, **kwds)#

_inputs(prune: bool = False) → dict#

_prune(value)#

class aiida.engine.ProcessFuture(pk: int, loop: Optional[asyncio.AbstractEventLoop] = None, poll_interval: Union[None, int, float] = None, communicator: Optional[kiwipy.Communicator] = None)#

Bases: asyncio.Future

Initialization

_filtered = None#

cleanup() → None#

async _poll_process(node: aiida.orm.Node, poll_interval: Union[int, float]) → None#

class aiida.engine.ProcessHandlerReport#

Bases: typing.NamedTuple

do_break: bool = False#

exit_code: aiida.engine.processes.exit_code.ExitCode = None#

class aiida.engine.ProcessSpec#

Bases: plumpy.process_spec.ProcessSpec

Initialization

METADATA_KEY: str = 'metadata'#

METADATA_OPTIONS_KEY: str = 'options'#

INPUT_PORT_TYPE = None#

PORT_NAMESPACE_TYPE = None#

property metadata_key: str#

property options_key: str#

property exit_codes: aiida.engine.processes.exit_code.ExitCodesNamespace#

exit_code(status: int, label: str, message: str, invalidates_cache: bool = False) → None#

property ports: aiida.engine.processes.ports.PortNamespace#

property inputs: aiida.engine.processes.ports.PortNamespace#

property outputs: aiida.engine.processes.ports.PortNamespace#

class aiida.engine.Runner(poll_interval: Union[int, float] = 0, loop: Optional[asyncio.AbstractEventLoop] = None, communicator: Optional[kiwipy.Communicator] = None, rmq_submit: bool = False, persister: Optional[plumpy.persistence.Persister] = None)#

Initialization

_persister: Optional[plumpy.persistence.Persister] = None#

_communicator: Optional[kiwipy.Communicator] = None#

_controller: Optional[plumpy.process_comms.RemoteProcessThreadController] = None#

_closed: bool = False#

__enter__() → aiida.engine.runners.Runner#

__exit__(exc_type, exc_val, exc_tb)#

property loop: asyncio.AbstractEventLoop#

property transport: aiida.engine.transports.TransportQueue#

property persister: Optional[plumpy.persistence.Persister]#

property communicator: Optional[kiwipy.Communicator]#

property plugin_version_provider: aiida.plugins.utils.PluginVersionProvider#

property job_manager: aiida.engine.processes.calcjobs.manager.JobManager#

property controller: Optional[plumpy.process_comms.RemoteProcessThreadController]#

property is_daemon_runner: bool#

is_closed() → bool#

start() → None#

stop() → None#

run_until_complete(future: asyncio.Future) → Any#

close() → None#

instantiate_process(process: aiida.engine.runners.TYPE_RUN_PROCESS, **inputs)#

submit(process: aiida.engine.runners.TYPE_SUBMIT_PROCESS, **inputs: Any)#

schedule(process: aiida.engine.runners.TYPE_SUBMIT_PROCESS, *args: Any, **inputs: Any) → aiida.orm.ProcessNode#

_run(process: aiida.engine.runners.TYPE_RUN_PROCESS, *args: Any, **inputs: Any) → Tuple[Dict[str, Any], aiida.orm.ProcessNode]#

run(process: aiida.engine.runners.TYPE_RUN_PROCESS, *args: Any, **inputs: Any) → Dict[str, Any]#

run_get_node(process: aiida.engine.runners.TYPE_RUN_PROCESS, *args: Any, **inputs: Any) → aiida.engine.runners.ResultAndNode#

run_get_pk(process: aiida.engine.runners.TYPE_RUN_PROCESS, *args: Any, **inputs: Any) → aiida.engine.runners.ResultAndPk#

call_on_process_finish(pk: int, callback: Callable[[], Any]) → None#

get_process_future(pk: int) → aiida.engine.processes.futures.ProcessFuture#

_poll_process(node, callback)#

aiida.engine.ToContext = None#

class aiida.engine.WithNonDb(*args, **kwargs)#

Initialization

property non_db_explicitly_set: bool#

property non_db: bool#

class aiida.engine.WithSerialize(*args, **kwargs)#

Initialization

serialize(value: Any) → aiida.orm.Data#

class aiida.engine.WorkChain(inputs: dict | None = None, logger: logging.Logger | None = None, runner: aiida.engine.runners.Runner | None = None, enable_persistence: bool = True)#

Bases: aiida.engine.processes.process.Process

Initialization

_node_class = None#

_spec_class = None#

_STEPPER_STATE = 'stepper_state'#

_CONTEXT = 'CONTEXT'#

classmethod spec() → aiida.engine.processes.workchains.workchain.WorkChainSpec#

property node: aiida.orm.WorkChainNode#

property ctx: aiida.common.extendeddicts.AttributeDict#

save_instance_state(out_state, save_context)#

load_instance_state(saved_state, load_context)#

on_run()#

_resolve_nested_context(key: str) → tuple[aiida.common.extendeddicts.AttributeDict, str]#

_insert_awaitable(awaitable: aiida.engine.processes.workchains.awaitable.Awaitable) → None#

_resolve_awaitable(awaitable: aiida.engine.processes.workchains.awaitable.Awaitable, value: Any) → None#

to_context(**kwargs: aiida.engine.processes.workchains.awaitable.Awaitable | aiida.orm.ProcessNode) → None#

_update_process_status() → None#

run() → Any#

_do_step() → Any#

_store_nodes(data: Any) → None#

on_exiting() → None#

on_wait(awaitables: Sequence[aiida.engine.processes.workchains.awaitable.Awaitable])#

_action_awaitables() → None#

_on_awaitable_finished(awaitable: aiida.engine.processes.workchains.awaitable.Awaitable) → None#

aiida.engine.append_(target: Union[aiida.engine.processes.workchains.awaitable.Awaitable, aiida.orm.ProcessNode]) → aiida.engine.processes.workchains.awaitable.Awaitable#

aiida.engine.assign_(target: Union[aiida.engine.processes.workchains.awaitable.Awaitable, aiida.orm.ProcessNode]) → aiida.engine.processes.workchains.awaitable.Awaitable#

aiida.engine.calcfunction(function: aiida.engine.processes.functions.FunctionType) → aiida.engine.processes.functions.FunctionType#

aiida.engine.construct_awaitable(target: Union[aiida.engine.processes.workchains.awaitable.Awaitable, aiida.orm.ProcessNode]) → aiida.engine.processes.workchains.awaitable.Awaitable#

aiida.engine.get_object_loader() → aiida.engine.persistence.ObjectLoader#

aiida.engine.interruptable_task(coro: Callable[[aiida.engine.utils.InterruptableFuture], Awaitable[Any]], loop: Optional[asyncio.AbstractEventLoop] = None) → aiida.engine.utils.InterruptableFuture#

aiida.engine.is_process_function(function: Any) → bool#

aiida.engine.process_handler(wrapped: Optional[types.FunctionType] = None, *, priority: int = 0, exit_codes: Union[None, aiida.engine.processes.exit_code.ExitCode, List[aiida.engine.processes.exit_code.ExitCode]] = None, enabled: bool = True) → types.FunctionType#

aiida.engine.run(process: aiida.engine.launch.TYPE_RUN_PROCESS, *args: Any, **inputs: Any) → Dict[str, Any]#

aiida.engine.run_get_node(process: aiida.engine.launch.TYPE_RUN_PROCESS, *args: Any, **inputs: Any) → Tuple[Dict[str, Any], aiida.orm.ProcessNode]#

aiida.engine.run_get_pk(process: aiida.engine.launch.TYPE_RUN_PROCESS, *args: Any, **inputs: Any) → Tuple[Dict[str, Any], int]#

aiida.engine.submit(process: aiida.engine.launch.TYPE_SUBMIT_PROCESS, **inputs: Any) → aiida.orm.ProcessNode#

aiida.engine.workfunction(function: aiida.engine.processes.functions.FunctionType) → aiida.engine.processes.functions.FunctionType#

`AiiDAPersister`
`Awaitable`
`AwaitableAction`
`AwaitableTarget`
`BaseRestartWorkChain`
`CalcJob`
`CalcJobImporter`
`CalcJobOutputPort`
`CalcJobProcessSpec`
`DaemonClient`
`ExitCode`
`ExitCodesNamespace`
`FunctionProcess`
`InputPort`
`InterruptableFuture`
`JobManager`
`JobsList`
`ObjectLoader`
`PortNamespace`
`Process`
`ProcessBuilder`
`ProcessBuilderNamespace`
`ProcessFuture`
`ProcessHandlerReport`
`ProcessSpec`
`Runner`
`WithNonDb`
`WithSerialize`
`WorkChain`

aiida.engine#

Package Contents#

Classes#

Functions#

Data#

External#

API#

`aiida.engine`#