hep_ipython_tools
5.6.7. hep_ipython_tools#
- class hep_ipython_tools.IPythonHandler[source]#
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()
andprocess_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)
- static create_queue()[source]#
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.
- information#
A shortcut for returning information on the environment.
- log_files#
A list of open log files.
- next_log_file_name()[source]#
Return the name of the next log file. If there are more than 20 log files present, start deleting the oldest ones.
- process(result_queue=None, **kwargs)[source]#
Turn a parameter set into a Calculation that you can start, stop or whatever you want.
- Parameters
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.
- process_parameter_space(kwargs_creator_function, **parameter_lists)[source]#
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).
- Parameters
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.
- hep_ipython_tools.handler = <hep_ipython_tools.ipython_handler.IPythonHandler object>#
Create a single instance