RushFunctions.py

Go to the documentation of this file.

#  This file is part of repro, a Python package for automating 
#  reproducible research in scientific computing.
#
#  Copyright (C) 2008  Gilles Hennenfent, Sean Ross-Ross
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program.  If not, see <http://www.gnu.org/licenses/>.

from SCons.Script import Mkdir
from os.path import abspath,isdir,join,split,isfile
from repro.functions.reproexports import reproexports
from repro.BookKeeping import ReproProject
import re
import os


##
# 
#     @todo Documentation
#     
def rsf_program_prefix( target, source, env, name ):
    
    omp = env.get('OMP')
    
    if omp is True:
        omp = env.WhereIs( 'sfomp' )
        
    prog = env.WhereIs( 'sf' + name )
    
    if not prog:
        prog = name
        
    if omp:
        prog = "%s %s" %(omp,prog)
        
    return prog

##
# 
#     @todo Documentation
#     
def rush_method( self, target=None, source=None, flow_command=None, *p,**kw ):
    
    return self._Rush( target, source, flow_command=flow_command, *p, **kw )


##
# 
#     @todo Documentation
#     
def get_in_eqs( contents ):
    
    binary_file = None
    for line in contents.splitlines():
        if "in=" in line:
            binary_file = line.split("in=",1)[-1]
            binary_file = binary_file.strip()
            binary_file = binary_file.strip('"')
    return binary_file

##
# 
#     @todo Documentation
#     
def sfbin_method( env, targets, *p, **kw ):
    
    targets = env.Split(targets)
    
    pack = kw.get('rsfpack', env.get('rsfpack') )
    datapath = kw.get('DATAPATH', env.get('DATAPATH') )
    if pack:
        return targets 
    
    for target in targets:
        
        if hasattr( target, 'suffix' ) and target.suffix == ".rsf":
            binary_part = get_in_eqs( target.get_contents() )
            #guess where data is 
            if not binary_part:
                binary_part = join(datapath ,str(target) + "@" )
            elif not isfile(binary_part) and isfile(target.path):
                env.AlwaysBuild( target )
            env.SideEffect(binary_part, target)
            env.Clean( target, binary_part )
    return targets

##
# 
#     @todo Documentation
#     
def rsf_emitter( target, source, env ):
        
    datapath = env.get('DATAPATH','.')
    datapath = abspath(datapath) 
    
    cwd = os.getcwd()
    here = split(cwd)[-1]
    
    
    reproexports( env )
    datapath = join( datapath, "%s-hash-%s/" %(here,hash(cwd)) )
    if not isdir(datapath):
        if env.GetOption('help') or env.GetOption('clean') or env.GetOption('no_exec'):
            pass
        else:
            env.Execute( Mkdir(datapath) ) 
    
    env['DATAPATH'] = datapath
    env['ENV']['DATAPATH'] = datapath
    
    sfbin_method( env, target )

    return target, source

##
# 
#     @todo Documentation
#     
def gen_suffix(env, sources):
    
    suffixes = [src.suffix for src in sources if hasattr(src,'suffix')]
    if suffixes:
        suffix = suffixes[0]
        suffix = env.get('RUSHSUFFIX' , suffix )
        return suffix
    else:
        return "" 

##
# 
#     @todo Documentation
#     
def flow_join(flow_command):
    
    if isinstance(flow_command,str):
        return flow_command
    else:
        return " | ".join(flow_command)

##
# 
#     @todo Documentation
#     
def tilda_command_expantion( env, flow_command ):
    
    c = re.compile('~~|~([\w.-]+)')
    
    new_flow_command = []
    for flow in flow_command:
        all = [mch for mch in c.findall(flow) if mch]
        
        for mch in all:
            flow = flow.replace( "~%(mch)s" %vars(), "${_SF('%(mch)s')}" %vars() )
            
        new_flow_command.append(flow)
    return new_flow_command
        
    
##
# 
#     @todo Documentation
#     
def defaultSF( target, source, env, name ):
    
    return name

class PROG_SUFFIX_GUESS( object ):
    def __init__(self, target, source, env):
        self.target = target
        self.source = source
        self.env = env
    def __call__(self,name):
        SFDict = self.env.get('SF',defaultSF)
        
        if isinstance(SFDict, dict):
            SF = SFDict.get( self.target[0].suffix, defaultSF )
        else:
            SF = SFDict
        
        return SF( self.target, self.source, 
                   self.env, name )
    
##
# 
#     @todo Documentation
#     
def rush_gen( source, target, env, for_signature ):

    flow_command = env.get( 'flow_command' )
        
    if for_signature or env.GetOption("clean") or env.GetOption("no_exec"):
        flow_command = flow_command[:] 
        for idx,flow in enumerate(flow_command):
            flow_command[idx] = flow.replace( ".read()", "" )
    
    env['_flow_command'] = flow_command
    return ['$RUSHSTR']


##
# 
#     @todo Documentation
#     
def add_to_books( target, source, env, flow_command ):

    for flow in flow_command:
        try:
            command = env.subst(flow.split()[0])
            
            ReproProject.record_flow(env, command, target[0].dir.path )
        except:
            print "WARNING: not adding command",repr(flow), 'to books'
            raise
    return

##
# 
#     @todo Documentation
#     
def add_dependancies( env,flow_command):

    deps = []
    for flow in flow_command:
        command = env.subst(flow.split()[0])
        command = env.WhereIs(command)
        if command:
            deps.append( command )
    return deps
    
##
# 
#     @todo Documentation
#     
def RUSH_EMITTER( target, source, env ):

    env.Alias('flow', target)
    
    _SF = PROG_SUFFIX_GUESS(target, source, env)
    env['_SF'] = _SF

    flow_command = env.get( 'flow_command' )
    if isinstance(flow_command, str):
        flow_command = flow_command.split("|")
    
    flow_command = tilda_command_expantion( env, flow_command )
    add_to_books( target, source, env, flow_command)
    
    deps = add_dependancies( env, flow_command )
    source.extend(deps)
    
    env['flow_command'] = flow_command

    suffixes = [src.suffix for src in source if hasattr(src,'suffix')]
    if not suffixes:
        suffixes = [tgt.suffix for tgt in target if hasattr(tgt,'suffix')]
    
    for sfx in suffixes:
        if sfx in env['RUSH_EMITTERS']:
            return env['RUSH_EMITTERS'][sfx]( target, source, env )
        
    return target, source


##
# 
#     @todo Documentation
#     
def rsfprefix( name ):
    
    pass

---