fabricate Namespace Reference

Classes
class	_after
class	_Groups
class	_running
class	_todo
class	AlwaysRunner
class	AtimesRunner
class	Builder
class	ExecutionError
class	MultiprocessingModule
class	PathError
class	PickleJson
class	Runner
class	RunnerUnsupportedException
class	SmartRunner
class	StraceProcess
class	StraceRunner

Functions
def	printerr (message)
def	args_to_list (args)
def	shell (args, kwargs)
def	_shell (args, input=None, silent=True, shell=False, ignore_status=False, kwargs)
def	md5_hasher (filename)
def	mtime_hasher (filename)
def	_call_strace (self, args, kwargs)
def	_results_handler (builder, delay=0.01)
def	setup (builder=None, default=None, kwargs)
def	_set_default_builder ()
def	run (args, kwargs)
def	after (args)
def	autoclean ()
def	memoize (command, kwargs)
def	outofdate (command)
def	parse_options (usage=_usage, extra_options=None, command_line=None)
def	fabricate_version (min=None, max=None)
def	main (globals_dict=None, build_dir=None, extra_options=None, builder=None, default=None, jobs=1, command_line=None, kwargs)

Variables
string	__version__ = '1.29.3'
int	deps_version = 2
	multiprocessing
int	PY3 = 3
	string_types = str
	threading_condition = threading.Condition
list	__all__
int	FAT_atime_resolution = 24
int	FAT_mtime_resolution = 2
float	NTFS_atime_resolution = 0.0002048
float	NTFS_mtime_resolution = 0.0002048
	md5func = hashlib.md5
	json
	_pool = None
	_groups = _Groups()
	_results = None
	_stop_results = threading.Event()
	default_builder = None
string	default_command = 'build'
	_setup_builder = None
	_setup_default = None
dictionary	_setup_kwargs = {}
	_parsed_options = None
string	_usage = '[options] build script functions to run'
	parser
	options
	args
int	status = 0

Detailed Description

Build tool that finds dependencies automatically for any language.

fabricate is a build tool that finds dependencies automatically for any
language. It's small and just works. No hidden stuff behind your back. It was
inspired by Bill McCloskey's make replacement, memoize, but fabricate works on
Windows as well as Linux.

Read more about how to use it and how it works on the project page:
https://github.com/SimonAlfie/fabricate/

Like memoize, fabricate is released under a "New BSD license". fabricate is
copyright (c) 2009 Brush Technology. Full text of the license is here:
https://github.com/SimonAlfie/fabricate/wiki/License

To get help on fabricate functions:
from fabricate import *
help(function)

Function Documentation

def fabricate._call_strace (   self,   args,   kwargs  )

private

Top level function call for Strace that can be run in parallel 

Definition at line 499 of file fabricate.py.

def _call_strace(self, *args, **kwargs):
    """ Top level function call for Strace that can be run in parallel """
    return self(*args, **kwargs)

def fabricate._results_handler (   builder,   delay = 0.01  )

private

Body of thread that stores results in .deps and handles 'after'
    conditions
   "builder" the builder used 

Definition at line 917 of file fabricate.py.

References printerr(), submit_syst.str, and sum.

def _results_handler( builder, delay=0.01):
    """ Body of thread that stores results in .deps and handles 'after'
        conditions
       "builder" the builder used """
    try:
        while not _stop_results.isSet():
            # go through the lists and check any results available
            for id in _groups.ids():
                if id is False: continue # key of False is _afters not _runnings
                for r in _groups.item_list(id):
                    if r.results is None and r.async.ready():
                        try:
                            d, o = r.async.get()
                        except ExecutionError as e:
                            r.results = e
                            _groups.set_ok(id, False)
                            message, data, status = e
                            printerr("fabricate: " + message)
                        else:
                            builder.done(r.command, d, o) # save deps
                            r.results = (r.command, d, o)
                        _groups.dec_count(id)
            # check if can now schedule things waiting on the after queue
            for a in _groups.item_list(False):
                still_to_do = sum(_groups.get_count(g) for g in a.afters)
                no_error = all(_groups.get_ok(g) for g in a.afters)
                if False in a.afters:
                    still_to_do -= 1 # don't count yourself of course
                if still_to_do == 0:
                    if isinstance(a.do, _todo):
                        if no_error:
                            async = _pool.apply_async(_call_strace, a.do.arglist,
                                        a.do.kwargs)
                            _groups.add_for_blocked(a.do.group, _running(async, a.do.command))
                        else:
                            # Mark the command as not done due to errors
                            r = _running(None, a.do.command)
                            _groups.add_for_blocked(a.do.group, r)
                            r.results = False
                            _groups.set_ok(a.do.group, False)
                            _groups.dec_count(a.do.group)
                    elif isinstance(a.do, threading_condition):
                        # is this only for threading_condition in after()?
                        a.do.acquire()
                        # only mark as done if there is no error
                        a.done = no_error
                        a.do.notify()
                        a.do.release()
                    # else: #are there other cases?
                    _groups.remove_item(False, a)
                    _groups.dec_count(False)

            _stop_results.wait(delay)
    except Exception:
        etype, eval, etb = sys.exc_info()
        printerr("Error: exception " + repr(etype) + " at line " + str(etb.tb_lineno))
        traceback.print_tb(etb)
    finally:
        if not _stop_results.isSet():
            # oh dear, I am about to die for unexplained reasons, stop the whole
            # app otherwise the main thread hangs waiting on non-existant me,
            # Note: sys.exit() only kills me
            printerr("Error: unexpected results handler exit")
            os._exit(1)

def fabricate._set_default_builder ( )

private

Set default builder to Builder() instance if it's not yet set. 

Definition at line 1399 of file fabricate.py.

Referenced by after(), autoclean(), memoize(), outofdate(), and run().

def _set_default_builder():
    """ Set default builder to Builder() instance if it's not yet set. """
    global default_builder
    if default_builder is None:
        default_builder = Builder()

def fabricate._shell (   args,   input = None,   silent = True,   shell = False,   ignore_status = False,   kwargs  )

private

Definition at line 176 of file fabricate.py.

References args_to_list().

Referenced by shell().

def _shell(args, input=None, silent=True, shell=False, ignore_status=False, **kwargs):
    if input:
        stdin = subprocess.PIPE
    else:
        stdin = None
    if silent:
        stdout = subprocess.PIPE
    else:
        stdout = None
    arglist = args_to_list(args)
    if not arglist:
        raise TypeError('shell() takes at least 1 argument (0 given)')
    if shell:
        # handle subprocess.Popen quirk where subsequent args are passed
        # to bash instead of to our command
        command = subprocess.list2cmdline(arglist)
    else:
        command = arglist
    try:
        proc = subprocess.Popen(command, stdin=stdin, stdout=stdout,
                                stderr=subprocess.STDOUT, shell=shell, **kwargs)
    except OSError as e:
        # Work around the problem that Windows Popen doesn't say what file it couldn't find
        if platform.system() == 'Windows' and e.errno == 2 and e.filename is None:
            e.filename = arglist[0]
        raise e
    output, stderr = proc.communicate(input)
    status = proc.wait()
    if status and not ignore_status:
        raise ExecutionError('%r exited with status %d'
                             % (os.path.basename(arglist[0]), status),
                             output, status)
    if silent:
        return output

def fabricate.after

(

args

)

wait until after the specified command groups complete and return
    results, or None if not parallel 

Definition at line 1416 of file fabricate.py.

References _set_default_builder().

Referenced by CopyPred(), DecorrelateFD(), and main().

def after(*args):
    """ wait until after the specified command groups complete and return
        results, or None if not parallel """
    _set_default_builder()
    if getattr(default_builder, 'parallel_ok', False):
        if len(args) == 0:
            args = _groups.ids()  # wait on all
        cond = threading.Condition()
        cond.acquire()
        a = _after(args, cond)
        _groups.add(False, a)
        cond.wait()
        if not a.done:
            sys.exit(1)
        results = []
        ids = _groups.ids()
        for a in args:
            if a in ids and a is not False:
                r = []
                for i in _groups.item_list(a):
                    r.append(i.results)
                results.append((a,r))
        return results
    else:
        return None

def fabricate.args_to_list

(

args

)

Return a flat list of the given arguments for shell(). 

Definition at line 129 of file fabricate.py.

Referenced by fabricate.Builder._run(), _shell(), and fabricate.Builder.memoize().

def args_to_list(args):
    """ Return a flat list of the given arguments for shell(). """
    arglist = []
    for arg in args:
        if arg is None:
            continue
        if isinstance(arg, (list, tuple)):
            arglist.extend(args_to_list(arg))
        else:
            if not isinstance(arg, string_types):
                arg = str(arg)
            arglist.append(arg)
    return arglist

def fabricate.autoclean

(

)

Automatically delete all outputs of the default build. 

Definition at line 1442 of file fabricate.py.

References _set_default_builder().

Referenced by build_template.clean(), and build_test.clean().

def autoclean():
    """ Automatically delete all outputs of the default build. """
    _set_default_builder()
    default_builder.autoclean()

def fabricate.fabricate_version	(		min = None,
			max = None
	)

If min is given, assert that the running fabricate is at least that
    version or exit with an error message. If max is given, assert that
    the running fabricate is at most that version. Return the current
    fabricate version string. This function was introduced in v1.14;
    for prior versions, the version string is available only as module
    local string fabricate.__version__ 

Definition at line 1495 of file fabricate.py.

References check_time_usage.float, and main().

def fabricate_version(min=None, max=None):
    """ If min is given, assert that the running fabricate is at least that
        version or exit with an error message. If max is given, assert that
        the running fabricate is at most that version. Return the current
        fabricate version string. This function was introduced in v1.14;
        for prior versions, the version string is available only as module
        local string fabricate.__version__ """

    if min is not None and float(__version__) < min:
        sys.stderr.write(("fabricate is version %s.  This build script "
            "requires at least version %.2f") % (__version__, min))
        sys.exit()
    if max is not None and float(__version__) > max:
        sys.stderr.write(("fabricate is version %s.  This build script "
            "requires at most version %.2f") % (__version__, max))
        sys.exit()
    return __version__

def fabricate.main	(		globals_dict = None,
			build_dir = None,
			extra_options = None,
			builder = None,
			default = None,
			jobs = 1,
			command_line = None,
			kwargs
	)

Run the default function or the function(s) named in the command line
    arguments. Call this at the end of your build script. If one of the
    functions returns nonzero, main will exit with the last nonzero return
    value as its status code.

    "builder" is the class of builder to create, default (None) is the
    normal builder
    "command_line" is an optional list of command line arguments that can
    be used to prevent the default parsing of sys.argv. Used to intercept
    and modify the command line passed to the build script.
    "default" is the default user script function to call, None = 'build'
    "extra_options" is an optional list of options created with
    optparse.make_option(). The pseudo-global variable main.options
    is set to the parsed options list.
    "kwargs" is any other keyword arguments to pass to the builder 

Definition at line 1514 of file fabricate.py.

References after(), makeTrainCVSamples.int, parse_options(), print, printerr(), and split().

Referenced by fabricate_version(), build_template.rebuild(), and build_test.rebuild().

         default=None, jobs=1, command_line=None, **kwargs):
    """ Run the default function or the function(s) named in the command line
        arguments. Call this at the end of your build script. If one of the
        functions returns nonzero, main will exit with the last nonzero return
        value as its status code.

        "builder" is the class of builder to create, default (None) is the
        normal builder
        "command_line" is an optional list of command line arguments that can
        be used to prevent the default parsing of sys.argv. Used to intercept
        and modify the command line passed to the build script.
        "default" is the default user script function to call, None = 'build'
        "extra_options" is an optional list of options created with
        optparse.make_option(). The pseudo-global variable main.options
        is set to the parsed options list.
        "kwargs" is any other keyword arguments to pass to the builder """
    global default_builder, default_command, _pool

    kwargs.update(_setup_kwargs)
    if _parsed_options is not None and command_line is None:
        parser, options, actions = _parsed_options
    else:
        parser, options, actions = parse_options(extra_options=extra_options, command_line=command_line)
    kwargs['quiet'] = options.quiet
    kwargs['debug'] = options.debug
    if options.time:
        kwargs['hasher'] = mtime_hasher
    if options.dir:
        kwargs['dirs'] = options.dir
    if options.keep:
        StraceRunner.keep_temps = options.keep
    main.options = options
    if options.jobs is not None:
        jobs = options.jobs
    if default is not None:
        default_command = default
    if default_command is None:
        default_command = _setup_default
    if not actions:
        actions = [default_command]

    original_path = os.getcwd()
    if None in [globals_dict, build_dir]:
        try:
            frame = sys._getframe(1)
        except:
            printerr("Your Python version doesn't support sys._getframe(1),")
            printerr("call main(globals(), build_dir) explicitly")
            sys.exit(1)
        if globals_dict is None:
            globals_dict = frame.f_globals
        if build_dir is None:
            build_file = frame.f_globals.get('__file__', None)
            if build_file:
                build_dir = os.path.dirname(build_file)
    if build_dir:
        if not options.quiet and os.path.abspath(build_dir) != original_path:
            print("Entering directory '%s'" % build_dir)
        os.chdir(build_dir)
    if _pool is None and jobs > 1:
        _pool = multiprocessing.Pool(jobs)

    use_builder = Builder
    if _setup_builder is not None:
        use_builder = _setup_builder
    if builder is not None:
        use_builder = builder
    default_builder = use_builder(**kwargs)

    if options.clean:
        default_builder.autoclean()

    status = 0
    try:
        for action in actions:
            if '(' not in action:
                action = action.strip() + '()'
            name = action.split('(')[0].split('.')[0]
            if name in globals_dict:
                this_status = eval(action, globals_dict)
                if this_status:
                    status = int(this_status)
            else:
                printerr('%r command not defined!' % action)
                sys.exit(1)
        after() # wait till the build commands are finished
    except ExecutionError as exc:
        message, data, status = exc.args
        printerr('fabricate: ' + message)
    finally:
        _stop_results.set() # stop the results gatherer so I don't hang
        if not options.quiet and os.path.abspath(build_dir) != original_path:
            print("Leaving directory '%s' back to '%s'" % (build_dir, original_path))
        os.chdir(original_path)
    sys.exit(status)

def fabricate.md5_hasher

(

filename

)

Return MD5 hash of given filename if it is a regular file or
    a symlink with a hashable target, or the MD5 hash of the
    target_filename if it is a symlink without a hashable target,
    or the MD5 hash of the filename if it is a directory, or None
    if file doesn't exist.

    Note: Pyhton versions before 3.2 do not support os.readlink on
    Windows so symlinks without a hashable target fall back to
    a hash of the filename if the symlink target is a directory,
    or None if the symlink is broken

Definition at line 211 of file fabricate.py.

References md5func, and open().

def md5_hasher(filename):
    """ Return MD5 hash of given filename if it is a regular file or
        a symlink with a hashable target, or the MD5 hash of the
        target_filename if it is a symlink without a hashable target,
        or the MD5 hash of the filename if it is a directory, or None
        if file doesn't exist.

        Note: Pyhton versions before 3.2 do not support os.readlink on
        Windows so symlinks without a hashable target fall back to
        a hash of the filename if the symlink target is a directory,
        or None if the symlink is broken"""
    if not isinstance(filename, bytes):
        filename = filename.encode('utf-8')
    try:
        f = open(filename, 'rb')
        try:
            return md5func(f.read()).hexdigest()
        finally:
            f.close()
    except IOError:
        if hasattr(os, 'readlink') and os.path.islink(filename):
            return md5func(os.readlink(filename)).hexdigest()
        elif os.path.isdir(filename):
            return md5func(filename).hexdigest()
        return None

def fabricate.memoize	(		command,
			kwargs
	)

Definition at line 1447 of file fabricate.py.

References _set_default_builder().

def memoize(command, **kwargs):
    _set_default_builder()
    return default_builder.memoize(command, **kwargs)

memoize.__doc__ = Builder.memoize.__doc__

def fabricate.mtime_hasher

(

filename

)

Return modification time of file, or None if file doesn't exist. 

Definition at line 237 of file fabricate.py.

def mtime_hasher(filename):
    """ Return modification time of file, or None if file doesn't exist. """
    try:
        st = os.stat(filename)
        return repr(st.st_mtime)
    except (IOError, OSError):
        return None

def fabricate.outofdate

(

command

)

Return True if given command is out of date and needs to be run. 

Definition at line 1453 of file fabricate.py.

References _set_default_builder().

def outofdate(command):
    """ Return True if given command is out of date and needs to be run. """
    _set_default_builder()
    return default_builder.outofdate(command)

# save options for use by main() if parse_options called earlier by user script

def fabricate.parse_options	(		usage = _usage,
			extra_options = None,
			command_line = None
	)

Parse command line options and return (parser, options, args). 

Definition at line 1464 of file fabricate.py.

Referenced by main().

def parse_options(usage=_usage, extra_options=None, command_line=None):
    """ Parse command line options and return (parser, options, args). """
    parser = optparse.OptionParser(usage='Usage: %prog '+usage,
                                   version='%prog '+__version__)
    parser.disable_interspersed_args()
    parser.add_option('-t', '--time', action='store_true',
                      help='use file modification times instead of MD5 sums')
    parser.add_option('-d', '--dir', action='append',
                      help='add DIR to list of relevant directories')
    parser.add_option('-c', '--clean', action='store_true',
                      help='autoclean build outputs before running')
    parser.add_option('-q', '--quiet', action='store_true',
                      help="don't echo commands, only print errors")
    parser.add_option('-D', '--debug', action='store_true',
                      help="show debug info (why commands are rebuilt)")
    parser.add_option('-k', '--keep', action='store_true',
                      help='keep temporary strace output files')
    parser.add_option('-j', '--jobs', type='int',
                      help='maximum number of parallel jobs')
    if extra_options:
        # add any user-specified options passed in via main()
        for option in extra_options:
            parser.add_option(option)
    if command_line is not None:
        options, args = parser.parse_args(command_line)
    else:
        options, args = parser.parse_args()
    global _parsed_options
    _parsed_options = (parser, options, args)
    return _parsed_options

def fabricate.printerr

(

message

)

Print given message to stderr with a line feed. 

Definition at line 118 of file fabricate.py.

References print.

Referenced by fabricate.StraceRunner._match_line(), _results_handler(), main(), and fabricate.Builder.read_deps().

def printerr(message):
    """ Print given message to stderr with a line feed. """
    print(message, file=sys.stderr)

def fabricate.run	(		args,
			kwargs
	)

Run the given command, but only if its dependencies have changed. Uses
    the default Builder. Return value as per Builder.run(). If there is
    only one positional argument which is an iterable treat each element
    as a command, returns a list of returns from Builder.run().

Definition at line 1405 of file fabricate.py.

References _set_default_builder().

def run(*args, **kwargs):
    """ Run the given command, but only if its dependencies have changed. Uses
        the default Builder. Return value as per Builder.run(). If there is
        only one positional argument which is an iterable treat each element
        as a command, returns a list of returns from Builder.run().
    """
    _set_default_builder()
    if len(args) == 1 and isinstance(args[0], (list, tuple)):
        return [default_builder.run(*a, **kwargs) for a in args[0]]
    return default_builder.run(*args, **kwargs)

def fabricate.setup	(		builder = None,
			default = None,
			kwargs
	)

NOTE: setup functionality is now in main(), setup() is kept for
    backward compatibility and should not be used in new scripts.

    Setup the default Builder (or an instance of given builder if "builder"
    is not None) with the same keyword arguments as for Builder().
    "default" is the name of the default function to run when the build
    script is run with no command line arguments. 

Definition at line 1385 of file fabricate.py.

def setup(builder=None, default=None, **kwargs):
    """ NOTE: setup functionality is now in main(), setup() is kept for
        backward compatibility and should not be used in new scripts.

        Setup the default Builder (or an instance of given builder if "builder"
        is not None) with the same keyword arguments as for Builder().
        "default" is the name of the default function to run when the build
        script is run with no command line arguments. """
    global _setup_builder, _setup_default, _setup_kwargs
    _setup_builder = builder
    _setup_default = default
    _setup_kwargs = kwargs
setup.__doc__ += '\n\n' + Builder.__init__.__doc__

def fabricate.shell	(		args,
			kwargs
	)

Definition at line 143 of file fabricate.py.

References _shell().

Referenced by fabricate.AtimesRunner.__call__(), and fabricate.StraceRunner._do_strace().

def shell(*args, **kwargs):
    r""" Run a command: program name is given in first arg and command line
        arguments in the rest of the args. Iterables (lists and tuples) in args
        are recursively converted to separate arguments, non-string types are
        converted with str(arg), and None is ignored. For example:

        >>> def tail(input, n=3, flags=None):
        >>>     args = ['-n', n]
        >>>     return shell('tail', args, flags, input=input)
        >>> tail('a\nb\nc\nd\ne\n')
        'c\nd\ne\n'
        >>> tail('a\nb\nc\nd\ne\n', 2, ['-v'])
        '==> standard input <==\nd\ne\n'

        Keyword arguments kwargs are interpreted as follows:

        "input" is a string to pass standard input into the process (or the
            default of None to use parent's stdin, eg: the keyboard)
        "silent" is True (default) to return process's standard output as a
            string, or False to print it as it comes out
        "shell" set to True will run the command via the shell (/bin/sh or
            COMSPEC) instead of running the command directly (the default)
        "ignore_status" set to True means ignore command status code -- i.e.,
            don't raise an ExecutionError on nonzero status code
        Any other kwargs are passed directly to subprocess.Popen
        Raises ExecutionError(message, output, status) if the command returns
        a non-zero status code. """
    try:
        return _shell(args, **kwargs)
    finally:
        sys.stderr.flush()
        sys.stdout.flush()

Variable Documentation

list fabricate.__all__

private

Initial value:

= ['setup', 'run', 'autoclean', 'main', 'shell', 'fabricate_version',
           'memoize', 'outofdate', 'parse_options', 'after',
           'ExecutionError', 'md5_hasher', 'mtime_hasher',
           'Runner', 'AtimesRunner', 'StraceRunner', 'AlwaysRunner',
           'SmartRunner', 'Builder']

Definition at line 67 of file fabricate.py.

string fabricate.__version__ = '1.29.3'

private

Definition at line 26 of file fabricate.py.

fabricate._groups = _Groups()

private

Definition at line 904 of file fabricate.py.

fabricate._parsed_options = None

private

Definition at line 1459 of file fabricate.py.

fabricate._pool = None

private

Definition at line 902 of file fabricate.py.

fabricate._results = None

private

Definition at line 906 of file fabricate.py.

fabricate._setup_builder = None

private

Definition at line 1381 of file fabricate.py.

fabricate._setup_default = None

private

Definition at line 1382 of file fabricate.py.

dictionary fabricate._setup_kwargs = {}

private

Definition at line 1383 of file fabricate.py.

fabricate._stop_results = threading.Event()

private

Definition at line 907 of file fabricate.py.

string fabricate._usage = '[options] build script functions to run'

private

Definition at line 1462 of file fabricate.py.

fabricate.args

Definition at line 1612 of file fabricate.py.

fabricate.default_builder = None

Definition at line 1377 of file fabricate.py.

string fabricate.default_command = 'build'

Definition at line 1378 of file fabricate.py.

int fabricate.deps_version = 2

Definition at line 29 of file fabricate.py.

int fabricate.FAT_atime_resolution = 24

Definition at line 79 of file fabricate.py.

int fabricate.FAT_mtime_resolution = 2

Definition at line 80 of file fabricate.py.

fabricate.json

Definition at line 116 of file fabricate.py.

Referenced by samweb_client.admin.getAvailableValues(), samweb_client.admin.listDataDisks(), samweb_client.admin.listParameters(), samweb_client.admin.listValues(), and samweb_client.projects.projectSummary().

fabricate.md5func = hashlib.md5

Definition at line 97 of file fabricate.py.

Referenced by md5_hasher().

fabricate.multiprocessing

Definition at line 51 of file fabricate.py.

float fabricate.NTFS_atime_resolution = 0.0002048

Definition at line 85 of file fabricate.py.

float fabricate.NTFS_mtime_resolution = 0.0002048

Definition at line 86 of file fabricate.py.

fabricate.options

Definition at line 1612 of file fabricate.py.

Referenced by demo_nueNumuSysts(), demo_numuOnly(), demoFitContours(), demoFitSlices(), evd::PlotView.Draw(), fake_future_data(), futureSig_getNueNumuSyst(), goodness_of_fit(), tensorflow::TFHandler.Initialize(), joint_fit_2017_contours(), joint_fit_2017_slices(), joint_fit_2018_contours(), joint_fit_2018_slices(), joint_fit_2019_bestfit(), joint_fit_2019_contours(), joint_fit_2019_slices(), joint_fit_future_bestfit_univ(), joint_fit_future_contour_univ(), make_fc_surfaces_2020(), make_fc_surfaces_2020_validation(), median_contours(), nuebar_signif(), plot_joint_fit_2020_contours(), plot_joint_fit_2020_slices(), reach_2018_dCPfractions(), run_joint_fit_2020_bestfit(), run_joint_fit_2020_contours(), run_joint_fit_2020_slices(), Tutorial2019Fit(), Tutorial2019FitContours(), and Tutorial2019FitSlices().

fabricate.parser

Definition at line 1612 of file fabricate.py.

int fabricate.PY3 = 3

Definition at line 54 of file fabricate.py.

int fabricate.status = 0

Definition at line 1613 of file fabricate.py.

Referenced by dbutils::daqconfig::BNEVBRunConfig._fetchAllData(), dbutils::daqconfig::DCMConnectConfig._fetchAllData(), dbutils::daqconfig::DCMRunConfig._fetchAllData(), dbutils::daqconfig::DLRunConfig._fetchAllData(), dbutils::daqconfig::DCMHardwareConfig._fetchAllData(), dbutils::daqconfig::DCMHardwareConfig._fetchNamedConfigList(), dbutils::gui::ConfigDataTreeModel._populateSubTree(), dbutils::gui::ConfigDataTreeEditor.addChildRow(), dbutils::gui::ConfigDataTreeModel.addChildRow(), dbutils::gui::CustomTabWidget.addInitialRow(), dbutils::gui::TabbedSetOfTableEditors.addInitialRow(), dbutils::gui::TabbedSetOfTreeEditors.addInitialRow(), dbutils::gui::ConfigDataTableModel.addInitialRow(), dbutils::gui::ConfigDataTreeEditor.addRowAfter(), dbutils::gui::ConfigDataTableModel.addRowAfter(), dbutils::gui::ConfigDataTreeEditor.addRowBefore(), tbana::SpillStreamAna.analyze(), tbana::DetectorRateShutOff.analyze(), dbutils::dcs::APDSettings.APDSettings(), dbutils::daqconfig::BNEVBRunConfig.BNEVBRunConfig(), bsim.calcLocationWeights(), caf::Proxy< caf::SRNuGenParticle >.CheckEquals(), flat::Flat< caf::SRNuGenParticle >.Clear(), gov::fnal::cd::rms::provider::DPSingleton.connect_participant(), dbutils::daqconfig::DDTConnectConfig.DDTConnectConfig(), dbutils::gui::ConfigDataTableModel.deleteRow(), dbutils::daqconfig::DLRunConfig.DLRunConfig(), evd::GeometryDrawer.DrawBadBoxesPretty(), art::productstatus.dropped(), art::productstatus.dummyToPreventDoubleCount(), genie::FermiMover.Emit2ndNucleonFromSRC(), util.EnvExpansion(), gibuu::GiBUURegen.ExpandLibraryPath(), flat::Flat< caf::SRNuGenParticle >.Fill(), FindhAFate(), genie::flux::GAstroFlux.GenerateNext(), dbutils::gui::DCSConfigEditorDisplay.generateRecipeScripts(), novadaq::ProcessUtils.getChildProcessIds(), novadaq::ProcessUtils.getDescendantProcessIds(), gov::fnal::cd::rms::provider.getErrorName(), dbutils::dcs::APDSettings.getTemperature(), genie::KNOHadronization.HandleDecays(), tensorflow::TFHandler.Initialize(), dbutils::gui::ConfigDataTableModel.insertRows(), dbutils::gui::ConfigDataTreeModel.insertRows(), load_libs_from_command(), dbutils::gui::CustomTabWidget.loadData(), dbutils::gui::TabbedSetOfTableEditors.loadData(), dbutils::gui::TabbedSetOfTreeEditors.loadData(), loadlibs(), genie::FermiMomentumTablePool.LoadTables(), dbutils::daqconfig::NamedConfigUtils.markConfigDone(), dbutils::daqconfig::NDMRunConfig.NDMRunConfig(), art::productstatus.neverCreated(), NewNearlinePlots(), genie::utils::fragmrec.NParticles(), caf::Proxy< caf::SRNuGenParticle >.operator=(), dbutils::daqconfig::PixelEnableMasks.PixelEnableMasks(), dbutils::daqconfig::PixelThresholds.PixelThresholds(), tensorflow::TFHandler.Predict(), tensorflow::TensorflowHandler.Predict(), art::productstatus.present(), genie::TuneId.Print(), gov::fnal::cd::rms::provider::DDSTopicReaderClass< TT_ >.receiveMessage(), gov::fnal::cd::rms::provider::DDSConnection.receiveMessage(), dbutils::gui::ConfigDataTableModel.removeRows(), dbutils::gui::ConfigDataTreeModel.removeRows(), lem::LEMMixer.respondToOpenInputFile(), novadaq::BackgroundProcess.run(), dbutils::gui::CustomTabWidget.saveChanges(), dbutils::gui::TabbedSetOfTreeEditors.saveChanges(), dbutils::gui::TabbedSetOfTableEditors.saveChanges(), dbutils::gui::BasicEditorDisplay.saveChanges(), dbutils::gui::BasicEditorDisplay.saveChangesWithNewName(), set_eventn_status_track(), set_eventn_status_vertex(), gov::fnal::cd::rms::provider::DDSTopicReaderClass< TT_ >.statusConditionHandler(), novadaq::BackgroundProcess.stop(), nutools::dbi::Table.Tag(), nova::dbi::Table.Tag(), gov::fnal::cd::rms::provider::DDSTopicReaderClass< TT_ >.take_timed_wait(), art::productstatus.uninitialized(), art::productstatus.unknown(), genie::GMCJMonitor.Update(), wildcard(), ana.Wildcard(), novadaq::LocationUtils.wordExpansion(), gov::fnal::cd::rms::provider::DDSTopicWriterClass< TT_ >.write(), nutools::dbi::Table.Write(), nova::dbi::Table.Write(), genie::utils::app_init.XSecTable(), and dbutils::gui::BasicEditorDisplay.~BasicEditorDisplay().

fabricate.string_types = str

Definition at line 56 of file fabricate.py.

fabricate.threading_condition = threading.Condition

Definition at line 57 of file fabricate.py.