IPythonHandler Class Reference

Inheritance diagram for IPythonHandler:

Public Member Functions
def	__init__ (self)
def	process (self, result_queue=None, **kwargs)
def	process_parameter_space (self, kwargs_creator_function, **parameter_lists)
def	next_log_file_name (self)

Static Public Member Functions
def	create_queue ()

Public Attributes
	log_files
	A list of open log files.
	information
	A shortcut for returning information on the environment.

Private Attributes
	_calculation_type
	The calculation type to use.

Detailed Description

Handler class to start processes in an IPython notebook in a convenient way.
From this whole framework you should not need to create any instances by yourself but rather use the
given ipython handler for this.

Create a handler object in the beginning of your NB and use the two methods `process()`
and `process_parameter_space()` to turn parameters or a parameter creator function into a Calculation.
Do not create calculations on you own::

    from tracking.validation.ipython_handler import handler

    calculation = handler.process(parameters)

Definition at line 14 of file ipython_handler.py.

Constructor & Destructor Documentation

__init__()

def __init__

(

self

)

Each created log file gets registered and deleted if there are more than 20 log files present
or if the get_log function of the process is called (the log is saved elsewhere).
As the log files are saved to /tmp you have probably not to care about deleting them.

Reimplemented in Basf2IPythonHandler.

Definition at line 31 of file ipython_handler.py.

    def __init__(self):
        """
        Each created log file gets registered and deleted if there are more than 20 log files present
        or if the get_log function of the process is called (the log is saved elsewhere).
        As the log files are saved to /tmp you have probably not to care about deleting them.
        """
 
        
        self.log_files = []
 
        
        self.information = information.EnvironmentInformation()
 
        
        self._calculation_type = calculation.Calculation
 

Member Function Documentation

create_queue()

def create_queue ( )

static

Create a Calculation queue. You need to do this if you want to pass it to your modules
and write to it while processing the events.

Definition at line 138 of file ipython_handler.py.

next_log_file_name()

def next_log_file_name

(

self

)

Return the name of the next log file.
If there are more than 20 log files present,
start deleting the oldest ones.

Definition at line 117 of file ipython_handler.py.

process()

def process	(		self,
			result_queue = None,
		**	kwargs
	)

Turn a parameter set into a Calculation that you can start, stop or whatever you want.

Arguments:
    result_queue: The CalculationQueue you want to use. Without giving
        this as a parameter the function creates one for you. Create
        one on your own with the function create_queue.

Definition at line 47 of file ipython_handler.py.

process_parameter_space()

def process_parameter_space	(		self,
			kwargs_creator_function,
		**	parameter_lists
	)

Create a list of calculations by combining all parameters with all parameters you provide and
feeding the tuple into the parameter_creator_function.
If the kwargs_creator_function has a parameter named queue, the function feeds the corresponding
created queue into the parameter_creator_function.
The parameter_creator_function must return a dictionary for every combination of parameters it gets,
which will be used to construct a process out of it.
See ipython_handler_basf2/ipython_handler for an example.

Please note that a list of calculations acts the same as a single calculation you would get from
the process function. You can handle 10 calculations the same way you would handle a single one.

The kwargs_creator_function can transform the incoming parameters into different ones. To make this
more clear, the resulting dictionary created by the kwargs_creator_function is called kwargs.
These are the ones, that will be used to create a calculation process, so they must be compatible to the
calculation you chose (namely compatible with the append function of the _calculation_type).

Arguments:
    kwargs_creator_function: A function with as many input parameters
        as parameters you provide.  If the function has an additional
        queue parameter it is fed with the corresponding queue for this
        calculation.
    parameter_lists: As many lists as you want. Every list is one
        parameter. If you do not want a specific parameter
        constellation to occur, you can return None in your
        parameter_creator_function for this combination.

Usage::

    def kwargs_creator_function(par_1, par_2, par_3, queue):
        kwargs = {... f(par_1) ... g(par_2) ... h(par_3)}
        queue.put(..., ...)
        return kwargs

    calculations = handler.process_parameter_space(kwargs_creator_function,
                                                   par_1=[1, 2, 3], par_2=["x", "y", "z"], par_3=[3, 4, 5])

The calculations will be created with the kwargs arguments.

Definition at line 65 of file ipython_handler.py.

---

The documentation for this class was generated from the following file:

• framework/scripts/hep_ipython_tools/ipython_handler.py