spinetoolbox.headless

Contains facilities to open and execute projects without GUI.

Module Contents

Classes

HeadlessLogger	A LoggerInterface compliant logger that uses Python's standard logging facilities.
ModifiableProject	A simple project that is available for modification script.
ActionsWithProject	A 'task' which opens Toolbox project and operates on it.
Status	Status codes returned from headless execution.

Functions

headless_main(args)	Executes a project using QCoreApplication.
open_project(project_dict, project_dir, logger)	Opens a project.
_specification_dicts(project_dict, project_dir, logger)	Loads project item specification dictionaries.
solve_project_dir(pd)	Makes given path object OS independent.

class spinetoolbox.headless.HeadlessLogger

Bases: PySide6.QtCore.QObject

A LoggerInterface compliant logger that uses Python’s standard logging facilities.

msg

Emits a notification message.

msg_success

Emits a message on success

msg_warning

Emits a warning message.

msg_error

Emits an error message.

msg_proc

Emits a message originating from a subprocess (usually something printed to stdout).

msg_proc_error

Emits an error message originating from a subprocess (usually something printed to stderr).

information_box

Requests an ‘information message box’ (e.g. a message window) to be opened with a given title and message.

error_box

Requests an ‘error message box’ to be opened with a given title and message.

_log_message(message)

Prints an information message.

_log_warning(message)

Prints a warning message.

_log_error(message)

Prints an error message.

_show_information_box(title, message)

Prints an information message with a title.

_show_error_box(title, message)

Prints an error message with a title.

_print(message, out_stream)

Filters HTML tags from message before printing it to given file.

class spinetoolbox.headless.ModifiableProject(project_dir, items_dict, connection_dicts)

A simple project that is available for modification script.

Parameters:

• project_dir (Path) – project directory

• items_dict (dict) – project item dictionaries

• connection_dicts (list of dict) – connection dictionaries

property project_dir

find_connection(source_name, destination_name)

Searches for a connection between given items.

Parameters:

• source_name (str) – source item’s name

• destination_name (str) – destination item’s name

Returns:

connection instance or None if there is no connection

Return type:

Connection

find_item(name)

Searches for a project item.

Parameters:

name (str) – item’s name

Returns:

item dict or None if no such item exists

Return type:

dict

items_to_dict()

Stores project items back to dictionaries.

Returns:

item dictionaries

Return type:

dict

connections_to_dict()

Stores connections back to dictionaries.

Returns:

connection dictionaries

Return type:

list of dict

class spinetoolbox.headless.ActionsWithProject(args, startup_event_type, parent)

Bases: PySide6.QtCore.QObject

A ‘task’ which opens Toolbox project and operates on it.

The execution of this task is triggered by sending it a ‘startup’ QEvent using e.g. QCoreApplication.postEvent()

Parameters:

• args (argparse.Namespace) – parsed command line arguments

• startup_event_type (int) – expected type id for the event that starts this task

• parent (QObject) – a parent object

_start

A private signal to actually start execution. Not to be used directly. Post a startup event instead.

_dags()

_execute()

Executes this task.

_open_project()

Opens a project.

Returns:

status code

Return type:

Status

_check_project_version(project_dict)

Checks project dict version.

Parameters:

project_dict (dict) – project dict

Returns:

status code

Return type:

Status

_exec_mod_script()

Executes project modification script given in command line arguments.

Returns:

status code

Return type:

Status

_execute_project()

Executes all DAGs in a project.

Returns:

status code

Return type:

Status

_process_engine_event(event_type, data)

event(e)

_handle_node_execution_started(data)

Starts collecting messages from given node.

Parameters:

data (dict) – execution start data

_handle_node_execution_finished(data)

Prints messages for finished nodes.

Parameters:

data (dict) – execution end data

_handle_event_msg(data)

Stores event messages for later printing.

Parameters:

data (dict) – event message data

_handle_process_msg(data)

Stores process messages for later printing.

Parameters:

data (dict) – process message data

_handle_standard_execution_msg(data)

Handles standard execution messages.

Currently, these messages are ignored.

Parameters:

data (dict) – execution message data

_handle_persistent_execution_msg(data)

Handles persistent execution messages.

Parameters:

data (dict) – execution message data

_handle_kernel_execution_msg(data)

Handles kernel messages.

Currently, these messages are ignored.

Parameters:

data (dict) – message data

_handle_server_status_msg(data)

Handles received remote execution messages.

_read_server_config()

Reads the user provided server settings file that the client requires to establish connection.

Returns:

Dictionary containing the EngineClient settings or None if the given config file does not exist.

Return type:

dict

_insert_remote_engine_settings(settings)

Inserts remote engine client settings into the settings dictionary that is delivered to the engine.

Parameters:

settings (dict) – Original settings dictionary

Returns:

Settings dictionary containing remote engine client settings

Return type:

dict

_prepare_remote_execution()

If remote execution is enabled, makes an EngineClient for pinging and uploading the project. If ping is successful, the project is uploaded to the server. If the upload is successful, the server responds with a Job id, which is later used by the client to make a ‘start execution’ request.

Returns:

Job id if server is ready for remote execution, empty string if something went wrong

or “1” if local execution is enabled.

Return type:

str

spinetoolbox.headless.headless_main(args)

Executes a project using QCoreApplication.

Parameters:

args (argparser.Namespace) – parsed command line arguments.

Returns:

exit status code; 0 for success, everything else for failure

Return type:

int

spinetoolbox.headless.open_project(project_dict, project_dir, logger)

Opens a project.

Parameters:

• project_dict (dict) – a serialized project dictionary

• project_dir (Path) – path to a directory containing the .spinetoolbox dir

• logger (LoggerInterface) – a logger

Returns:

item dicts, specification dicts, connection dicts, jump dicts and a DagHandler object

Return type:

tuple

spinetoolbox.headless._specification_dicts(project_dict, project_dir, logger)

Loads project item specification dictionaries.

Parameters:

• project_dict (dict) – a serialized project dictionary

• project_dir (str) – path to a directory containing the .spinetoolbox dir

• logger (LoggerInterface) – a logger

Returns:

a mapping from item type to a list of specification dicts

Return type:

dict

spinetoolbox.headless.solve_project_dir(pd)

Makes given path object OS independent.

Parameters:

pd (Path) – Path Object

Returns:

OS independent path as string.

Return type:

str

class spinetoolbox.headless.Status

Bases: enum.IntEnum

Status codes returned from headless execution.

Initialize self. See help(type(self)) for accurate signature.

OK = 0

ERROR = 1

ARGUMENT_ERROR = 2