def Execute(rule, directory):
"""
Execute the rule in the given directory
"""
global has_executable
# If the executable is not present, notify and terminate
if not has_executable:
print I18n.get('no_executable').format(options['exec'])
if directory.options.get(rule, 'partial') == '0':
sys.exit(1)
return
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, directory)
if toProcess == []:
return
executable = directory.getProperty(rule, 'exec')
outputFormat = directory.getProperty(rule, 'output_format')
if not outputFormat in set([]):
print I18n.get('program_incorrect_format').format(executable,
outputFormat)
sys.exit(1)
# Prepare the command to execute
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Create a list with the suffixes to consider
suffixes = []
produceValues = set(dirObj.getProperty(rule, 'produce').split())
if 'regular' in produceValues:
# Delete the regular version
suffixes.append('')
if 'solution' in produceValues:
# Delete the solution
suffixes.append('_solution')
if 'pguide' in produceValues:
# Delete the professor guide
suffixes.append('_pguide')
if 'submit' in produceValues:
# Delete the submission file
suffixes.append('_submit')
xsltproc.doClean(rule, dirObj, toProcess, suffixes)
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Loop over all source files to process
dstDir = dirObj.getProperty(rule, 'dst_dir')
nupOption = dirObj.getProperty(rule, 'nup')
for datafile in toProcess:
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Derive the destination file name
dstFile = os.path.splitext(os.path.basename(datafile))[0] + \
'-' + nupOption + os.path.splitext(os.path.basename(datafile))[1]
dstFile = os.path.abspath(os.path.join(dstDir, dstFile))
if not os.path.exists(dstFile):
continue
rules.remove(dstFile)
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
global has_executable
if has_executable == '':
has_executable = adagio.findExecutable(rule, dirObj)
# If the executable is not present, notify and terminate
if not has_executable:
print i18n.get('no_executable').format(dirObj.options.get(rule, 'exec'))
if dirObj.options.get(rule, 'partial') == '0':
sys.exit(1)
return
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
adagio.logDebug(rule, dirObj, i18n.get('no_file_to_process'))
return
# Loop over all source files to process
executable = dirObj.getProperty(rule, 'exec')
extraArgs = dirObj.getProperty(rule, 'extra_arguments')
# The command is soffice --nologo --invisible --headless
# --convert-to pdf *.doc
command = [executable, '--nologo', '--invisible', '--headless',
'--convert-to', 'pdf']
command.extend(extraArgs.split())
dstDir = dirObj.getProperty(rule, 'src_dir')
for datafile in toProcess:
adagio.logDebug(rule, dirObj, ' EXEC ' + datafile)
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Derive the destination file name
dstFileName = os.path.splitext(os.path.basename(datafile))[0] + \
'.pdf'
dstFile = os.path.abspath(os.path.join(dstDir, dstFileName))
# Perform the execution
command.append(datafile)
# command.append('macro:///Tools.MSToPDF.ConvertMSToPDF(' + datafile + ')')
rules.doExecution(rule, dirObj, command, datafile, dstFile,
stdout = adagio.userLog)
command.pop(-1)
# End of loop over all src files
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
global has_executable
if has_executable == '':
has_executable = adagio.findExecutable(rule, dirObj)
# If the executable is not present, notify and terminate
if not has_executable:
print i18n.get('no_executable').format(dirObj.options.get(rule, 'exec'))
if dirObj.options.get(rule, 'partial') == '0':
sys.exit(1)
return
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Prepare the command to execute
executable = dirObj.getProperty(rule, 'exec')
dstDir = dirObj.getProperty(rule, 'dst_dir')
outputFormat = dirObj.getProperty(rule, 'output_format')
if outputFormat == '':
print i18n.get('empty_output_format').format(rule)
sys.exit(1)
# Loop over all source files to process
for datafile in toProcess:
adagio.logDebug(rule, dirObj, ' EXEC ' + datafile)
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Derive the destination file name
dstFile = os.path.splitext(os.path.basename(datafile))[0] + \
'.' + outputFormat
dstFile = os.path.abspath(os.path.join(dstDir, dstFile))
# Add the input file to the command
command = [executable, '-L', outputFormat]
command.extend(dirObj.getProperty(rule,
'extra_arguments').split())
command.extend([datafile, dstFile])
# Perform the execution
rules.doExecution(rule, dirObj, command, datafile, dstFile,
adagio.userLog, adagio.userLog)
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, "Cleaning")
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
doClean(rule, dirObj, toProcess)
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Every source file given is processed to know how many permutations will be
# rawFiles contains the list of files produced that need to be processed
rawFiles = doShuffle(toProcess, dirObj)
# Prepare the style transformation
styleFiles = dirObj.getProperty(rule, 'styles')
styleTransform = xsltproc.createStyleTransform(styleFiles.split())
if styleTransform == None:
print i18n.get('no_style_file')
return
# Create the dictionary of stylesheet parameters
styleParams = xsltproc.createParameterDict(rule, dirObj)
# Create a list with the param dictionaries to use in the different versions
# to be created.
paramDict = []
produceValues = set(dirObj.getProperty(rule, 'produce').split())
if 'regular' in produceValues:
# Create the regular version, no additional parameters needed
paramDict.append(({}, ''))
if 'solution' in produceValues:
paramDict.append(({'solutions.include.guide': "'yes'",
'adagio.testquestions.include.solutions': "'yes'"},
'_solution'))
if 'pguide' in produceValues:
paramDict.append(({'solutions.include.guide': "'yes'",
'adagio.testquestions.include.solutions': "'yes'",
'professorguide.include.guide': "'yes'",
'adagio.testquestions.include.id': "'yes'",
'adagio.testquestions.include.history': "'yes'"},
'_pguide'))
# Apply all these transformations.
xsltproc.doTransformations(styleFiles.split(), styleTransform, styleParams,
rawFiles, rule, dirObj, paramDict)
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Perform the copy
doCopy(rule, dirObj, toProcess,
dirObj.getProperty(rule, 'src_dir'),
dirObj.getProperty(rule, 'dst_dir'))
return
def clean(rule, directory):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, directory, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, directory)
if toProcess == []:
return
print 'Not implemented yet'
sys.exit(1)
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Loop over all source files to process
doClean(rule, dirObj, toProcess,
dirObj.getProperty(rule, 'src_dir'),
dirObj.getProperty(rule, 'dst_dir'))
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Loop over all source files to process
dstDir = dirObj.getProperty(rule, 'dst_dir')
outputFormat = dirObj.getProperty(rule, 'output_format')
for datafile in toProcess:
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Derive the destination file name
dstPrefix = os.path.splitext(os.path.basename(datafile))[0]
dstPrefix = os.path.join(dstDir, dstPrefix)
extensionsToClean = ['out', 'aux', 'log', 'bbl', 'blg', 'idx',
'ilg', 'ind', 'lof', 'lot', 'toc']
if outputFormat != 'dvipdf':
extensionsToClean.append(outputFormat)
else:
extensionsToClean.append('dvi')
extensionsToClean.append('pdf')
for fmt in extensionsToClean:
dstFile = dstPrefix + '.' + fmt
if not os.path.exists(dstFile):
continue
rules.remove(dstFile)
return
def prepareExecution(rule, dirObj, functionOption):
"""
Redirect stdin, stdout, stderr + set argv to new values.
"""
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Drop the extensions of the script files
toProcess = map(lambda x: os.path.splitext(x)[0], toProcess)
# Get the function to execute
functionName = dirObj.getProperty(rule, functionOption)
# Modify input/output/error channels
oldStdin = sys.stdin
oldStdout = sys.stdout
oldStderr = sys.stderr
newStdin = dirObj.getProperty(rule, 'stdin')
newStdout = dirObj.getProperty(rule, 'stdout')
newStderr = dirObj.getProperty(rule, 'stderr')
if newStdin != '':
if not os.path.exists(newStdin):
print i18n.get('file_not_found').format(newStdin)
sys.exit(1)
sys.stdin = codecs.open(newStdin, 'r')
if newStdout != '':
sys.stdout = codecs.open(newStdout, 'w')
if newStderr != '':
sys.stderr = codecs.open(newStderr, 'w')
# Execute the 'main' function
executeFunction(toProcess, rule, dirObj, functionName)
# Restore
sys.stdin = oldStdin
sys.stdout = oldStdout
sys.stderr = oldStderr
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Check if dstDir is empty, in which case, there is nothing to do
dstDir = dirObj.getProperty(rule, 'dst_dir')
if dstDir == '':
print i18n.get('export_no_dst')
return
# If we are here, the export may proceed!
srcDir = dirObj.getProperty(rule, 'src_dir')
filecopy.doCopy(rule, dirObj, toProcess, srcDir, dstDir)
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Get geometry
geometries = dirObj.getProperty(rule, 'geometry').split()
if geometries == []:
print i18n.get('no_var_value').format('geometry')
return
# Loop over all the source files
dstDir = dirObj.getProperty(rule, 'dst_dir')
for datafile in toProcess:
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Loop over formats
for geometry in geometries:
# Derive the destination file name
(fn, ext) = os.path.splitext(os.path.basename(datafile))
dstFile = fn + '_' + geometry + ext
dstFile = os.path.abspath(os.path.join(dstDir, dstFile))
if not os.path.exists(dstFile):
continue
rules.remove(dstFile)
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
rawFiles = []
for fname in toProcess:
# Get the result files
resultFiles = doGetShuffledFiles(fname)
# Accumulate the list
rawFiles.extend(resultFiles)
suffixes = []
produceValues = set(dirObj.getProperty(rule, 'produce').split())
if 'regular' in produceValues:
# Delete the regular version
suffixes.append('')
if 'solution' in produceValues:
# Delete the solution
suffixes.append('_solution')
if 'pguide' in produceValues:
# Delete the professor guide
suffixes.append('_pguide')
xsltproc.doClean(rule, dirObj, rawFiles, suffixes)
# Clean also the produced files
map(lambda x: rules.remove(x), rawFiles)
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule. The rule is executed under the same
conditions explained in the documentation variable.
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Check the condition
dstDir = dirObj.getProperty(rule, 'dst_dir')
if dstDir == '':
return
# If we are here, the export may proceed!
filecopy.doClean(rule, dirObj, toProcess,
dirObj.getProperty(rule, 'src_dir'), dstDir)
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Prepare the style transformation
styleFiles = dirObj.getProperty(rule, "styles").split()
styleTransform = createStyleTransform(styleFiles)
if styleTransform == None:
print i18n.get("no_style_file")
return
# Create the dictionary of stylesheet parameters
styleParams = createParameterDict(rule, dirObj)
doTransformations(styleFiles, styleTransform, styleParams, toProcess, rule, dirObj)
return
def clean(rule, dirObj):
"""
Clean the files produced by this rule
"""
adagio.logInfo(rule, dirObj, 'Cleaning')
# Get the files to process
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Get the dstDir
dstDir = dirObj.getProperty(rule, 'dst_dir')
# If dist dir not found, terminate
if not os.path.isdir(dstDir):
print i18n.get('file_not_found').format(dstDir)
sys.exit(1)
# Delete the dst directory
rules.remove(dstDir)
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
global has_executable
if has_executable == '':
has_executable = adagio.findExecutable(rule, dirObj)
# If the executable is not present, notify and terminate
if not has_executable:
print i18n.get('no_executable').format(dirObj.options.get(rule, 'exec'))
if dirObj.options.get(rule, 'partial') == '0':
sys.exit(1)
return
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
executable = dirObj.getProperty(rule, 'exec')
outputFormat = dirObj.getProperty(rule, 'output_format')
if not outputFormat in set(['tex', 'dvi', 'ps', 'pdf']):
print i18n.get('program_incorrect_format').format(executable,
outputFormat)
sys.exit(1)
# Prepare the command to execute
dstDir = dirObj.getProperty(rule, 'dst_dir')
if dirObj.getProperty(rule, 'compliant_mode') == '1':
compliantOptions = \
'-P doc.collab.show=0 -P latex.output.revhistory=0'.split()
else:
compliantOptions = []
extraArgs = dirObj.getProperty(rule, 'extra_arguments')
extraXsltArgs = dirObj.getProperty(rule,
'extra_xslt_arguments').split()
extraXsltArgs = reduce(lambda x, y: x + ['-x', y], extraXsltArgs, [])
commandPrefix = [executable, '-t', outputFormat]
commandPrefix.extend(compliantOptions)
commandPrefix.extend(extraXsltArgs)
commandPrefix.extend(extraArgs.split())
# Loop over all source files to process
for datafile in toProcess:
adagio.logDebug(rule, dirObj, ' EXEC ' + datafile)
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Derive the destination file name
dstFile = os.path.splitext(os.path.basename(datafile))[0] + \
'.' + outputFormat
dstFile = os.path.abspath(os.path.join(dstDir, dstFile))
# Add the output and input files to the command
command = commandPrefix + ['-o', dstFile] + [datafile]
# Perform the execution
rules.doExecution(rule, dirObj, command, datafile, dstFile,
adagio.userLog, adagio.userLog)
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
# Prepare the style transformation
styleFiles = dirObj.getProperty(rule, 'styles')
styleTransform = xsltproc.createStyleTransform(styleFiles.split())
if styleTransform == None:
print i18n.get('no_style_file')
return
# Create the dictionary of stylesheet parameters
styleParams = xsltproc.createParameterDict(rule, dirObj)
# Create a list with the param dictionaries to use in the different versions
# to be created.
paramDict = []
produceValues = set(dirObj.getProperty(rule, 'produce').split())
if 'regular' in produceValues:
# Create the regular version, no additional parameters needed
paramDict.append(({}, ''))
if 'solution' in produceValues:
paramDict.append(({'solutions.include.guide': "'yes'"},
'_solution'))
if 'pguide' in produceValues:
paramDict.append(({'solutions.include.guide': "'yes'",
'professorguide.include.guide': "'yes'"},
'_pguide'))
# Apply all these transformations.
xsltproc.doTransformations(styleFiles.split(), styleTransform, styleParams,
toProcess, rule, dirObj, paramDict)
# If 'submit' is also in the produce values, apply that transformation as
# well (an optimization could be applied here such that if the same style is
# given for the submit production, it could be folded in the previous
# transformations...)
if 'submit' in produceValues:
# Prepare the style transformation
styleFiles = dirObj.getProperty(rule, 'submit_styles')
styleTransform = xsltproc.createStyleTransform(styleFiles.split())
if styleTransform == None:
print i18n.get('no_style_file')
return
# Create the dictionary of stylesheet parameters
styleParams = xsltproc.createParameterDict(rule, dirObj)
# Apply the transformation and produce '_submit' file
xsltproc.doTransformations(styleFiles.split(), styleTransform,
styleParams, toProcess, rule, dirObj,
[({}, '_submit')])
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
global has_executable
if has_executable == '':
has_executable = adagio.findExecutable(rule, dirObj)
# If the executable is not present, notify and terminate
if not has_executable:
print i18n.get('no_executable').format(dirObj.options.get(rule, 'exec'))
if dirObj.options.get(rule, 'partial') == '0':
sys.exit(1)
return
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
adagio.logDebug(rule, dirObj, i18n.get('no_file_to_process'))
return
# Get geometry
geometries = dirObj.getProperty(rule, 'geometry').split()
if geometries == []:
print i18n.get('no_var_value').format('geometry')
return
# Loop over all source files to process
executable = dirObj.getProperty(rule, 'exec')
extraArgs = dirObj.getProperty(rule, 'extra_arguments')
convertCrop = dirObj.getProperty(rule, 'crop_option')
dstDir = dirObj.getProperty(rule, 'dst_dir')
for datafile in toProcess:
adagio.logDebug(rule, dirObj, ' EXEC ' + datafile)
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Loop over formats
for geometry in geometries:
# Derive the destination file name
(fn, ext) = os.path.splitext(os.path.basename(datafile))
dstFile = fn + '_' + geometry + ext
dstFile = os.path.abspath(os.path.join(dstDir, dstFile))
# Creat the command to execute (slightly non-optimal, because the
# following function might NOT execute the process due to
# dependencies
command = [executable, '-scale', geometry]
command.extend(convertCrop.split())
command.extend(extraArgs.split())
command.append(datafile)
command.append(dstFile)
# Perform the execution
rules.doExecution(rule, dirObj, command, datafile, dstFile,
adagio.userLog)
return
def Execute(rule, dirObj):
"""
Execute the rule in the given directory
"""
global has_executable
if has_executable == '':
has_executable = adagio.findExecutable(rule, dirObj)
# If the executable is not present, notify and terminate
if not has_executable:
print i18n.get('no_executable').format(dirObj.options.get(rule, 'exec'))
if dirObj.options.get(rule, 'partial') == '0':
sys.exit(1)
return
# Get the files to process, if empty, terminate
toProcess = rules.getFilesToProcess(rule, dirObj)
if toProcess == []:
return
executable = dirObj.getProperty(rule, 'exec')
outputFormat = dirObj.getProperty(rule, 'output_format')
if not outputFormat in set(['dvi', 'pdf', 'dvipdf']):
print i18n.get('program_incorrect_format').format(executable,
outputFormat)
sys.exit(1)
# Prepare the command to execute
dstDir = dirObj.getProperty(rule, 'dst_dir')
commandPrefix = [executable, '-output-directory=' + dstDir,
'-interaction=nonstopmode']
if outputFormat != 'dvipdf':
commandPrefix.append('-output-format=' + outputFormat)
commandPrefix.extend(dirObj.getProperty(rule,
'extra_arguments').split())
# Loop over all source files to process
for datafile in toProcess:
adagio.logDebug(rule, dirObj, ' EXEC ' + datafile)
# If file not found, terminate
if not os.path.isfile(datafile):
print i18n.get('file_not_found').format(datafile)
sys.exit(1)
# Derive the destination file name
baseName = os.path.splitext(os.path.basename(datafile))[0]
if outputFormat != 'dvipdf':
dstFile = baseName + '.' + outputFormat
else:
dstFile = baseName + '.dvi'
pdfFile = baseName + '.pdf'
dstFile = os.path.abspath(os.path.join(dstDir, dstFile))
# Add the input file to the command
command = commandPrefix + [datafile]
# Perform the execution
rules.doExecution(rule, dirObj, command, datafile, dstFile,
adagio.userLog)
if outputFormat == 'dvipdf':
rules.doExecution(rule, dirObj, ['dvipdf', dstFile], datafile,
pdfFile, adagio.userLog)
return
