Gaudi.Main Namespace Reference

Classes
class	BootstrapHelper
class	gaudimain

Functions
def	_getAllOpts_old (explicit_defaults=False)
def	getAllOpts (explicit_defaults=False)
def	toOpt (value)
def	parseOpt (s)

Variables
	log = logging.getLogger(__name__)

Function Documentation

_getAllOpts_old()

def Gaudi.Main._getAllOpts_old (   explicit_defaults = False )

private

Return all options from the old configuration system as a dictionary.

If explicit_defaults is true, include default values of unset properties in the dictionary.

Definition at line 172 of file Main.py.

def _getAllOpts_old(explicit_defaults=False):
    """
    Return all options from the old configuration system as a dictionary.
 
    If explicit_defaults is true, include default values of unset properties in the dictionary.
    """
    from itertools import chain
    from GaudiKernel.Proxy.Configurable import Configurable, getNeededConfigurables
 
    old_opts = {}
 
    # some algorithms may be generater when we call "getValuedProperties"
    # so we need a few iterations before we get the full list
    # (see GaudiConfig.ControlFlow)
    needed_conf = []
    count = 0
    new_count = -1
    while count != new_count:
        count = new_count
        needed_conf = getNeededConfigurables()
        new_count = len(needed_conf)
        for n in needed_conf:
            c = Configurable.allConfigurables[n]
            if hasattr(c, 'getValuedProperties'):
                c.getValuedProperties()
 
    for n in needed_conf:
        c = Configurable.allConfigurables[n]
        items = (chain(c.getDefaultProperties().items(),
                       c.getValuedProperties().items())
                 if explicit_defaults else c.getValuedProperties().items())
        for p, v in items:
            # Note: AthenaCommon.Configurable does not have Configurable.PropertyReference
            if hasattr(Configurable, "PropertyReference") and type(
                    v) == Configurable.PropertyReference:
                # this is done in "getFullName", but the exception is ignored,
                # so we do it again to get it
                v = v.__resolve__()
            if isinstance(v, str):
                # properly escape quotes in the string (see gaudi/Gaudi#78)
                v = '"%s"' % v.replace('"', '\\"')
            elif sys.version_info < (3, ) and isinstance(v, long):
                v = '%d' % v  # prevent pending 'L'
            elif hasattr(v, '__opt_value__'):
                v = v.__opt_value__()
            old_opts['.'.join((n, p))] = str(v)
 
    return old_opts
 
 

getAllOpts()

def Gaudi.Main.getAllOpts

(

explicit_defaults = False

)

Return all options from the old and configuration system as a dictionary.

If explicit_defaults is true, include default values of unset properties in the dictionary.

Definition at line 222 of file Main.py.

def getAllOpts(explicit_defaults=False):
    """
    Return all options from the old and configuration system as a dictionary.
 
    If explicit_defaults is true, include default values of unset properties in the dictionary.
    """
    import GaudiConfig2
    # We need to run normal (without defaults) collection first (regardless of explicit_defaults)
    # as the conflicts detection makes sense only for explicitly set options
    old_opts = _getAllOpts_old(False)
    opts = GaudiConfig2.all_options(False)
 
    conflicts = [
        n for n in set(opts).intersection(old_opts) if opts[n] != old_opts[n]
    ]
    if conflicts:
        conflicts.sort()
        log.error('Some properties are set in old and new style configuration')
        log.warning('name: old -> new')
        for n in conflicts:
            log.warning('%s: %s -> %s', n, old_opts[n], opts[n])
            sys.exit(10)
 
    opts.update(old_opts)
 
    if explicit_defaults:
        # If we are asked to print also the defaults, we collect everything
        # and blindly merge to make sure we have the full set of configurables
        all_opts = _getAllOpts_old(True)
        all_opts.update(GaudiConfig2.all_options(True))
        # the we override the dictionary with the explicitly set options
        # (that leaves the defaults untouched and the set options with the
        # correct value)
        all_opts.update(opts)
        opts = all_opts
 
    return opts
 
 

parseOpt()

def Gaudi.Main.parseOpt

(

s

)

Helper to parse option strings to Python values.

Ideally it should just be "eval", but the string parser of Gaudi
is different from the Python one, so we get string options that
cannot be just evaluated.

>>> print(parseOpt('123'))
123
>>> print(parseOpt('"some\\n\\\\"text\\\\""'))
some
"text"
>>> print(parseOpt(''))
<BLANKLINE>

(see gaudi/Gaudi#78)

Definition at line 284 of file Main.py.

def parseOpt(s):
    '''
    Helper to parse option strings to Python values.
 
    Ideally it should just be "eval", but the string parser of Gaudi
    is different from the Python one, so we get string options that
    cannot be just evaluated.
 
    >>> print(parseOpt('123'))
    123
    >>> print(parseOpt('"some\\n\\\\"text\\\\""'))
    some
    "text"
    >>> print(parseOpt(''))
    <BLANKLINE>
 
    (see gaudi/Gaudi#78)
    '''
    import re
    quoted_string = re.compile(r'^"(.*)"$', re.DOTALL)
    # FIXME: this is needed because we cannot use repr for strings
    #        (see gaudi/Gaudi#78)
    if not s:  # pass through empty strings
        return s
    m = quoted_string.match(s)
    if m:
        return m.group(1).replace('\\"', '"')
    return eval(s)
 
 

toOpt()

def Gaudi.Main.toOpt

(

value

)

Helper to convert values to old .opts format.

>>> print(toOpt('some "text"'))
"some \\"text\\""
>>> print(toOpt('first\\nsecond'))
"first
second"
>>> print(toOpt({'a': [1, 2, '3']}))
{"a": [1, 2, "3"]}

Definition at line 261 of file Main.py.

def toOpt(value):
    '''
    Helper to convert values to old .opts format.
 
    >>> print(toOpt('some "text"'))
    "some \\"text\\""
    >>> print(toOpt('first\\nsecond'))
    "first
    second"
    >>> print(toOpt({'a': [1, 2, '3']}))
    {"a": [1, 2, "3"]}
    '''
    if isinstance(value, six.string_types):
        return '"{0}"'.format(value.replace('"', '\\"'))
    elif isinstance(value, dict):
        return '{{{0}}}'.format(', '.join(
            '{0}: {1}'.format(toOpt(k), toOpt(v)) for k, v in value.items()))
    elif hasattr(value, '__iter__'):
        return '[{0}]'.format(', '.join(map(toOpt, value)))
    else:
        return repr(value)
 
 

Variable Documentation

log

Gaudi.Main.log = logging.getLogger(__name__)

Definition at line 20 of file Main.py.