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 178 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 = {}
 
    # Keep track of which algorithms we have already processed to avoid
    # computing them many times
    done_conf = set()
    # More algorithms may be generated when we call "getValuedProperties" so we
    # may need a few iterations before we get the full list
    # (see GaudiConfig.ControlFlow)
    while True:
        needed_conf = [n for n in getNeededConfigurables() if n not in done_conf]
        if not needed_conf:
            break
 
        for n in needed_conf:
            done_conf.add(n)
            c = Configurable.allConfigurables[n]
            items = getattr(c, "getValuedProperties", dict)().items()
            if explicit_defaults:
                items = chain(c.getDefaultProperties().items(), items)
            for p, v in items:
                # Note: AthenaCommon.Configurable does not have Configurable.PropertyReference
                if hasattr(Configurable, "PropertyReference") and isinstance(
                    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 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 new configuration system as a dictionary.

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

Definition at line 225 of file Main.py.

def getAllOpts(explicit_defaults=False):
    """
    Return all options from the old and new 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 287 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 263 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, str):
        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 18 of file Main.py.