aiida.orm.nodes.process package

Module with Node sub classes for processes.

class aiida.orm.nodes.process.CalculationNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.nodes.process.process.ProcessNode

Base class for all nodes representing the execution of a calculation process.

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.calculation.calculation'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 40

_abc_registry = <_weakrefset.WeakSet object>

_cachable = True

_logger = <logging.Logger object>

_plugin_type_string = 'process.calculation.calculation.CalculationNode.'

_query_type_string = 'process.calculation.calculation.'

_storable = True

_unstorable_message = 'storing for this node has been disabled'

inputs

Return an instance of NodeLinksManager to manage incoming INPUT_CALC links

The returned Manager allows you to easily explore the nodes connected to this node via an incoming INPUT_CALC link. The incoming nodes are reachable by their link labels which are attributes of the manager.

Returns:NodeLinksManager

outputs

Return an instance of NodeLinksManager to manage outgoing CREATE links

The returned Manager allows you to easily explore the nodes connected to this node via an outgoing CREATE link. The outgoing nodes are reachable by their link labels which are attributes of the manager.

Returns:NodeLinksManager

class aiida.orm.nodes.process.CalcFunctionNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.utils.mixins.FunctionCalculationMixin, aiida.orm.nodes.process.calculation.calculation.CalculationNode

ORM class for all nodes representing the execution of a calcfunction.

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.calculation.calcfunction'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 40

_abc_registry = <_weakrefset.WeakSet object>

_logger = <logging.Logger object>

_plugin_type_string = 'process.calculation.calcfunction.CalcFunctionNode.'

_query_type_string = 'process.calculation.calcfunction.'

validate_outgoing(target, link_type, link_label)

Validate adding a link of the given type from ourself to a given node.

A calcfunction cannot return Data, so if we receive an outgoing link to a stored Data node, that means the user created a Data node within our function body and stored it themselves or they are returning an input node. The latter use case is reserved for @workfunctions, as they can have RETURN links.

Parameters:

• target – the node to which the link is going
• link_type – the link type
• link_label – the link label

Raises:

• TypeError – if target is not a Node instance or link_type is not a LinkType enum
• ValueError – if the proposed link is invalid

class aiida.orm.nodes.process.CalcJobNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.nodes.process.calculation.calculation.CalculationNode

ORM class for all nodes representing the execution of a CalcJob.

CALC_JOB_STATE_KEY = 'state'

REMOTE_WORKDIR_KEY = 'remote_workdir'

RETRIEVE_LIST_KEY = 'retrieve_list'

RETRIEVE_SINGLE_FILE_LIST_KEY = 'retrieve_singlefile_list'

RETRIEVE_TEMPORARY_LIST_KEY = 'retrieve_temporary_list'

SCHEDULER_JOB_ID_KEY = 'job_id'

SCHEDULER_LAST_CHECK_TIME_KEY = 'scheduler_lastchecktime'

SCHEDULER_STATE_KEY = 'scheduler_state'

SCHEUDLER_LAST_JOB_INFO_KEY = 'last_jobinfo'

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.calculation.calcjob'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 40

_abc_registry = <_weakrefset.WeakSet object>

_cachable = True

_hash_ignored_attributes = ('queue_name', 'account', 'qos', 'priority', 'max_wallclock_seconds', 'max_memory_kb')

_logger = <logging.Logger object>

_plugin_type_string = 'process.calculation.calcjob.CalcJobNode.'

_query_type_string = 'process.calculation.calcjob.'

_raw_input_folder

Get the input folder object.

Returns:the input folder object. Raise:NotExistent: if the raw folder hasn’t been created yet

_repository_base_path = 'raw_input'

_tools = None

_updatable_attributes = ('sealed', 'paused', 'checkpoints', 'exception', 'exit_message', 'exit_status', 'process_label', 'process_state', 'process_status', 'state', 'remote_workdir', 'retrieve_list', 'retrieve_temporary_list', 'retrieve_singlefile_list', 'job_id', 'scheduler_state', 'scheduler_lastchecktime', 'last_jobinfo')

_validate()

Verify if all the input nodes are present and valid.

Raise:ValidationError: if invalid parameters are found.

static _validate_retrieval_directive(directives)

Validate a list or tuple of file retrieval directives.

Parameters:directives – a list or tuple of file retrieveal directives Raises:ValueError – if the format of the directives is invalid

delete_state()

Delete the calculation job state attribute if it exists.

get_authinfo()

Return the AuthInfo that is configured for the Computer set for this node.

Returns:AuthInfo

get_builder_restart()

Return a CalcJobBuilder instance, tailored for this calculation instance

This builder is a mapping of the inputs of the CalcJobNode class, supports tab-completion, automatic validation when settings values as well as automated docstrings for each input.

The fields of the builder will be pre-populated with all the inputs recorded for this instance as well as settings all the options that were explicitly set for this calculation instance.

This builder can then directly be launched again to effectively run a duplicate calculation. But more useful is that it serves as a starting point to, after changing one or more inputs, launch a similar calculation by using this already completed calculation as a starting point.

Returns:CalcJobBuilder instance

get_description()

Return a string with a description of the node based on its properties.

get_hash(ignore_errors=True, ignored_folder_content=('raw_input', ), **kwargs)

Return the hash for this node based on its attributes.

get_job_id()

Return job id that was assigned to the calculation by the scheduler.

Returns:the string representation of the scheduler job id

get_last_job_info()

Return the last information asked to the scheduler about the status of the job.

Returns:a JobInfo object (that closely resembles a dictionary) or None.

get_option(name)

Retun the value of an option that was set for this CalcJobNode

Parameters:name – the option name Returns:the option value or None Raises:ValueError for unknown option

get_options()

Return the dictionary of options set for this CalcJobNode

Returns:dictionary of the options and their values

get_parser_class()

Return the output parser object for this calculation or None if no parser is set.

Returns:a Parser class. Raise:MissingPluginError from ParserFactory no plugin is found.

get_remote_workdir()

Return the path to the remote (on cluster) scratch folder of the calculation.

Returns:a string with the remote path

get_retrieve_list()

Return the list of files/directories to be retrieved on the cluster after the calculation has completed.

Returns:a list of file directives

get_retrieve_singlefile_list()

Return the list of files to be retrieved on the cluster after the calculation has completed.

Returns:list of single file retrieval directives

get_retrieve_temporary_list()

Return list of files to be retrieved from the cluster which will be available during parsing.

Returns:a list of file directives

get_retrieved_node()

Return the retrieved data folder.

Returns:the retrieved FolderData node or None if not found

get_scheduler_lastchecktime()

Return the time of the last update of the scheduler state by the daemon or None if it was never set.

Returns:a datetime object or None

get_scheduler_state()

Return the status of the calculation according to the cluster scheduler.

Returns:a JobState enum instance.

get_scheduler_stderr()

Return the scheduler stdout output if the calculation has finished and been retrieved, None otherwise.

Returns:scheduler stdout output or None

get_scheduler_stdout()

Return the scheduler stderr output if the calculation has finished and been retrieved, None otherwise.

Returns:scheduler stderr output or None

get_state()

Return the state of the calculation job.

Returns:the calculation job state

get_transport()

Return the transport for this calculation.

Returns:Transport configured with the AuthInfo associated to the computer of this node

link_label_retrieved

Return the link label used for the retrieved FolderData node.

options

Return the available process options for the process class that created this node.

process_class

Return the CalcJob class that was used to create this node.

Returns:CalcJob class Raises:ValueError – if no process type is defined or it is an invalid process type string

res

To be used to get direct access to the parsed parameters.

Returns:an instance of the CalcJobResultManager. Note:a practical example on how it is meant to be used: let’s say that there is a key ‘energy’ in the dictionary of the parsed results which contains a list of floats. The command calc.res.energy will return such a list.

set_job_id(job_id)

Set the job id that was assigned to the calculation by the scheduler.

Note

the id will always be stored as a string

Parameters:job_id – the id assigned by the scheduler after submission

set_last_job_info(last_job_info)

Set the last job info.

Parameters:last_job_info – a JobInfo object

set_option(name, value)

Set an option to the given value

Parameters:

• name – the option name
• value – the value to set

Raises:

ValueError for unknown option

Raises:

TypeError for values with invalid type

set_options(options)

Set the options for this CalcJobNode

Parameters:options – dictionary of option and their values to set

set_remote_workdir(remote_workdir)

Set the absolute path to the working directory on the remote computer where the calculation is run.

Parameters:remote_workdir – absolute filepath to the remote working directory

set_retrieve_list(retrieve_list)

Set the retrieve list.

This list of directives will instruct the daemon what files to retrieve after the calculation has completed. list or tuple of files or paths that should be retrieved by the daemon.

Parameters:retrieve_list – list or tuple of with filepath directives

set_retrieve_singlefile_list(retrieve_singlefile_list)

Set the retrieve singlefile list.

The files will be stored as SinglefileData instances and added as output nodes to this calculation node. The format of a single file directive is a tuple or list of length 3 with the following entries:

1. the link label under which the file should be added
2. the SinglefileData class or sub class to use to store
3. the filepath relative to the remote working directory of the calculation

Parameters:retrieve_singlefile_list – list or tuple of single file directives

set_retrieve_temporary_list(retrieve_temporary_list)

Set the retrieve temporary list.

The retrieve temporary list stores files that are retrieved after completion and made available during parsing and are deleted as soon as the parsing has been completed.

Parameters:retrieve_temporary_list – list or tuple of with filepath directives

set_scheduler_state(state)

Set the scheduler state.

Parameters:state – an instance of JobState

set_state(state)

Set the state of the calculation job.

Parameters:state – a string with the state from aiida.common.datastructures.CalcJobState. Raise:ValueError if state is invalid

tools

Return the calculation tools that are registered for the process type associated with this calculation.

If the entry point name stored in the process_type of the CalcJobNode has an accompanying entry point in the aiida.tools.calculations entry point category, it will attempt to load the entry point and instantiate it passing the node to the constructor. If the entry point does not exist, cannot be resolved or loaded, a warning will be logged and the base CalculationTools class will be instantiated and returned.

Returns:CalculationTools instance

class aiida.orm.nodes.process.ProcessNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.utils.mixins.Sealable, aiida.orm.nodes.node.Node

Base class for all nodes representing the execution of a process

This class and its subclasses serve as proxies in the database, for actual Process instances being run. The Process instance in memory will leverage an instance of this class (the exact sub class depends on the sub class of Process) to persist important information of its state to the database. This serves as a way for the user to inspect the state of the Process during its execution as well as a permanent record of its execution in the provenance graph, after the execution has terminated.

CHECKPOINT_KEY = 'checkpoints'

EXCEPTION_KEY = 'exception'

EXIT_MESSAGE_KEY = 'exit_message'

EXIT_STATUS_KEY = 'exit_status'

PROCESS_LABEL_KEY = 'process_label'

PROCESS_PAUSED_KEY = 'paused'

PROCESS_STATE_KEY = 'process_state'

PROCESS_STATUS_KEY = 'process_status'

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.process'

__str__() <==> str(x)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 102

_abc_registry = <_weakrefset.WeakSet object>

_cachable = False

_get_objects_to_hash()

Return a list of objects which should be included in the hash.

_hash_ignored_inputs = ['CALL_CALC', 'CALL_WORK']

_logger = <logging.Logger object>

_plugin_type_string = 'process.process.ProcessNode.'

_query_type_string = 'process.process.'

_unstorable_message = 'only Data, WorkflowNode, CalculationNode or their subclasses can be stored'

_updatable_attributes = ('sealed', 'paused', 'checkpoints', 'exception', 'exit_message', 'exit_status', 'process_label', 'process_state', 'process_status')

called

Return a list of nodes that the process called

Returns:list of process nodes called by this process

called_descendants

Return a list of all nodes that have been called downstream of this process

This will recursively find all the called processes for this process and its children.

caller

Return the process node that called this process node, or None if it does not have a caller

Returns:process node that called this process node instance or None

checkpoint

Return the checkpoint bundle set for the process

Returns:checkpoint bundle if it exists, None otherwise

delete_checkpoint()

Delete the checkpoint bundle set for the process

exception

Return the exception of the process or None if the process is not excepted.

If the process is marked as excepted yet there is no exception attribute, an empty string will be returned.

Returns:the exception message or None

exit_message

Return the exit message of the process

Returns:the exit message

exit_status

Return the exit status of the process

Returns:the exit status, an integer exit code or None

is_excepted

Return whether the process has excepted

Excepted means that during execution of the process, an exception was raised that was not caught.

Returns:True if during execution of the process an exception occurred, False otherwise Return type:bool

is_failed

Return whether the process has failed

Failed means that the process terminated nominally but it had a non-zero exit status.

Returns:True if the process has failed, False otherwise Return type:bool

is_finished

Return whether the process has finished

Finished means that the process reached a terminal state nominally. Note that this does not necessarily mean successfully, but there were no exceptions and it was not killed.

Returns:True if the process has finished, False otherwise Return type:bool

is_finished_ok

Return whether the process has finished successfully

Finished successfully means that it terminated nominally and had a zero exit status.

Returns:True if the process has finished successfully, False otherwise Return type:bool

is_killed

Return whether the process was killed

Killed means the process was killed directly by the user or by the calling process being killed.

Returns:True if the process was killed, False otherwise Return type:bool

is_terminated

Return whether the process has terminated

Terminated means that the process has reached any terminal state.

Returns:True if the process has terminated, False otherwise Return type:bool

is_valid_cache

Return whether the node is valid for caching

Returns:True if this process node is valid to be used for caching, False otherwise

load_process_class()

For nodes that were ran by a Process, the process_type will be set. This can either be an entry point string or a module path, which is the identifier for that Process. This method will attempt to load the Process class and return

logger

Get the logger of the Calculation object, so that it also logs to the DB.

Returns:LoggerAdapter object, that works like a logger, but also has the ‘extra’ embedded

pause()

Mark the process as paused by setting the corresponding attribute.

This serves only to reflect that the corresponding Process is paused and so this method should not be called by anyone but the Process instance itself.

paused

Return whether the process is paused

Returns:True if the Calculation is marked as paused, False otherwise

process_label

Return the process label

Returns:the process label

process_state

Return the process state

Returns:the process state instance of ProcessState enum

process_status

Return the process status

The process status is a generic status message e.g. the reason it might be paused or when it is being killed

Returns:the process status

set_checkpoint(checkpoint)

Set the checkpoint bundle set for the process

Parameters:state – string representation of the stepper state info

set_exception(exception)

Set the exception of the process

Parameters:exception – the exception message

set_exit_message(message)

Set the exit message of the process, if None nothing will be done

Parameters:message – a string message

set_exit_status(status)

Set the exit status of the process

Parameters:state – an integer exit code or None, which will be interpreted as zero

set_process_label(label)

Set the process label

Parameters:label – process label string

set_process_state(state)

Set the process state

Parameters:state – value or instance of ProcessState enum

set_process_status(status)

Set the process status

The process status is a generic status message e.g. the reason it might be paused or when it is being killed. If status is None, the corresponding attribute will be deleted.

Parameters:status – string process status

set_process_type(process_type_string)

Set the process type string.

Parameters:process_type – the process type string identifying the class using this process node as storage.

unpause()

Mark the process as unpaused by removing the corresponding attribute.

This serves only to reflect that the corresponding Process is unpaused and so this method should not be called by anyone but the Process instance itself.

class aiida.orm.nodes.process.WorkflowNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.nodes.process.process.ProcessNode

Base class for all nodes representing the execution of a workflow process.

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.workflow.workflow'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 40

_abc_registry = <_weakrefset.WeakSet object>

_logger = <logging.Logger object>

_plugin_type_string = 'process.workflow.workflow.WorkflowNode.'

_query_type_string = 'process.workflow.workflow.'

_storable = True

_unstorable_message = 'storing for this node has been disabled'

inputs

Return an instance of NodeLinksManager to manage incoming INPUT_WORK links

The returned Manager allows you to easily explore the nodes connected to this node via an incoming INPUT_WORK link. The incoming nodes are reachable by their link labels which are attributes of the manager.

Returns:NodeLinksManager

outputs

Return an instance of NodeLinksManager to manage outgoing RETURN links

The returned Manager allows you to easily explore the nodes connected to this node via an outgoing RETURN link. The outgoing nodes are reachable by their link labels which are attributes of the manager.

Returns:NodeLinksManager

class aiida.orm.nodes.process.WorkChainNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.nodes.process.workflow.workflow.WorkflowNode

ORM class for all nodes representing the execution of a WorkChain.

STEPPER_STATE_INFO_KEY = 'stepper_state_info'

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.workflow.workchain'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 40

_abc_registry = <_weakrefset.WeakSet object>

_cachable = False

_logger = <logging.Logger object>

_plugin_type_string = 'process.workflow.workchain.WorkChainNode.'

_query_type_string = 'process.workflow.workchain.'

_updatable_attributes = ('sealed', 'paused', 'checkpoints', 'exception', 'exit_message', 'exit_status', 'process_label', 'process_state', 'process_status', 'stepper_state_info')

set_stepper_state_info(stepper_state_info)

Set the stepper state info

Parameters:state – string representation of the stepper state info

stepper_state_info

Return the stepper state info

Returns:string representation of the stepper state info

class aiida.orm.nodes.process.WorkFunctionNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.utils.mixins.FunctionCalculationMixin, aiida.orm.nodes.process.workflow.workflow.WorkflowNode

ORM class for all nodes representing the execution of a workfunction.

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.workflow.workfunction'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 40

_abc_registry = <_weakrefset.WeakSet object>

_logger = <logging.Logger object>

_plugin_type_string = 'process.workflow.workfunction.WorkFunctionNode.'

_query_type_string = 'process.workflow.workfunction.'

validate_outgoing(target, link_type, link_label)

Validate adding a link of the given type from ourself to a given node.

A workfunction cannot create Data, so if we receive an outgoing RETURN link to an unstored Data node, that means the user created a Data node within our function body and is trying to return it. This use case should be reserved for @calcfunctions, as they can have CREATE links.

Parameters:

• target – the node to which the link is going
• link_type – the link type
• link_label – the link label

Raises:

• TypeError – if target is not a Node instance or link_type is not a LinkType enum
• ValueError – if the proposed link is invalid

Subpackages

• aiida.orm.nodes.process.calculation package
  • Submodules
• aiida.orm.nodes.process.workflow package
  • Submodules

Submodules

Module with Node sub class for processes.

class aiida.orm.nodes.process.process.ProcessNode(backend=None, user=None, computer=None, **kwargs)

Bases: aiida.orm.utils.mixins.Sealable, aiida.orm.nodes.node.Node

Base class for all nodes representing the execution of a process

This class and its subclasses serve as proxies in the database, for actual Process instances being run. The Process instance in memory will leverage an instance of this class (the exact sub class depends on the sub class of Process) to persist important information of its state to the database. This serves as a way for the user to inspect the state of the Process during its execution as well as a permanent record of its execution in the provenance graph, after the execution has terminated.

CHECKPOINT_KEY = 'checkpoints'

EXCEPTION_KEY = 'exception'

EXIT_MESSAGE_KEY = 'exit_message'

EXIT_STATUS_KEY = 'exit_status'

PROCESS_LABEL_KEY = 'process_label'

PROCESS_PAUSED_KEY = 'paused'

PROCESS_STATE_KEY = 'process_state'

PROCESS_STATUS_KEY = 'process_status'

__abstractmethods__ = frozenset([])

__module__ = 'aiida.orm.nodes.process.process'

__str__() <==> str(x)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 102

_abc_registry = <_weakrefset.WeakSet object>

_cachable = False

_get_objects_to_hash()

Return a list of objects which should be included in the hash.

_hash_ignored_inputs = ['CALL_CALC', 'CALL_WORK']

_logger = <logging.Logger object>

_plugin_type_string = 'process.process.ProcessNode.'

_query_type_string = 'process.process.'

_unstorable_message = 'only Data, WorkflowNode, CalculationNode or their subclasses can be stored'

_updatable_attributes = ('sealed', 'paused', 'checkpoints', 'exception', 'exit_message', 'exit_status', 'process_label', 'process_state', 'process_status')

called

Return a list of nodes that the process called

Returns:list of process nodes called by this process

called_descendants

Return a list of all nodes that have been called downstream of this process

This will recursively find all the called processes for this process and its children.

caller

Return the process node that called this process node, or None if it does not have a caller

Returns:process node that called this process node instance or None

checkpoint

Return the checkpoint bundle set for the process

Returns:checkpoint bundle if it exists, None otherwise

delete_checkpoint()

Delete the checkpoint bundle set for the process

exception

Return the exception of the process or None if the process is not excepted.

If the process is marked as excepted yet there is no exception attribute, an empty string will be returned.

Returns:the exception message or None

exit_message

Return the exit message of the process

Returns:the exit message

exit_status

Return the exit status of the process

Returns:the exit status, an integer exit code or None

is_excepted

Return whether the process has excepted

Excepted means that during execution of the process, an exception was raised that was not caught.

Returns:True if during execution of the process an exception occurred, False otherwise Return type:bool

is_failed

Return whether the process has failed

Failed means that the process terminated nominally but it had a non-zero exit status.

Returns:True if the process has failed, False otherwise Return type:bool

is_finished

Return whether the process has finished

Finished means that the process reached a terminal state nominally. Note that this does not necessarily mean successfully, but there were no exceptions and it was not killed.

Returns:True if the process has finished, False otherwise Return type:bool

is_finished_ok

Return whether the process has finished successfully

Finished successfully means that it terminated nominally and had a zero exit status.

Returns:True if the process has finished successfully, False otherwise Return type:bool

is_killed

Return whether the process was killed

Killed means the process was killed directly by the user or by the calling process being killed.

Returns:True if the process was killed, False otherwise Return type:bool

is_terminated

Return whether the process has terminated

Terminated means that the process has reached any terminal state.

Returns:True if the process has terminated, False otherwise Return type:bool

is_valid_cache

Return whether the node is valid for caching

Returns:True if this process node is valid to be used for caching, False otherwise

load_process_class()

For nodes that were ran by a Process, the process_type will be set. This can either be an entry point string or a module path, which is the identifier for that Process. This method will attempt to load the Process class and return

logger

Get the logger of the Calculation object, so that it also logs to the DB.

Returns:LoggerAdapter object, that works like a logger, but also has the ‘extra’ embedded

pause()

Mark the process as paused by setting the corresponding attribute.

This serves only to reflect that the corresponding Process is paused and so this method should not be called by anyone but the Process instance itself.

paused

Return whether the process is paused

Returns:True if the Calculation is marked as paused, False otherwise

process_label

Return the process label

Returns:the process label

process_state

Return the process state

Returns:the process state instance of ProcessState enum

process_status

Return the process status

The process status is a generic status message e.g. the reason it might be paused or when it is being killed

Returns:the process status

set_checkpoint(checkpoint)

Set the checkpoint bundle set for the process

Parameters:state – string representation of the stepper state info

set_exception(exception)

Set the exception of the process

Parameters:exception – the exception message

set_exit_message(message)

Set the exit message of the process, if None nothing will be done

Parameters:message – a string message

set_exit_status(status)

Set the exit status of the process

Parameters:state – an integer exit code or None, which will be interpreted as zero

set_process_label(label)

Set the process label

Parameters:label – process label string

set_process_state(state)

Set the process state

Parameters:state – value or instance of ProcessState enum

set_process_status(status)

Set the process status

The process status is a generic status message e.g. the reason it might be paused or when it is being killed. If status is None, the corresponding attribute will be deleted.

Parameters:status – string process status

set_process_type(process_type_string)

Set the process type string.

Parameters:process_type – the process type string identifying the class using this process node as storage.

unpause()

Mark the process as unpaused by removing the corresponding attribute.

This serves only to reflect that the corresponding Process is unpaused and so this method should not be called by anyone but the Process instance itself.