| |
| 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 = '' |
|
|
