lsst.pipe.base.argumentParser Namespace Reference

Classes
class	ArgumentParser
class	ConfigDatasetType
class	ConfigFileAction
class	ConfigValueAction
class	DataIdArgument
class	DataIdContainer
class	DatasetArgument
class	DynamicDatasetType
class	IdValueAction
class	InputOnlyArgumentParser
class	LogLevelAction
class	ReuseAction

Functions
def	getTaskDict (config, taskDict=None, baseName="")
def	obeyShowArgument (showOpts, config=None, exit=False)
def	showTaskHierarchy (config)
def	setDottedAttr (item, name, value)
def	getDottedAttr (item, name)

Variables
string	DEFAULT_INPUT_NAME = "PIPE_INPUT_ROOT"
string	DEFAULT_CALIB_NAME = "PIPE_CALIB_ROOT"
string	DEFAULT_OUTPUT_NAME = "PIPE_OUTPUT_ROOT"

Function Documentation

getDottedAttr()

def lsst.pipe.base.argumentParser.getDottedAttr	(		item,
			name
	)

Get an attribute (like `getattr` but accepts hierarchical names
such as ``foo.bar.baz``).

Parameters
----------
item : obj
    Object whose attribute is to be returned.
name : `str`
    Name of the attribute to get.

Returns
-------
itemAttr : obj
    If name is ``foo.bar.baz then the return value is
    ``item.foo.bar.baz``.

Definition at line 1329 of file argumentParser.py.

def getDottedAttr(item, name):
    """Get an attribute (like `getattr` but accepts hierarchical names
    such as ``foo.bar.baz``).
 
    Parameters
    ----------
    item : obj
        Object whose attribute is to be returned.
    name : `str`
        Name of the attribute to get.
 
    Returns
    -------
    itemAttr : obj
        If name is ``foo.bar.baz then the return value is
        ``item.foo.bar.baz``.
    """
    subitem = item
    for subname in name.split("."):
        subitem = getattr(subitem, subname)
    return subitem

getTaskDict()

def lsst.pipe.base.argumentParser.getTaskDict	(		config,
			taskDict = None,
			baseName = ""
	)

Get a dictionary of task info for all subtasks in a config

Parameters
----------
config : `lsst.pex.config.Config`
    Configuration to process.
taskDict : `dict`, optional
    Users should not specify this argument. Supports recursion.
    If provided, taskDict is updated in place, else a new `dict`
    is started.
baseName : `str`, optional
    Users should not specify this argument. It is only used for
    recursion: if a non-empty string then a period is appended
    and the result is used as a prefix for additional entries
    in taskDict; otherwise no prefix is used.

Returns
-------
taskDict : `dict`
    Keys are config field names, values are task names.

Notes
-----
This function is designed to be called recursively.
The user should call with only a config (leaving taskDict and baseName
at their default values).

Definition at line 924 of file argumentParser.py.

def getTaskDict(config, taskDict=None, baseName=""):
    """Get a dictionary of task info for all subtasks in a config
 
    Parameters
    ----------
    config : `lsst.pex.config.Config`
        Configuration to process.
    taskDict : `dict`, optional
        Users should not specify this argument. Supports recursion.
        If provided, taskDict is updated in place, else a new `dict`
        is started.
    baseName : `str`, optional
        Users should not specify this argument. It is only used for
        recursion: if a non-empty string then a period is appended
        and the result is used as a prefix for additional entries
        in taskDict; otherwise no prefix is used.
 
    Returns
    -------
    taskDict : `dict`
        Keys are config field names, values are task names.
 
    Notes
    -----
    This function is designed to be called recursively.
    The user should call with only a config (leaving taskDict and baseName
    at their default values).
    """
    if taskDict is None:
        taskDict = dict()
    for fieldName, field in config.items():
        if hasattr(field, "value") and hasattr(field, "target"):
            subConfig = field.value
            if isinstance(subConfig, pexConfig.Config):
                subBaseName = f"{baseName}.{fieldName}" if baseName else fieldName
                try:
                    taskName = f"{field.target.__module__}.{field.target.__name__}"
                except Exception:
                    taskName = repr(field.target)
                taskDict[subBaseName] = taskName
                getTaskDict(config=subConfig, taskDict=taskDict, baseName=subBaseName)
    return taskDict
 
 

obeyShowArgument()

def lsst.pipe.base.argumentParser.obeyShowArgument	(		showOpts,
			config = None,
			exit = False
	)

Process arguments specified with ``--show`` (but ignores
``"data"``).

Parameters
----------
showOpts : `list` of `str`
    List of options passed to ``--show``.
config : optional
    The provided config.
exit : bool, optional
    Exit if ``"run"`` isn't included in ``showOpts``.

Parameters
----------
Supports the following options in showOpts:

- ``config[=PAT]``. Dump all the config entries, or just the ones that
    match the glob pattern.
- ``history=PAT``. Show where the config entries that match the glob
    pattern were set.
- ``tasks``. Show task hierarchy.
- ``data``. Ignored; to be processed by caller.
- ``run``. Keep going (the default behaviour is to exit if
    ``--show`` is specified).

Calls ``sys.exit(1)`` if any other option found.

Definition at line 968 of file argumentParser.py.

def obeyShowArgument(showOpts, config=None, exit=False):
    """Process arguments specified with ``--show`` (but ignores
    ``"data"``).
 
    Parameters
    ----------
    showOpts : `list` of `str`
        List of options passed to ``--show``.
    config : optional
        The provided config.
    exit : bool, optional
        Exit if ``"run"`` isn't included in ``showOpts``.
 
    Parameters
    ----------
    Supports the following options in showOpts:
 
    - ``config[=PAT]``. Dump all the config entries, or just the ones that
        match the glob pattern.
    - ``history=PAT``. Show where the config entries that match the glob
        pattern were set.
    - ``tasks``. Show task hierarchy.
    - ``data``. Ignored; to be processed by caller.
    - ``run``. Keep going (the default behaviour is to exit if
        ``--show`` is specified).
 
    Calls ``sys.exit(1)`` if any other option found.
    """
    if not showOpts:
        return
 
    for what in showOpts:
        showCommand, showArgs = what.split("=", 1) if "=" in what else (what, "")
 
        if showCommand == "config":
            matConfig = re.search(r"^(?:config.)?(.+)?", showArgs)
            pattern = matConfig.group(1)
            if pattern:
                class FilteredStream:
                    """A file object that only prints lines
                    that match the glob "pattern".
 
                    N.b. Newlines are silently discarded and reinserted;
                    crude but effective.
                    """
 
                    def __init__(self, pattern):
                        # obey case if pattern isn't lowecase or requests
                        # NOIGNORECASE
                        mat = re.search(r"(.*):NOIGNORECASE$", pattern)
 
                        if mat:
                            pattern = mat.group(1)
                            self._pattern = re.compile(fnmatch.translate(pattern))
                        else:
                            if pattern != pattern.lower():
                                print(f"Matching {pattern!r} without regard to case "
                                      "(append :NOIGNORECASE to prevent this)", file=sys.stdout)
                            self._pattern = re.compile(fnmatch.translate(pattern), re.IGNORECASE)
 
                    def write(self, showStr):
                        showStr = showStr.rstrip()
                        # Strip off doc string line(s) and cut off
                        # at "=" for string matching
                        matchStr = showStr.split("\n")[-1].split("=")[0]
                        if self._pattern.search(matchStr):
                            print("\n" + showStr)
 
                fd = FilteredStream(pattern)
            else:
                fd = sys.stdout
 
            config.saveToStream(fd, "config")
        elif showCommand == "history":
            matHistory = re.search(r"^(?:config.)?(.+)?", showArgs)
            globPattern = matHistory.group(1)
            if not globPattern:
                print("Please provide a value with --show history (e.g. history=*.doXXX)", file=sys.stderr)
                sys.exit(1)
 
            error = False
            for i, pattern in enumerate(fnmatch.filter(config.names(), globPattern)):
                if i > 0:
                    print("")
 
                pattern = pattern.split(".")
                cpath, cname = pattern[:-1], pattern[-1]
                hconfig = config            # the config that we're interested in
                for i, cpt in enumerate(cpath):
                    try:
                        hconfig = getattr(hconfig, cpt)
                    except AttributeError:
                        config_path = ".".join(["config"] + cpath[:i])
                        print(f"Error: configuration {config_path} has no subconfig {cpt}", file=sys.stderr)
                        error = True
 
                try:
                    print(pexConfig.history.format(hconfig, cname))
                except KeyError:
                    config_path = ".".join(["config"] + cpath)
                    print(f"Error: {config_path} has no field {cname}", file=sys.stderr)
                    error = True
 
            if error:
                sys.exit(1)
 
        elif showCommand == "data":
            pass
        elif showCommand == "run":
            pass
        elif showCommand == "tasks":
            showTaskHierarchy(config)
        else:
            choices = "', '".join("config[=XXX] data history=XXX tasks run".split())
            print(f"Unknown value for show: {what} (choose from {choices!r})", file=sys.stderr)
            sys.exit(1)
 
    if exit and "run" not in showOpts:
        sys.exit(0)
 
 

setDottedAttr()

def lsst.pipe.base.argumentParser.setDottedAttr	(		item,
			name,
			value
	)

Set an instance attribute (like `setattr` but accepting
hierarchical names such as ``foo.bar.baz``).

Parameters
----------
item : obj
    Object whose attribute is to be set.
name : `str`
    Name of attribute to set.
value : obj
    New value for the attribute.

Notes
-----
For example if name is ``foo.bar.baz`` then ``item.foo.bar.baz``
is set to the specified value.

Definition at line 1304 of file argumentParser.py.

def setDottedAttr(item, name, value):
    """Set an instance attribute (like `setattr` but accepting
    hierarchical names such as ``foo.bar.baz``).
 
    Parameters
    ----------
    item : obj
        Object whose attribute is to be set.
    name : `str`
        Name of attribute to set.
    value : obj
        New value for the attribute.
 
    Notes
    -----
    For example if name is ``foo.bar.baz`` then ``item.foo.bar.baz``
    is set to the specified value.
    """
    subitem = item
    subnameList = name.split(".")
    for subname in subnameList[:-1]:
        subitem = getattr(subitem, subname)
    setattr(subitem, subnameList[-1], value)
 
 

showTaskHierarchy()

def lsst.pipe.base.argumentParser.showTaskHierarchy

(

config

)

Print task hierarchy to stdout.

Parameters
----------
config : `lsst.pex.config.Config`
    Configuration to process.

Definition at line 1089 of file argumentParser.py.

def showTaskHierarchy(config):
    """Print task hierarchy to stdout.
 
    Parameters
    ----------
    config : `lsst.pex.config.Config`
        Configuration to process.
    """
    print("Subtasks:")
    taskDict = getTaskDict(config=config)
 
    fieldNameList = sorted(taskDict.keys())
    for fieldName in fieldNameList:
        taskName = taskDict[fieldName]
        print(f"{fieldName}: {taskName}")
 
 

Variable Documentation

DEFAULT_CALIB_NAME

string lsst.pipe.base.argumentParser.DEFAULT_CALIB_NAME = "PIPE_CALIB_ROOT"

Definition at line 45 of file argumentParser.py.

DEFAULT_INPUT_NAME

string lsst.pipe.base.argumentParser.DEFAULT_INPUT_NAME = "PIPE_INPUT_ROOT"

Definition at line 44 of file argumentParser.py.

DEFAULT_OUTPUT_NAME

string lsst.pipe.base.argumentParser.DEFAULT_OUTPUT_NAME = "PIPE_OUTPUT_ROOT"

Definition at line 46 of file argumentParser.py.