framework::ConfigurePython Class Reference

Utility class which reads/executes a python script and creates a Process object based on the input. More...

#include <ConfigurePython.h>

Public Member Functions
	ConfigurePython (const std::string &pythonScript, char *args[], int nargs)
	Class constructor.
	~ConfigurePython ()=default
	Class destructor.
ProcessHandle	makeProcess ()
	Create a process object based on the python file information.
const framework::config::Parameters	get () const
	Get a handle to the configuration.

Static Public Attributes
static std::string	root_module = "ldmxcfg"
	the root configuration module name
static std::string	root_class = "Process"
	the root configuration class name
static std::string	root_object = "lastProcess"
	the root configuration object name

Private Attributes
framework::config::Parameters	configuration_
	The entire configuration for this process.

Detailed Description

Utility class which reads/executes a python script and creates a Process object based on the input.

Note

The configuration language is documented in the overall Framework package documentation.

Definition at line 19 of file ConfigurePython.h.

Constructor & Destructor Documentation

ConfigurePython()

framework::ConfigurePython::ConfigurePython	(	const std::string &	pythonScript,
		char *	args[],
		int	nargs
	)

Class constructor.

This method contains all the parsing and execution of the python script.

Exceptions

Exception

if any necessary components of the python configuration are missing. e.g. The Process class or the different members of the lastProcess object.

The basic premise of this constructor is to execute the python configuration script by loading it into python as a module. Then, after the script has been executed, all of the parameters for the Process and EventProcessors are gathered from python. The fact that the script has been executed means that the user can get up to a whole lot of shenanigans that can help them make their work more efficient.

Parameters

pythonScript	Filename location of the python script.
args	Commandline arguments to be passed to the python script.
nargs	Number of commandline arguments.

Definition at line 273 of file ConfigurePython.cxx.

                                            {
  // assumes that nargs >= 0
  //  this is true always because we error out if no python script has been
  //  found
 
  // load a handle to the config file into memory (and check that it exists)
  FILE* config_file{fopen(pythonScript.c_str(), "r")};
  if (config_file == NULL) {
    EXCEPTION_RAISE("ConfigDNE",
                    "Passed config script '" + pythonScript +
                        "' is not accessible.\n"
                        "    Did you make a typo in the path to the script?\n"
                        "    Are you referencing a directory that is not "
                        "mounted to the container?");
  }
 
  std::string cmd = pythonScript;
  if (pythonScript.rfind("/") != std::string::npos) {
    cmd = pythonScript.substr(pythonScript.rfind("/") + 1);
  }
  cmd = cmd.substr(0, cmd.find(".py"));
 
  // python needs the argument list as if you are on the command line
  //  targs = [ script , arg0 , arg1 , ... ] ==> len(targs) = nargs+1
  // PySys_SetArgvEx uses wchar_t instead of char in python3
  wchar_t** targs = new wchar_t*[nargs + 1];
  targs[0] = Py_DecodeLocale(pythonScript.c_str(), NULL);
  for (int i = 0; i < nargs; i++) targs[i + 1] = Py_DecodeLocale(args[i], NULL);
 
  // name our program after the script that is being run
  Py_SetProgramName(targs[0]);
 
  // start up python interpreter
  Py_Initialize();
 
  // The third argument to PySys_SetArgvEx tells python to import
  // the args and add the directory of the first argument to
  // the PYTHONPATH
  // This way, the command to import the module just needs to be
  // the name of the python script
  PySys_SetArgvEx(nargs + 1, targs, 1);
 
  // run the file as a python script
  if (PyRun_AnyFile(config_file, pythonScript.c_str()) != 0) {
    PyErr_Print();
    EXCEPTION_RAISE("ConfigureError", "Problem running python script.");
  }
 
  // script has been run so we can
  // free up arguments to python script
  fclose(config_file);
  for (int i = 0; i < nargs + 1; i++) PyMem_RawFree(targs[i]);
  delete[] targs;
 
  // when a script runs in python, the script itself becomes the module
  // named __main__, we retrieve a handle to that module by "importing"
  // it (since it is already within the python interpreter, we are just
  // getting the handle and not actually running anything here
  PyObject* script = PyImport_ImportModule("__main__");
  if (script == NULL) {
    PyErr_Print();
    EXCEPTION_RAISE("ConfigureError", "Problem loading python script");
  }
  PyObject* pCMod = PyObject_GetAttrString(script, root_module.c_str());
  Py_DECREF(script);  // don't need the script anymore
  if (pCMod == 0) {
    PyErr_Print();
    EXCEPTION_RAISE("ConfigureError",
                    "Did not import root configuration module " + root_module);
  }
 
  PyObject* pProcessClass = PyObject_GetAttrString(pCMod, root_class.c_str());
  Py_DECREF(pCMod);  // don't need the config module anymore
  if (pProcessClass == 0) {
    PyErr_Print();
    EXCEPTION_RAISE("ConfigureError",
                    "Did not import root configuration class " + root_class);
  }
 
  PyObject* pProcess =
      PyObject_GetAttrString(pProcessClass, root_object.c_str());
  Py_DECREF(pProcessClass);  // don't need the Process class anymore
  if (pProcess == 0) {
    // wasn't able to get lastProcess class member
    PyErr_Print();
    EXCEPTION_RAISE(
        "ConfigureError",
        "Process object not defined. This object is required to run.");
  } else if (pProcess == Py_None) {
    // lastProcess was left undefined
    EXCEPTION_RAISE("ConfigureError",
                    "Did not create a configuration class instance");
  }
 
  // okay, now we have fully imported the script and gotten the handle
  // to the last Process object defined in the script.
  // We can now look at pProcess and get all of our parameters out of it.
 
  configuration_.setParameters(getMembers(pProcess));
 
  // all done with python nonsense
  // delete one parent python object
  // MEMORY still not sure if this is enough, but not super worried about it
  //  because this only happens once per run
  Py_DECREF(pProcess);
  // close up python interpreter
  if (Py_FinalizeEx() < 0) {
    PyErr_Print();
    EXCEPTION_RAISE("PyError",
                    "I wasn't able to close up the python interpreter!");
  }
}

References configuration_, framework::getMembers(), root_class, root_module, root_object, and framework::config::Parameters::setParameters().

~ConfigurePython()

framework::ConfigurePython::~ConfigurePython ( )

default

Class destructor.

Does nothing at the moment.

Member Function Documentation

get()

const framework::config::Parameters framework::ConfigurePython::get ( ) const

inline

Get a handle to the configuration.

Definition at line 71 of file ConfigurePython.h.

{ return configuration_; }

References configuration_.

makeProcess()

ProcessHandle framework::ConfigurePython::makeProcess

(

)

Create a process object based on the python file information.

No python parsing actually happens in this function. All of the parsing is done in the constructor, this just copies that information from configuration_ into the Process object.

Returns

ProcessHandle handle to process that is configured and ready to go

Definition at line 387 of file ConfigurePython.cxx.

                                           {
  // no python nonsense happens in here,
  // this just takes the parameters determined earlier
  // and puts them into the Process + EventProcessor framework
 
  return std::make_unique<Process>(configuration_);
}

References configuration_.

Member Data Documentation

configuration_

framework::config::Parameters framework::ConfigurePython::configuration_

private

The entire configuration for this process.

Contains all parameters that were passed in the python in a recursive manner. For example, this would contain a key called 'sequence' that has a value of a vector of Parmaeters, each one corresponding to a processor.

Definition at line 82 of file ConfigurePython.h.

Referenced by ConfigurePython(), get(), and makeProcess().

root_class

std::string framework::ConfigurePython::root_class = "Process"

static

the root configuration class name

Definition at line 24 of file ConfigurePython.h.

Referenced by ConfigurePython().

root_module

std::string framework::ConfigurePython::root_module = "ldmxcfg"

static

the root configuration module name

Definition at line 22 of file ConfigurePython.h.

Referenced by ConfigurePython().

root_object

std::string framework::ConfigurePython::root_object = "lastProcess"

static

the root configuration object name

Definition at line 26 of file ConfigurePython.h.

Referenced by ConfigurePython().

---

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

• Framework/include/Framework/ConfigurePython.h
• Framework/src/Framework/ConfigurePython.cxx