Core documentation

Package for sequence execution.

Engine module

Main module for sequence execution

class sequence.core.engine.SequenceEngine

Main class of the sequence engine

interrupt()

Interrupt the sequence execution

load(xml_file, max_depth=None, backup=None)

Load an xml file

Parameters:

• xml_file – str – path of the xml file to load
• max_depth – int – maximum depth for sequence creation
• backup – str – path of the xml backup file

start()

Start the sequence

wait(timeout=None)

Wait for the sequence to terminate Return False if the timeout is expired, True otherwise

class sequence.core.engine.SequenceLoggingFormatter(fmt=None, datefmt=None)

A log formatter customized to handle sequence execution logs

format(record)

Override the “format” method of the Formatter class

sequence.core.engine.add_log_handler(handler)

Add a log handler to the execution logger

sequence.core.engine.stream_sequence_logs(stream, debug_level=20)

Add the custom stream handler to the execution logger

Runable sequence module

Module for running sequences

class sequence.core.runable.AbstractExecution(thread)

Class providing a basis for execution implementation

class sequence.core.runable.ActionExecution(thread)

Class implementing an action execution

class sequence.core.runable.BranchExecution(thread)

Class implementing a branch execution

add_thread(thread)

Append a thread to join to the list

class sequence.core.runable.ResetTimeExecution(thread)

Class implementing a time reset execution

class sequence.core.runable.RootSequenceThread(xml_sequence, stop_thread_parent=None)

Class to implement the root sequence and run it in a thread

run()

Run the root sequence

stop()

Stop the current sequence execution. Note that it is not necessarily the “self” instance.

class sequence.core.runable.RunableSequence(xml_sequence, stop_thread, root=False)

Class for creating runable sequences and subsequences

class TimeReference

Class for creating a specific time reference

reset()

Reset the time reference

wait(arg)

Wait until the time reference equals the time parameter

RunableSequence.load()

Load the content of the XML sequence

RunableSequence.run()

Run the sequence

class sequence.core.runable.SequenceThread(sequence, starter=None, first=None)

Class to implement and execute a sequence thread

build_execution()

Build the next execution block of the sequence thread

generate_threads()

Generate the threads launched by the current sequence thread

increment()

Go to the next block

run()

Run method of the sequence thread

class sequence.core.runable.StopThread(main_thread)

Class implementing a mechanism to stop the whole sequence execution

add_backup(backup)

Add a backup to start when the stop mechanism is set

add_child(child)

Add a child to propagate stop signals to

add_starter(starter)

Add a starter to set when the stop mechanism is set

disable()

Disable the stop mechanism

enable()

Enable the stop mechanism

is_set()

Test if the stop mechanism is set

run()

Run the stop mechanism

set()

Start the stop mechanism if it is enabled, propagate to children otherwise

class sequence.core.runable.SubsequenceExecution(thread)

Class implementing a subsequence execution

class sequence.core.runable.WaitExecution(thread)

Class implementing a wait execution