python.flagTestLOD Namespace Reference

Functions
def	_eval_deferred (expr, fdict, hookargs, **kw)
def	flagTestLOD (expr, flags, hook=None)
def	deferFlag (expr, flags, gdict={})

Function Documentation

_eval_deferred()

def python.flagTestLOD._eval_deferred (   expr,   fdict,   hookargs, **  kw  )

private

Definition at line 13 of file flagTestLOD.py.

def _eval_deferred (expr, fdict, hookargs, **kw):
    dd = fdict.copy()
    dd.update (hookargs)
    dd.update (kw)
    return eval (expr, globals(), dd)
 
 

deferFlag()

def python.flagTestLOD.deferFlag	(		expr,
			flags,
			gdict = {}
	)

Helper for making deferred arguments that evaluate flags.

Numerous parts of the D3PD configuration use arbitrary global flags
to control how tuples are configured.  This is bad because there
can be interference when multiple tuples are configured in the
same job.

Better is to pass the flags in as arguments to the D3PDObject and pass
them to blocks using the DeferArg mechanism.

This helper is to ease this conversion, while still allowing
backwards compatibility with flag-based configuration.

deferFlag will return a DeferArg object that evaluates
the provided expression string EXP.  This will be evaluated
in an environment that includes names for all flags in the flags
class(es) FLAGS, merged with the value of the hookargs.

So if you do something like

  myobj = make_SGDataVector_D3PDObject ('mycont', 'mykey', 'my_', 'myob',
                                        allow_args = ['doExtra'])
  myobj.defineBlock (0, 'myblock', filler_tool,
                     DoExtra = deferFlag ('doExtra', myFlags))

then the DoExtra property will be set from the property myFlags.doExtra()
unless it's overridden by passing an argument to the D3PDObject:

  alg += myobj (level, doExtra = True)

Flags are evaluated at the point where deferFlag is called.

GDICT gives extra names to be made available when evaluating EXPR.


Examples:
>>> from AthenaConfiguration.AllConfigFlags import initConfigFlags
>>> flags = initConfigFlags()
>>> flags.addFlag ('D3PD.flag3', True)

>>> arg = deferFlag ('flag3', flags.D3PD)
>>> arg()
True
>>> arg({'flag3':False})
False
>>> arg = deferFlag ('foo', flags.D3PD, {'foo' : 2})
>>> arg()
2

Definition at line 103 of file flagTestLOD.py.

def deferFlag (expr, flags, gdict={}):
    """Helper for making deferred arguments that evaluate flags.
 
    Numerous parts of the D3PD configuration use arbitrary global flags
    to control how tuples are configured.  This is bad because there
    can be interference when multiple tuples are configured in the
    same job.
 
    Better is to pass the flags in as arguments to the D3PDObject and pass
    them to blocks using the DeferArg mechanism.
 
    This helper is to ease this conversion, while still allowing
    backwards compatibility with flag-based configuration.
 
    deferFlag will return a DeferArg object that evaluates
    the provided expression string EXP.  This will be evaluated
    in an environment that includes names for all flags in the flags
    class(es) FLAGS, merged with the value of the hookargs.
 
    So if you do something like
 
      myobj = make_SGDataVector_D3PDObject ('mycont', 'mykey', 'my_', 'myob',
                                            allow_args = ['doExtra'])
      myobj.defineBlock (0, 'myblock', filler_tool,
                         DoExtra = deferFlag ('doExtra', myFlags))
 
    then the DoExtra property will be set from the property myFlags.doExtra()
    unless it's overridden by passing an argument to the D3PDObject:
 
      alg += myobj (level, doExtra = True)
 
    Flags are evaluated at the point where deferFlag is called.
 
    GDICT gives extra names to be made available when evaluating EXPR.
 
 
    Examples:
    >>> from AthenaConfiguration.AllConfigFlags import initConfigFlags
    >>> flags = initConfigFlags()
    >>> flags.addFlag ('D3PD.flag3', True)
 
    >>> arg = deferFlag ('flag3', flags.D3PD)
    >>> arg()
    True
    >>> arg({'flag3':False})
    False
    >>> arg = deferFlag ('foo', flags.D3PD, {'foo' : 2})
    >>> arg()
    2
"""
    fdict = flags.asdict()
    return DeferArg ('_eval_deferred(expr, fdict, locals(), **_gdict)',
                     expr = expr,
                     fdict = fdict,
                     _gdict = gdict,
                     _eval_deferred = _eval_deferred)

flagTestLOD()

def python.flagTestLOD.flagTestLOD	(		expr,
			flags,
			hook = None
	)

Helper for making LOD functions to evaluate flags.

Numerous parts of the D3PD configuration use arbitrary global flags
to control which blocks are included.  This is bad because there
can be interference when multiple tuples are configured in the
same job.

Better is to use the level-of-detail mechanism to do this,
passing in flags as extra arguments to the D3PDObject.

This helper is to ease this conversion, while still allowing
backwards compatibility with flag-based configuration.

flagTestLOD will return a level-of-detail function that evaluates
the provided expression string EXP.  This will be evaluated
in an environment that includes names for all flags in the flags
class(es) FLAGS, merged with the value of the hookargs.
The requested level of detail is also available as `reqlev'.
Thus, if you have something like:

    myobj = make_SGDataVector_D3PDObject ('mycont', 'mykey', 'my_', 'myob',
                                          allow_args = ['myLevel'])
    myobj.defineBlock (flagTestLOD('myLevel>2', myFlags),
                       'myblock', filler_tool)

then myblock will be included in the tuple if the property
myFlags.myLevel() is greater than two.  However, this can be overridden
by passing an argument to the D3PDObject:

    alg += myobj (level, myLevel=4)

Explicit inclusion / exclusion also overrides this determination.

Flags are evaluated at the point where flagTestLOD is called.

If HOOK is supplied, then it is called if the LOD test passes.
It is passed as arguments two dictionaries: the block filler tool
arguments and the hook arguments.

Examples:
>>> from AthenaConfiguration.AllConfigFlags import initConfigFlags
>>> flags = initConfigFlags()
>>> flags.addFlag ('D3PD.flag1', True)
>>> flags.addFlag ('D3PD.flag2', False)

>>> lod = flagTestLOD ('flag1', flags.D3PD)
>>> lod(2, {}, {})
True
>>> lod(2, {}, {'flag1': False})
False
>>> lod(-999, {}, {})
False
>>> lod(999, {}, {'flag1': False})
True
>>> lod = flagTestLOD ('flag2 or reqlev>4', flags.D3PD)
>>> lod(2, {}, {})
False
>>> lod(10, {}, {})
True
>>> def hook(*args):
...    print(args)
>>> lod = flagTestLOD ('flag2 or reqlev>4', flags.D3PD, hook)
>>> lod(2, {}, {})
False
>>> lod(10, {'a':1}, {'b':2})
({'a': 1}, {'b': 2})
True

Definition at line 20 of file flagTestLOD.py.

def flagTestLOD (expr, flags, hook = None):
    """Helper for making LOD functions to evaluate flags.
 
    Numerous parts of the D3PD configuration use arbitrary global flags
    to control which blocks are included.  This is bad because there
    can be interference when multiple tuples are configured in the
    same job.
 
    Better is to use the level-of-detail mechanism to do this,
    passing in flags as extra arguments to the D3PDObject.
 
    This helper is to ease this conversion, while still allowing
    backwards compatibility with flag-based configuration.
 
    flagTestLOD will return a level-of-detail function that evaluates
    the provided expression string EXP.  This will be evaluated
    in an environment that includes names for all flags in the flags
    class(es) FLAGS, merged with the value of the hookargs.
    The requested level of detail is also available as `reqlev'.
    Thus, if you have something like:
 
        myobj = make_SGDataVector_D3PDObject ('mycont', 'mykey', 'my_', 'myob',
                                              allow_args = ['myLevel'])
        myobj.defineBlock (flagTestLOD('myLevel>2', myFlags),
                           'myblock', filler_tool)
 
    then myblock will be included in the tuple if the property
    myFlags.myLevel() is greater than two.  However, this can be overridden
    by passing an argument to the D3PDObject:
 
        alg += myobj (level, myLevel=4)
 
    Explicit inclusion / exclusion also overrides this determination.
 
    Flags are evaluated at the point where flagTestLOD is called.
 
    If HOOK is supplied, then it is called if the LOD test passes.
    It is passed as arguments two dictionaries: the block filler tool
    arguments and the hook arguments.
 
    Examples:
    >>> from AthenaConfiguration.AllConfigFlags import initConfigFlags
    >>> flags = initConfigFlags()
    >>> flags.addFlag ('D3PD.flag1', True)
    >>> flags.addFlag ('D3PD.flag2', False)
 
    >>> lod = flagTestLOD ('flag1', flags.D3PD)
    >>> lod(2, {}, {})
    True
    >>> lod(2, {}, {'flag1': False})
    False
    >>> lod(-999, {}, {})
    False
    >>> lod(999, {}, {'flag1': False})
    True
    >>> lod = flagTestLOD ('flag2 or reqlev>4', flags.D3PD)
    >>> lod(2, {}, {})
    False
    >>> lod(10, {}, {})
    True
    >>> def hook(*args):
    ...    print(args)
    >>> lod = flagTestLOD ('flag2 or reqlev>4', flags.D3PD, hook)
    >>> lod(2, {}, {})
    False
    >>> lod(10, {'a':1}, {'b':2})
    ({'a': 1}, {'b': 2})
    True
"""
 
    fdict = flags.asdict()
    def flagTestLODFunc (reqlev, args, hookargs):
        if reqlev < 0:   return False # explicit exclusion
        if reqlev > 900:
            ret = True  # explicit inclusion
        else:
            ret = _eval_deferred (expr, fdict, hookargs, reqlev=reqlev)
        if ret and hook:
            hook (args, hookargs)
        return ret
    return flagTestLODFunc