Inheritance diagram for python.AnaAlgorithmConfig.AnaAlgorithmConfig:

Collaboration diagram for python.AnaAlgorithmConfig.AnaAlgorithmConfig:

Public Member Functions
	__init__ (self, typeAndName, **kwargs)
	getName (self)
	getType (self)
	__getattr__ (self, name)
	__setattr__ (self, key, value)
	__eq__ (self, other)
	__str__ (self)
	addPrivateTool (self, name, type)
	addPrivateToolInArray (self, name, type)

Static Public Attributes
int	printHeaderWidth = 80
int	printHeaderPre = 3

Static Protected Member Functions
	_printHeader (title)
	_printFooter (title)

Protected Attributes
dict	_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()

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().__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 )
 

Member Function Documentation

◆ eq()

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()

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 79 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
        """
 
        # Short-circuit internal/dunder attribute lookups, which are never
        # properties (and would otherwise recurse if '_props' is missing):
        if name.startswith( '_' ):
            raise AttributeError( name )
 
        # Fail if the property was not (yet) set:
        if name not in self._props:
            raise AttributeError( f"Property '{name}' was not set on "
                                  f"'{self.type()}/{self.name()}'" )
 
        # Return the property value:
        return self._props[ name ]
 

◆ setattr()

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 103 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().__setattr__( key, value )
 
        # Set the property, and remember its value:
        super().setPropertyFromString( key, stringPropValue( value ) )
        self._props[ key ] = copy.deepcopy( value )
 

◆ str()

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 142 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.
        """
 
        if self.isPublicTool():
            name = f'Public Tool {self.type()}/{self.name()}'
        else:
            name = f'Algorithm {self.type()}/{self.name()}'
        result = AnaAlgorithmConfig._printHeader( name )
        result += '\n'
        for key, value in sorted( self._props.items() ):
            if isinstance( value, str ):
                printedValue = f"'{value}'"
            else:
                printedValue = value
            result += f"|- {key}: {indentBy( printedValue, '| ' )}\n"
        result += AnaAlgorithmConfig._printFooter( name )
        return result
 

◆ _printFooter()

python.AnaAlgorithmConfig.AnaAlgorithmConfig._printFooter ( title )

staticprotected

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 261 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 f"\\{preLength * '-'} (End of {title}) {postLength * '-'}"
 
 

◆ _printHeader()

python.AnaAlgorithmConfig.AnaAlgorithmConfig._printHeader ( title )

staticprotected

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 244 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 f"/{preLength * '*'} {title} {postLength * '*'}"
 

◆ addPrivateTool()

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 164 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 )
 
        # Check that the component doesn't have such a (tool) property yet.
        if hasattr( component, toolNames[ -1 ] ):
            raise RuntimeError( f"Tool with name '{name}' already exists" )
 
        # 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()
 

◆ addPrivateToolInArray()

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 203 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 )
 
        # 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()

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 61 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()

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 70 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

dict python.AnaAlgorithmConfig.AnaAlgorithmConfig._props = {}

protected

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 Protected Member Functions

Protected Attributes