lsst.sconsUtils.builders Namespace Reference

Classes
class	DoxygenBuilder
	A callable to be used as an SCons Action to run Doxygen. More...

Functions
def	SharedLibraryIncomplete (self, target, source, keywords)
def	Pybind11LoadableModule (self, target, source, keywords)
def	SourcesForSharedLibrary (self, files)
	Prepare the list of files to be passed to a SharedLibrary constructor. More...
def	filesToTag (root=None, fileRegex=None, ignoreDirs=None)
def	BuildETags (env, root=None, fileRegex=None, ignoreDirs=None)
	Build Emacs tags (see man etags for more information). More...
def	CleanTree (self, filePatterns, dirPatterns="", directory=".", verbose=False)
	Remove files matching the argument list starting at directory when scons is invoked with -c/–clean and no explicit targets are listed. More...
def	ProductDir (env, product)
def	Doxygen (self, config, kw)
	Generate a Doxygen config file and run Doxygen on it. More...
def	VersionModule (self, filename, versionString=None)

Function Documentation

BuildETags()

def lsst.sconsUtils.builders.BuildETags	(		env,
			root = None,
			fileRegex = None,
			ignoreDirs = None
	)

Build Emacs tags (see man etags for more information).

Files are chosen if they match fileRegex; toplevel directories in list ignoreDirs are ignored This routine won't do anything unless you specified a "TAGS" target

Definition at line 154 of file builders.py.

def BuildETags(env, root=None, fileRegex=None, ignoreDirs=None):
    toTag = filesToTag(root, fileRegex, ignoreDirs)
    if toTag:
        return env.Command("TAGS", toTag, "etags -o $TARGET $SOURCES")


# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

CleanTree()

def lsst.sconsUtils.builders.CleanTree	(		self,
			filePatterns,
			dirPatterns = "",
			directory = ".",
			verbose = False
	)

Remove files matching the argument list starting at directory when scons is invoked with -c/–clean and no explicit targets are listed.

E.g. CleanTree(r"*~ core")

dirPatterns allows the specification of directories to be removed If verbose is True, print each filename after deleting it

Definition at line 172 of file builders.py.

def CleanTree(self, filePatterns, dirPatterns="", directory=".", verbose=False):

    def genFindCommand(patterns, directory, verbose, filesOnly):
        # Generate find command to clean up (find-glob) patterns, either files
        # or directories.
        expr = ""
        for pattern in SCons.Script.Split(patterns):
            if expr != "":
                expr += " -o "
            # Quote unquoted * and [
            expr += "-name %s" % re.sub(r"(^|[^\\])([\[*])", r"\1\\\2", pattern)
            if filesOnly:
                expr += " -type f"
            else:
                expr += " -type d -prune"

        command = "find " + directory
        # Don't look into .svn or .git directories to save time.
        command += r" \( -name .svn -prune -o -name .git -prune -o -name \* \) "
        command += r" \( " + expr + r" \)"
        if filesOnly:
            command += r" -exec rm -f {} \;"
        else:
            command += r" -exec rm -rf {} \;"
        if verbose:
            command += " -print"
        return command

    action = genFindCommand(filePatterns, directory, verbose, filesOnly=True)

    # Clean up scons files --- users want to be able to say scons -c and get a
    # clean copy.
    # We can't delete .sconsign.dblite if we use "scons clean" instead of
    # "scons --clean", so the former is no longer supported.
    action += " ; rm -rf .sconf_temp .sconsign.dblite .sconsign.tmp config.log"

    if dirPatterns != "":
        action += " ; "
        action += genFindCommand(dirPatterns, directory, verbose, filesOnly=False)
    # Do we actually want to clean up?  We don't if the command is e.g.
    # "scons -c install"
    if "clean" in SCons.Script.COMMAND_LINE_TARGETS:
        state.log.fail("'scons clean' is no longer supported; please use 'scons --clean'.")
    elif not SCons.Script.COMMAND_LINE_TARGETS and self.GetOption("clean"):
        self.Execute(self.Action([action]))

# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=


# @brief Return a product's PRODUCT_DIR, or None
@memberOf(SConsEnvironment)

Doxygen()

def lsst.sconsUtils.builders.Doxygen	(		self,
			config,
			kw
	)

Generate a Doxygen config file and run Doxygen on it.

Rather than parse a complete Doxygen config file for SCons sources and targets, this Doxygen builder builds a Doxygen config file, adding INPUT, FILE_PATTERNS, RECUSRIVE, EXCLUDE, XX_OUTPUT and GENERATE_XX options (and possibly others) to an existing proto-config file. Generated settings will override those in the proto-config file.

Parameters

config	A Doxygen config file, usually with the extension .conf.in; a new file with the .in removed will be generated and passed to Doxygen. Settings in the original config file will be overridden by those generated by this method.
inputs	A sequence of folders or files to be passed as the INPUT setting for Doxygen. This list will be turned into absolute paths by SCons, so the "#folder" syntax will work. Otherwise, the list is passed in as-is, but the builder will also examine those directories to find which source files the Doxygen output actually depends on.
patterns	A sequence of glob patterns for the FILE_PATTERNS Doxygen setting. This will be passed directly to Doxygen, but it is also used to determine which source files should be considered dependencies.
recursive	Whether the inputs should be searched recursively (used for the Doxygen RECURSIVE setting).
outputs	A sequence of output formats which will also be used as output directories.
exclude	A sequence of folders or files (not globs) to be ignored by Doxygen (the Doxygen EXCLUDE setting). Hidden directories are automatically ignored.
includes	A sequence of Doxygen config files to include. These will automatically be separated into paths and files to fill in the @INCLUDE_PATH and @INCLUDE settings.
useTags	A sequence of Doxygen tag files to use. It will be assumed that the html directory for each tag file is in an "html" subdirectory in the same directory as the tag file.
makeTag	A string indicating the name of a tag file to be generated.
projectName	Sets the Doxygen PROJECT_NAME setting.
projectNumber	Sets the Doxygen PROJECT_NUMBER setting.
excludeSwig	If True (default), looks for SWIG .i files in the input directories and adds Python and C++ files generated by SWIG to the list of files to exclude. For this to work, the SWIG-generated filenames must be the default ones ("module.i" generates "module.py" and "moduleLib_wrap.cc").

Note

When building documentation from a clean source tree, generated source files (like headers generated with M4) will not be included among the dependencies, because they aren't present when we walk the input folders. The workaround is just to build the docs after building the source.

Definition at line 453 of file builders.py.

def Doxygen(self, config, **kw):
    inputs = [d for d in ["#doc", "#include", "#python", "#src"]
              if os.path.exists(SCons.Script.Entry(d).abspath)]
    defaults = {
        "inputs": inputs,
        "recursive": True,
        "patterns": ["*.h", "*.cc", "*.py", "*.dox"],
        "outputs": ["html", "xml"],
        "excludes": [],
        "includes": [],
        "useTags": [],
        "makeTag": None,
        "projectName": None,
        "projectNumber": None,
        "excludeSwig": True
    }
    for k in defaults:
        if kw.get(k) is None:
            kw[k] = defaults[k]
    builder = DoxygenBuilder(**kw)
    return builder(self, config)


@memberOf(SConsEnvironment)

filesToTag()

def lsst.sconsUtils.builders.filesToTag	(		root = None,
			fileRegex = None,
			ignoreDirs = None
	)

Definition at line 114 of file builders.py.

def filesToTag(root=None, fileRegex=None, ignoreDirs=None):
    if root is None:
        root = "."
    if fileRegex is None:
        fileRegex = r"^[a-zA-Z0-9_].*\.(cc|h(pp)?|py)$"
    if ignoreDirs is None:
        ignoreDirs = ["examples", "tests"]

    if "TAGS" not in SCons.Script.COMMAND_LINE_TARGETS:
        return []

    files = []
    for dirpath, dirnames, filenames in os.walk(root):
        if dirpath == ".":
            dirnames[:] = [d for d in dirnames if not re.search(r"^(%s)$" % "|".join(ignoreDirs), d)]

        dirnames[:] = [d for d in dirnames if not re.search(r"^(\.svn)$", d)]  # ignore .svn tree
        #
        # List of possible files to tag, but there's some cleanup required for machine-generated files
        #
        candidates = [f for f in filenames if re.search(fileRegex, f)]
        #
        # Remove files generated by swig
        #
        for swigFile in [f for f in filenames if f.endswith(".i")]:
            name = os.path.splitext(swigFile)[0]
            candidates = [f for f in candidates if not re.search(r"%s(_wrap\.cc?|\.py)$" % name, f)]

        files += [os.path.join(dirpath, f) for f in candidates]

    return files

ProductDir()

def lsst.sconsUtils.builders.ProductDir	(		env,
			product
	)

Definition at line 223 of file builders.py.

def ProductDir(env, product):
    from . import eupsForScons
    global _productDirs
    try:
        _productDirs
    except Exception:
        try:
            _productDirs = eupsForScons.productDir(eupsenv=eupsForScons.getEups())
        except TypeError:               # old version of eups (pre r18588)
            _productDirs = None
    if _productDirs:
        pdir = _productDirs.get(product)
    else:
        pdir = eupsForScons.productDir(product)
    if pdir == "none":
        pdir = None
    return pdir


# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Pybind11LoadableModule()

def lsst.sconsUtils.builders.Pybind11LoadableModule	(		self,
			target,
			source,
			keywords
	)

Definition at line 32 of file builders.py.

def Pybind11LoadableModule(self, target, source, **keywords):
    myenv = self.Clone()
    myenv.Append(CCFLAGS=["-fvisibility=hidden"])
    if myenv['PLATFORM'] == 'darwin':
        myenv.Append(LDMODULEFLAGS=["-undefined", "suppress",
                                    "-flat_namespace", "-headerpad_max_install_names"])
    return myenv.LoadableModule(target, source, **keywords)

# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

SharedLibraryIncomplete()

def lsst.sconsUtils.builders.SharedLibraryIncomplete	(		self,
			target,
			source,
			keywords
	)

Definition at line 22 of file builders.py.

def SharedLibraryIncomplete(self, target, source, **keywords):
    myenv = self.Clone()
    if myenv['PLATFORM'] == 'darwin':
        myenv['SHLINKFLAGS'] += ["-undefined", "suppress", "-flat_namespace", "-headerpad_max_install_names"]
    return myenv.SharedLibrary(target, source, **keywords)


#  @brief Like LoadableModule, but don't insist that all symbols are resolved, and set
#         some pybind11-specific flags.
@memberOf(SConsEnvironment)

SourcesForSharedLibrary()

def lsst.sconsUtils.builders.SourcesForSharedLibrary	(		self,
			files
	)

Prepare the list of files to be passed to a SharedLibrary constructor.

In particular, ensure that any files listed in env.NoOptFiles (set by the command line option noOptFile="file1 file2") are built without optimisation and files listed in env.optFiles are built with optimisation

The usage pattern in an SConscript file is: ccFiles = env.SourcesForSharedLibrary(Glob("../src/*/*.cc")) env.SharedLibrary('afw', ccFiles, LIBS=env.getLibs("self")))

This is automatically used by scripts.BasicSConscript.lib().

Definition at line 57 of file builders.py.

def SourcesForSharedLibrary(self, files):

    files = [SCons.Script.File(file) for file in files]

    if not (self.get("optFiles") or self.get("noOptFiles")):
        objs = [self.SharedObject(ccFile) for ccFile in sorted(state.env.Flatten(files), key=str)]
        return objs

    if self.get("optFiles"):
        optFiles = self["optFiles"].replace(".", r"\.")  # it'll be used in an RE
        optFiles = SCons.Script.Split(optFiles.replace(",", " "))
        optFilesRe = "/(%s)$" % "|".join(optFiles)
    else:
        optFilesRe = None

    if self.get("noOptFiles"):
        noOptFiles = self["noOptFiles"].replace(".", r"\.")  # it'll be used in an RE
        noOptFiles = SCons.Script.Split(noOptFiles.replace(",", " "))
        noOptFilesRe = "/(%s)$" % "|".join(noOptFiles)
    else:
        noOptFilesRe = None

    if self.get("opt"):
        opt = int(self["opt"])
    else:
        opt = 0

    if opt == 0:
        opt = 3

    CCFLAGS_OPT = re.sub(r"-O(\d|s)\s*", "-O%d " % opt, " ".join(self["CCFLAGS"]))
    CCFLAGS_NOOPT = re.sub(r"-O(\d|s)\s*", "-O0 ", " ".join(self["CCFLAGS"]))  # remove -O flags from CCFLAGS

    objs = []
    for ccFile in files:
        if optFilesRe and re.search(optFilesRe, ccFile.abspath):
            obj = self.SharedObject(ccFile, CCFLAGS=CCFLAGS_OPT)
        elif noOptFilesRe and re.search(noOptFilesRe, ccFile.abspath):
            obj = self.SharedObject(ccFile, CCFLAGS=CCFLAGS_NOOPT)
        else:
            obj = self.SharedObject(ccFile)
        objs.append(obj)

    objs = sorted(state.env.Flatten(objs), key=str)
    return objs


# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

#
#  @brief Return a list of files that need to be scanned for tags, starting at directory root
#
#  These tags are for advanced Emacs users, and should not be confused with SVN tags or Doxygen tags.
#
#  Files are chosen if they match fileRegex; toplevel directories in list ignoreDirs are ignored
#  This routine won't do anything unless you specified a "TAGS" target
#

VersionModule()

def lsst.sconsUtils.builders.VersionModule	(		self,
			filename,
			versionString = None
	)

Definition at line 477 of file builders.py.

def VersionModule(self, filename, versionString=None):
    if versionString is None:
        for n in ("git", "hg", "svn",):
            if os.path.isdir(".%s" % n):
                versionString = n

        if not versionString:
            versionString = "git"

    def calcMd5(filename):
        try:
            import hashlib
            md5 = hashlib.md5(open(filename, "rb").read()).hexdigest()
        except IOError:
            md5 = None

        return md5

    oldMd5 = calcMd5(filename)

    def makeVersionModule(target, source, env):
        try:
            version = determineVersion(state.env, versionString)
        except RuntimeError:
            version = "unknown"
        parts = version.split("+")

        names = []
        with open(target[0].abspath, "w") as outFile:
            outFile.write("# -------- This file is automatically generated by LSST's sconsUtils -------- #\n")

            what = "__version__"
            outFile.write("%s = '%s'\n" % (what, version))
            names.append(what)

            what = "__repo_version__"
            outFile.write("%s = '%s'\n" % (what, parts[0]))
            names.append(what)

            what = "__fingerprint__"
            outFile.write("%s = '%s'\n" % (what, getFingerprint(versionString)))
            names.append(what)

            try:
                info = tuple(int(v) for v in parts[0].split("."))
                what = "__version_info__"
                names.append(what)
                outFile.write("%s = %r\n" % (what, info))
            except ValueError:
                pass

            if len(parts) > 1:
                try:
                    what = "__rebuild_version__"
                    outFile.write("%s = %s\n" % (what, int(parts[1])))
                    names.append(what)
                except ValueError:
                    pass

            what = "__dependency_versions__"
            names.append(what)
            outFile.write("%s = {\n" % (what))
            for name, mod in env.dependencies.packages.items():
                if mod is None:
                    outFile.write("    '%s': None,\n" % name)
                elif hasattr(mod.config, "version"):
                    outFile.write("    '%s': '%s',\n" % (name, mod.config.version))
                else:
                    outFile.write("    '%s': 'unknown',\n" % name)
            outFile.write("}\n")

            # Write out an entry per line as there can be many names
            outFile.write("__all__ = (\n")
            for n in names:
                outFile.write("    {!r},\n".format(n))
            outFile.write(")\n")

        if calcMd5(target[0].abspath) != oldMd5:  # only print if something's changed
            state.log.info("makeVersionModule([\"%s\"], [])" % str(target[0]))

    result = self.Command(filename, [], self.Action(makeVersionModule, strfunction=lambda *args: None))

    self.AlwaysBuild(result)
    return result

---

Generated on Thu Feb 14 2019 08:52:08 for LSSTApplications by   1.8.13