|
|
|
|
|
from __future__ import absolute_import, division, print_function, unicode_literals |
|
|
from future.utils import raise_from, string_types |
|
|
from builtins import (bytes, str, open, super, range, |
|
|
zip, round, input, int, pow, object) |
|
|
|
|
|
import os |
|
|
import io |
|
|
import sys |
|
|
import shutil |
|
|
import subprocess |
|
|
|
|
|
if (sys.version_info < (3, 0)) and (os.name == 'nt'): |
|
|
import gslab_make.private.subprocess_fix as subprocess_fix |
|
|
else: |
|
|
import subprocess as subprocess_fix |
|
|
|
|
|
from termcolor import colored |
|
|
import colorama |
|
|
colorama.init() |
|
|
|
|
|
import gslab_make.private.messages as messages |
|
|
import gslab_make.private.metadata as metadata |
|
|
from gslab_make.private.exceptionclasses import CritError |
|
|
from gslab_make.private.utility import norm_path, format_list, format_traceback, decode |
|
|
|
|
|
|
|
|
class Directive(object): |
|
|
""" |
|
|
Directive. |
|
|
|
|
|
Note |
|
|
---- |
|
|
Contains instructions on how to run shell commands. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
makelog : str |
|
|
Path of make log. |
|
|
log : str, optional |
|
|
Path of directive log. Directive log is only written if specified. |
|
|
Defaults to ``''`` (i.e., not written). |
|
|
osname : str, optional |
|
|
Name of OS. Defaults to ``os.name``. |
|
|
shell : bool, optional |
|
|
See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
|
|
Defaults to ``True``. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
def __init__(self, |
|
|
makelog, |
|
|
log = '', |
|
|
osname = os.name, |
|
|
shell = True): |
|
|
|
|
|
self.makelog = makelog |
|
|
self.log = log |
|
|
self.osname = osname |
|
|
self.shell = shell |
|
|
self.check_os() |
|
|
self.get_paths() |
|
|
|
|
|
def check_os(self): |
|
|
"""Check OS is either POSIX or NT. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
if self.osname not in ['posix', 'nt']: |
|
|
raise CritError(messages.crit_error_unknown_system % self.osname) |
|
|
|
|
|
def get_paths(self): |
|
|
"""Normalize paths. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
self.makelog = norm_path(self.makelog) |
|
|
self.log = norm_path(self.log) |
|
|
|
|
|
def execute_command(self, command): |
|
|
"""Execute shell command. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
command : str |
|
|
Shell command to execute. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
exit : tuple |
|
|
Tuple (exit code, error message) for shell command. |
|
|
""" |
|
|
|
|
|
self.output = 'Executing command: `%s`' % command |
|
|
print(colored(self.output, metadata.color_in_process)) |
|
|
|
|
|
try: |
|
|
if not self.shell: |
|
|
command = command.split() |
|
|
|
|
|
process = subprocess_fix.Popen(command, |
|
|
stdout = subprocess.PIPE, |
|
|
stderr = subprocess.PIPE, |
|
|
shell = self.shell, |
|
|
universal_newlines = True) |
|
|
stdout, stderr = process.communicate() |
|
|
exit = (process.returncode, stderr) |
|
|
|
|
|
if stdout: |
|
|
self.output += '\n' + decode(stdout) |
|
|
if stderr: |
|
|
self.output += '\n' + decode(stderr) |
|
|
pass |
|
|
|
|
|
return(exit) |
|
|
except: |
|
|
error_message = messages.crit_error_bad_command % command |
|
|
error_message = error_message + format_traceback() |
|
|
raise_from(CritError(error_message), None) |
|
|
|
|
|
def write_log(self): |
|
|
"""Write logs for shell command. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
if self.makelog: |
|
|
if not (metadata.makelog_started and os.path.isfile(self.makelog)): |
|
|
raise CritError(messages.crit_error_no_makelog % self.makelog) |
|
|
with io.open(self.makelog, 'a', encoding = 'utf-8', errors = 'ignore') as f: |
|
|
print(self.output, file = f) |
|
|
|
|
|
if self.log: |
|
|
with io.open(self.log, 'w', encoding = 'utf-8', errors = 'ignore') as f: |
|
|
f.write(self.output) |
|
|
|
|
|
|
|
|
class ProgramDirective(Directive): |
|
|
""" |
|
|
Program directive. |
|
|
|
|
|
Notes |
|
|
----- |
|
|
Contains instructions on how to run a program through shell command. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
See :class:`.Directive`. |
|
|
|
|
|
application : str |
|
|
Name of application to run program. |
|
|
program : str |
|
|
Path of program to run. |
|
|
executable : str, optional |
|
|
Executable to use for shell command. Defaults to executable specified in metadata. |
|
|
option : str, optional |
|
|
Options for shell command. Defaults to options specified in metadata. |
|
|
args : str, optional |
|
|
Arguments for shell command. Defaults to no arguments. |
|
|
|
|
|
Attributes |
|
|
---------- |
|
|
program_dir : str |
|
|
Directory of program parsed from program. |
|
|
program_base : str |
|
|
``program_name.program_ext`` of program parsed from program. |
|
|
program_name : str |
|
|
Name of program parsed from program. |
|
|
program_ext : str |
|
|
Extension of program parsed from program. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
def __init__(self, |
|
|
application, |
|
|
program, |
|
|
executable = '', |
|
|
option = '', |
|
|
args = '', |
|
|
**kwargs): |
|
|
|
|
|
self.application = application |
|
|
self.program = program |
|
|
self.executable = executable |
|
|
self.option = option |
|
|
self.args = args |
|
|
super(ProgramDirective, self).__init__(**kwargs) |
|
|
self.parse_program() |
|
|
self.check_program() |
|
|
self.get_executable() |
|
|
self.get_option() |
|
|
|
|
|
def parse_program(self): |
|
|
"""Parse program for directory, name, and extension. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
self.program = norm_path(self.program) |
|
|
self.program_dir = os.path.dirname(self.program) |
|
|
self.program_base = os.path.basename(self.program) |
|
|
self.program_name, self.program_ext = os.path.splitext(self.program_base) |
|
|
|
|
|
def check_program(self): |
|
|
"""Check program exists and has correct extension given application. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
if not os.path.isfile(self.program): |
|
|
raise CritError(messages.crit_error_no_file % self.program) |
|
|
|
|
|
if self.program_ext not in metadata.extensions[self.application]: |
|
|
extensions = format_list(metadata.extensions[self.application]) |
|
|
raise CritError(messages.crit_error_extension % (self.program, extensions)) |
|
|
|
|
|
def get_executable(self): |
|
|
"""Set executable to default from metadata if unspecified. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
if not self.executable: |
|
|
self.executable = metadata.default_executables[self.osname][self.application] |
|
|
|
|
|
def get_option(self): |
|
|
"""Set options to default from metadata if unspecified. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
if not self.option: |
|
|
self.option = metadata.default_options[self.osname][self.application] |
|
|
|
|
|
def move_program_output(self, program_output, log_file = ''): |
|
|
"""Move program outputs. |
|
|
|
|
|
Notes |
|
|
----- |
|
|
Certain applications create program outputs that need to be moved to |
|
|
appropriate logging files. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
program_output : str |
|
|
Path of program output. |
|
|
log_file : str, optional |
|
|
Path of log file. Log file is only written if specified. |
|
|
Defaults to ``''`` (i.e., not written). |
|
|
""" |
|
|
|
|
|
program_output = norm_path(program_output) |
|
|
|
|
|
try: |
|
|
with io.open(program_output, 'r', encoding = 'utf-8', errors = 'ignore') as f: |
|
|
out = f.read() |
|
|
except: |
|
|
error_message = messages.crit_error_no_program_output % (program_output, self.program) |
|
|
error_message = error_message + format_traceback() |
|
|
raise_from(CritError(error_message), None) |
|
|
|
|
|
if self.makelog: |
|
|
if not (metadata.makelog_started and os.path.isfile(self.makelog)): |
|
|
raise CritError(messages.crit_error_no_makelog % self.makelog) |
|
|
with io.open(self.makelog, 'a', encoding = 'utf-8', errors = 'ignore') as f: |
|
|
print(out, file = f) |
|
|
|
|
|
if log_file: |
|
|
if program_output != log_file: |
|
|
shutil.copy2(program_output, log_file) |
|
|
os.remove(program_output) |
|
|
else: |
|
|
os.remove(program_output) |
|
|
|
|
|
return(out) |
|
|
|
|
|
|
|
|
class SASDirective(ProgramDirective): |
|
|
""" |
|
|
SAS directive. |
|
|
|
|
|
Notes |
|
|
----- |
|
|
Contains instructions on how to run a SAS program through shell command. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
See :class:`.ProgramDirective`. |
|
|
|
|
|
lst : str, optional |
|
|
Path of directive lst. Directive lst is only written if specified. |
|
|
Defaults to ``''`` (i.e., not written). |
|
|
""" |
|
|
def __init__(self, |
|
|
lst = '', |
|
|
**kwargs): |
|
|
|
|
|
self.lst = lst |
|
|
super(SASDirective, self).__init__(**kwargs) |
|
|
|
|
|
|
|
|
class LyXDirective(ProgramDirective): |
|
|
""" |
|
|
LyX directive. |
|
|
|
|
|
Notes |
|
|
----- |
|
|
Contains instructions on how to run a LyX program through shell command. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
See :class:`.ProgramDirective`. |
|
|
|
|
|
output_dir : str |
|
|
Directory to write PDFs. |
|
|
doctype : str, optional |
|
|
Type of LyX document. Takes either ``'handout'`` and ``'comments'``. |
|
|
All other strings will default to standard document type. |
|
|
Defaults to ``''`` (i.e., standard document type). |
|
|
""" |
|
|
|
|
|
def __init__(self, |
|
|
output_dir, |
|
|
doctype = '', |
|
|
**kwargs): |
|
|
|
|
|
self.output_dir = output_dir |
|
|
self.doctype = doctype |
|
|
super(LyXDirective, self).__init__(**kwargs) |
|
|
self.check_doctype() |
|
|
|
|
|
def check_doctype(self): |
|
|
"""Check document type is valid. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
None |
|
|
""" |
|
|
|
|
|
if self.doctype not in ['handout', 'comments', '']: |
|
|
print(colored(messages.warning_lyx_type % self.doctype, 'red')) |
|
|
self.doctype = '' |
|
|
|
