# -*- coding: utf-8 -*- 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 `_. 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 = ''