Inheritance diagram for python.PythonConfig.PythonConfig:

Collaboration diagram for python.PythonConfig.PythonConfig:

Public Member Functions
def	__init__ (self, typeAndName, **kwargs)

def	getName (self)

def	getType (self)

def	addSelfToJob (self, job)

def	__getattr__ (self, name)

def	__setattr__ (self, key, value)

def	__eq__ (self, other)

def	__ne__ (self, other)

def	__str__ (self)

def	addPrivateTool (self, name, type)

def	addPrivateToolInArray (self, name, type)

Static Public Attributes
int	printHeaderWidth = 80

int	printHeaderPre = 3

Static Private Member Functions
def	_printHeader (title)

def	_printFooter (title)

Private Attributes
	_props

Detailed Description

Standalone Analysis Component Configuration

This class is used to describe the configuration of an analysis component
(a C++ class inheriting from asg::AsgComponentConfig) in Python. It behaves
similar to an Athena configurable, but is implemented in a much simpler
way.

An example of using it in configuring an EventLoop job could look like:

   job = ROOT.EL.Job()
   ...
   from AnaAlgorithm.PythonConfig import PythonConfig
   alg = PythonConfig( "EL::UnitTestAlg2/TestAlg",
                        property = 1.23 )
   alg.setComponentType( "AnaAlgorithm" )
   alg.string_property = "Foo"
   job.algsAdd( alg )

Note that the python code doesn't know what properties can actually be set
on any given C++ algorithm. Any mistake made in the Python configuration
(apart from syntax errors) is only discovered while initialising the
analysis job.

Definition at line 8 of file PythonConfig.py.

Constructor & Destructor Documentation

◆ init()

def python.PythonConfig.PythonConfig.__init__	(		self,
			typeAndName,
		**	kwargs
	)

Constructor for an algorithm configuration object

Keyword arguments:
  typeAndName -- The type/instance name of the algorithm

Note that you can pass (initial) properties to the constructor like:

   alg = PythonConfig( "EL::UnitTestAlg2/TestAlg",
               property = 1.23 )

Definition at line 37 of file PythonConfig.py.

     def __init__( self, typeAndName, **kwargs ):
         """Constructor for an algorithm configuration object
  
         Keyword arguments:
           typeAndName -- The type/instance name of the algorithm
  
         Note that you can pass (initial) properties to the constructor like:
  
            alg = PythonConfig( "EL::UnitTestAlg2/TestAlg",
                                property = 1.23 )
         """
  
         # Call the base class's constructor. Use the default constructor instead
         # of the one receiving the type and name, to avoid ROOT-10872.
         super( PythonConfig, self ).__init__()
         self.setTypeAndName( typeAndName )
  
         # Initialise the properties of the algorihm:
         self._props = {}
  
         # Set the properties on the object:
         for key, value in kwargs.items():
             self.setPropertyFromString( key, stringPropValue( value ) )
             self._props[ key ] = copy.deepcopy( value )
             pass
  
         pass
  

Member Function Documentation

◆ eq()

def python.PythonConfig.PythonConfig.__eq__	(	self,
		other
	)

Check for equality with another object

The implementation of this is very simple. We only check that the type
and the name of the algorithms would match.

Definition at line 137 of file PythonConfig.py.

     def __eq__( self, other ):
         """Check for equality with another object
  
         The implementation of this is very simple. We only check that the type
         and the name of the algorithms would match.
         """
  
         # First check that the other object is also an PythonConfig one:
         if not isinstance( other, PythonConfig ):
             return False
  
         # Now check whether the type and the name of the algorithms agree:
         return ( ( self.type() == other.type() ) and
                  ( self.name() == other.name() ) )
  

◆ getattr()

def python.PythonConfig.PythonConfig.__getattr__	(	self,
		name
	)

Get a previously set property value from the configuration

This function allows us to retrieve the value of a property that was
already set for the algorithm, to possibly use it in some configuration
decisions in the Python code itself.

Keyword arguments:
  name -- The name of the property

Definition at line 92 of file PythonConfig.py.

     def __getattr__( self, name ):
         """Get a previously set property value from the configuration
  
         This function allows us to retrieve the value of a property that was
         already set for the algorithm, to possibly use it in some configuration
         decisions in the Python code itself.
  
         Keyword arguments:
           name -- The name of the property
         """
  
         # Fail if the property was not (yet) set:
         if not name in self._props:
             raise AttributeError( 'Property \'%s\' was not set on \'%s/%s\'' %
                                   ( name, self.type(), self.name() ) )
  
         # Return the property value:
         return self._props[ name ]
  

◆ ne()

def python.PythonConfig.PythonConfig.__ne__	(	self,
		other
	)

Check for an inequality with another object

This is just defined to make the '!=' operator of Python behave
consistently with the '==' operator for such objects.

Definition at line 152 of file PythonConfig.py.

     def __ne__( self, other ):
         """Check for an inequality with another object
  
         This is just defined to make the '!=' operator of Python behave
         consistently with the '==' operator for such objects.
         """
         return not self.__eq__( other )
  

◆ setattr()

def python.PythonConfig.PythonConfig.__setattr__	(	self,
		key,
		value
	)

Set an algorithm property on an existing configuration object

This function allows us to set/override properties on an algorithm
configuration object. Allowing for the following syntax:

   alg = ...
   alg.IntProperty = 66
   alg.FloatProperty = 3.141592
   alg.StringProperty = "Foo"

Keyword arguments:
  key   -- The key/name of the property
  value -- The value to set for the property

Definition at line 111 of file PythonConfig.py.

     def __setattr__( self, key, value ):
         """Set an algorithm property on an existing configuration object
  
         This function allows us to set/override properties on an algorithm
         configuration object. Allowing for the following syntax:
  
            alg = ...
            alg.IntProperty = 66
            alg.FloatProperty = 3.141592
            alg.StringProperty = "Foo"
  
         Keyword arguments:
           key   -- The key/name of the property
           value -- The value to set for the property
         """
  
         # Private variables should be set directly:
         if key[ 0 ] == '_':
             return super( PythonConfig, self ).__setattr__( key, value )
  
         # Set the property, and remember its value:
         super( PythonConfig,
                self ).setPropertyFromString( key, stringPropValue( value ) )
         self._props[ key ] = copy.deepcopy( value )
         pass
  

◆ str()

def python.PythonConfig.PythonConfig.__str__ ( self )

Print the algorithm configuration in a user friendly way

This is just to help with debugging configurations, allowing
the user to get a nice printout of their job configuration.

Definition at line 160 of file PythonConfig.py.

     def __str__( self ):
         """Print the algorithm configuration in a user friendly way
  
         This is just to help with debugging configurations, allowing
         the user to get a nice printout of their job configuration.
         """
  
         name = 'PythonConfig %s/%s/%s' % ( self.componentType(),self.type(), self.name() )
         result = PythonConfig._printHeader( name )
         result += '\n'
         for key, value in sorted( self._props.items() ):
             if isinstance( value, str ):
                 printedValue = "'%s'" % value
             else:
                 printedValue = value
                 pass
             result += "|- %s: %s\n" % ( key, indentBy( printedValue, "| " ) )
             pass
         result += PythonConfig._printFooter( name )
         return result
  

◆ _printFooter()

def python.PythonConfig.PythonConfig._printFooter ( title )

staticprivate

Produce a nice footer when printing the configuration

This function is used for printing the footer of both algorithms
and tools.

Keyword arguments:
  indentString -- String used as indentation
  title        -- The title of the algorithm/tool

Definition at line 283 of file PythonConfig.py.

     def _printFooter( title ):
         """Produce a nice footer when printing the configuration
  
         This function is used for printing the footer of both algorithms
         and tools.
  
         Keyword arguments:
           indentString -- String used as indentation
           title        -- The title of the algorithm/tool
         """
  
         preLength = PythonConfig.printHeaderPre
         postLength = PythonConfig.printHeaderWidth - 12 - preLength - \
             len( title )
         return '\\%s (End of %s) %s' % ( preLength * '-', title,
                                          postLength * '-' )
  

◆ _printHeader()

def python.PythonConfig.PythonConfig._printHeader ( title )

staticprivate

Produce a nice header when printing the configuration

This function is used for printing the header of both algorithms
and tools.

Keyword arguments:
  indentString -- String used as indentation
  title        -- The title of the algorithm/tool

Definition at line 266 of file PythonConfig.py.

     def _printHeader( title ):
         """Produce a nice header when printing the configuration
  
         This function is used for printing the header of both algorithms
         and tools.
  
         Keyword arguments:
           indentString -- String used as indentation
           title        -- The title of the algorithm/tool
         """
  
         preLength = PythonConfig.printHeaderPre
         postLength = PythonConfig.printHeaderWidth - 3 - preLength - \
             len( title )
         return '/%s %s %s' % ( preLength * '*', title, postLength * '*' )
  

◆ addPrivateTool()

def python.PythonConfig.PythonConfig.addPrivateTool	(	self,
		name,
		type
	)

Create a private tool for the algorithm

This function is used in 'standalone' mode to declare a private tool
for the algorithm, or a private tool for an already declared private
tool.

Can be used like:
  config.addPrivateTool( 'tool1', 'ToolType1' )
  config.addPrivateTool( 'tool1.tool2', 'ToolType2' )

Keyword arguments:
  name -- The full name of the private tool
  type -- The C++ type of the private tool

Definition at line 181 of file PythonConfig.py.

     def addPrivateTool( self, name, type ):
         """Create a private tool for the algorithm
  
         This function is used in 'standalone' mode to declare a private tool
         for the algorithm, or a private tool for an already declared private
         tool.
  
         Can be used like:
           config.addPrivateTool( 'tool1', 'ToolType1' )
           config.addPrivateTool( 'tool1.tool2', 'ToolType2' )
  
         Keyword arguments:
           name -- The full name of the private tool
           type -- The C++ type of the private tool
         """
  
         # And now set up the Python object that will take care of setting
         # properties on this tool.
  
         # Tokenize the tool's name. In case it is a subtool of a tool, or
         # something possibly even deeper.
         toolNames = name.split( '.' )
  
         # Look up the component that we need to set up the private tool on.
         component = self
         for tname in toolNames[ 0 : -1 ]:
             component = getattr( component, tname )
             pass
  
         # Check that the component doesn't have such a (tool) property yet.
         if hasattr( component, toolNames[ -1 ] ):
             raise RuntimeError( "Tool with name '%s' already exists" % name )
             pass
  
         # Now set up a smart object as a property on that component.
         component._props[ toolNames[ -1 ] ] = PrivateToolConfig( self, name,
                                                                  type )
  
         # Finally, tell the C++ code what to do.
         self.createPrivateTool( name, type ).ignore()
  
         pass
  

◆ addPrivateToolInArray()

def python.PythonConfig.PythonConfig.addPrivateToolInArray	(	self,
		name,
		type
	)

Create a private tool in an array for the algorithm

This function is used in 'standalone' mode to declare a
private tool in a tool array for the algorithm, or a private
tool in a tool array for an already declared private tool.

Can be used like:
  tool = config.addPrivateToolInArray( 'tool1', 'ToolType1' )
  tool = config.addPrivateToolInArray( 'tool1.tool2', 'ToolType2' )

Keyword arguments:
  name -- The full name of the private tool
  type -- The C++ type of the private tool

Definition at line 224 of file PythonConfig.py.

     def addPrivateToolInArray( self, name, type ):
         """Create a private tool in an array for the algorithm
  
         This function is used in 'standalone' mode to declare a
         private tool in a tool array for the algorithm, or a private
         tool in a tool array for an already declared private tool.
  
         Can be used like:
           tool = config.addPrivateToolInArray( 'tool1', 'ToolType1' )
           tool = config.addPrivateToolInArray( 'tool1.tool2', 'ToolType2' )
  
         Keyword arguments:
           name -- The full name of the private tool
           type -- The C++ type of the private tool
         """
  
         # And now set up the Python object that will take care of setting
         # properties on this tool.
  
         # Tokenize the tool's name. In case it is a subtool of a tool, or
         # something possibly even deeper.
         toolNames = name.split( '.' )
  
         # Look up the component that we need to set up the private tool on.
         component = self
         for tname in toolNames[ 0 : -1 ]:
             component = getattr( component, tname )
             pass
  
         # Finally, tell the C++ code what to do.
         actualName = self.createPrivateToolInArray( name, type )
  
         # Tokenize the actual tool's name. In case it is a subtool of
         # a tool, or something possibly even deeper.
         actualToolNames = actualName.split( '.' )
  
         # Now set up a smart object as a property on that component.
         config = PrivateToolConfig( self, actualName, type )
         component._props[ actualToolNames[ -1 ] ] = config
         return config
  

◆ addSelfToJob()

def python.PythonConfig.PythonConfig.addSelfToJob	(	self,
		job
	)

add a copy of this config to the EventLoop job object

Keyword arguments:
  job      -- The job object to add ourself to

Definition at line 83 of file PythonConfig.py.

     def addSelfToJob( self, job ):
         """add a copy of this config to the EventLoop job object
  
         Keyword arguments:
           job      -- The job object to add ourself to
         """
         job.algsAdd( self )
         pass
  

◆ getName()

def python.PythonConfig.PythonConfig.getName ( self )

Get the instance name of the algorithm

This is for compatibility with the getName() function of Athena
configurables.

Definition at line 65 of file PythonConfig.py.

     def getName( self ):
         """Get the instance name of the algorithm
  
         This is for compatibility with the getName() function of Athena
         configurables.
         """
  
         return self.name()
  

◆ getType()

def python.PythonConfig.PythonConfig.getType ( self )

Get the type name of the algorithm

This is for compatibility with the getType() function of Athena
configurables.

Definition at line 74 of file PythonConfig.py.

     def getType( self ):
         """Get the type name of the algorithm
  
         This is for compatibility with the getType() function of Athena
         configurables.
         """
  
         return self.type()
  

Member Data Documentation

◆ _props

python.PythonConfig.PythonConfig._props

private

Definition at line 55 of file PythonConfig.py.

◆ printHeaderPre

int python.PythonConfig.PythonConfig.printHeaderPre = 3

static

Definition at line 35 of file PythonConfig.py.

◆ printHeaderWidth

int python.PythonConfig.PythonConfig.printHeaderWidth = 80

static

Definition at line 34 of file PythonConfig.py.

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

PythonConfig.py

Public Member Functions

Static Public Attributes

Static Private Member Functions

Private Attributes