Inheritance diagram for python.AnaAlgorithmConfig.AnaAlgorithmConfig:

Collaboration diagram for python.AnaAlgorithmConfig.AnaAlgorithmConfig:

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

def	getName (self)

def	getType (self)

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 Algorithm Configuration

This class is used to describe the configuration of an analysis algorithm
(a C++ class inheriting from EL::AnaAlgorithm) 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.AnaAlgorithmConfig import AnaAlgorithmConfig
   alg = AnaAlgorithmConfig( "EL::UnitTestAlg2/TestAlg",
                             property = 1.23 )
   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 AnaAlgorithmConfig.py.

Constructor & Destructor Documentation

◆ init()

def python.AnaAlgorithmConfig.AnaAlgorithmConfig.__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 = AnaAlgorithmConfig( "EL::UnitTestAlg2/TestAlg",
                     property = 1.23 )

Definition at line 36 of file AnaAlgorithmConfig.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 = AnaAlgorithmConfig( "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( AnaAlgorithmConfig, 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.AnaAlgorithmConfig.AnaAlgorithmConfig.__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 127 of file AnaAlgorithmConfig.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 AnaAlgorithmConfig one:
         if not isinstance( other, AnaAlgorithmConfig ):
             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.AnaAlgorithmConfig.AnaAlgorithmConfig.__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 82 of file AnaAlgorithmConfig.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.AnaAlgorithmConfig.AnaAlgorithmConfig.__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 142 of file AnaAlgorithmConfig.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.AnaAlgorithmConfig.AnaAlgorithmConfig.__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 101 of file AnaAlgorithmConfig.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( AnaAlgorithmConfig, self ).__setattr__( key, value )
  
         # Set the property, and remember its value:
         super( AnaAlgorithmConfig,
                self ).setPropertyFromString( key, stringPropValue( value ) )
         self._props[ key ] = copy.deepcopy( value )
         pass
  

◆ str()

def python.AnaAlgorithmConfig.AnaAlgorithmConfig.__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 150 of file AnaAlgorithmConfig.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 = ''
         if self.isPublicTool():
             name = 'Public Tool %s/%s' % ( self.type(), self.name() )
         else:
             name = 'Algorithm %s/%s' % ( self.type(), self.name() )
             pass
         result = AnaAlgorithmConfig._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 += AnaAlgorithmConfig._printFooter( name )
         return result
  

◆ _printFooter()

def python.AnaAlgorithmConfig.AnaAlgorithmConfig._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 278 of file AnaAlgorithmConfig.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 = AnaAlgorithmConfig.printHeaderPre
         postLength = AnaAlgorithmConfig.printHeaderWidth - 12 - preLength - \
             len( title )
         return '\\%s (End of %s) %s' % ( preLength * '-', title,
                                          postLength * '-' )
  

◆ _printHeader()

def python.AnaAlgorithmConfig.AnaAlgorithmConfig._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 261 of file AnaAlgorithmConfig.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 = AnaAlgorithmConfig.printHeaderPre
         postLength = AnaAlgorithmConfig.printHeaderWidth - 3 - preLength - \
             len( title )
         return '/%s %s %s' % ( preLength * '*', title, postLength * '*' )
  

◆ addPrivateTool()

def python.AnaAlgorithmConfig.AnaAlgorithmConfig.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 176 of file AnaAlgorithmConfig.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.AnaAlgorithmConfig.AnaAlgorithmConfig.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 219 of file AnaAlgorithmConfig.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
  

◆ getName()

def python.AnaAlgorithmConfig.AnaAlgorithmConfig.getName ( self )

Get the instance name of the algorithm

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

Definition at line 64 of file AnaAlgorithmConfig.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.AnaAlgorithmConfig.AnaAlgorithmConfig.getType ( self )

Get the type name of the algorithm

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

Definition at line 73 of file AnaAlgorithmConfig.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.AnaAlgorithmConfig.AnaAlgorithmConfig._props

private

Definition at line 54 of file AnaAlgorithmConfig.py.

◆ printHeaderPre

int python.AnaAlgorithmConfig.AnaAlgorithmConfig.printHeaderPre = 3

static

Definition at line 34 of file AnaAlgorithmConfig.py.

◆ printHeaderWidth

int python.AnaAlgorithmConfig.AnaAlgorithmConfig.printHeaderWidth = 80

static

Definition at line 33 of file AnaAlgorithmConfig.py.

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

AnaAlgorithmConfig.py

Public Member Functions

Static Public Attributes

Static Private Member Functions

Private Attributes