| |
| 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 re |
| import sys |
| import shutil |
| import traceback |
| import fileinput |
|
|
| import nbformat |
| from nbconvert.preprocessors import ExecutePreprocessor |
|
|
| 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, ColoredError, ProgramError |
| from gslab_make.private.programdirective import Directive, ProgramDirective, SASDirective, LyXDirective |
| from gslab_make.private.utility import get_path, format_message, norm_path |
| from gslab_make.write_logs import write_to_makelog |
|
|
|
|
| def run_jupyter(paths, program, timeout = None, kernel_name = ''): |
| """.. Run Jupyter notebook using system command. |
| |
| Runs notebook ``program`` using Python API, with notebook specified |
| in the form of ``notebook.ipynb``. |
| Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| timeout : int, optional |
| Time to wait (in seconds) to finish executing a cell before raising exception. |
| Defaults to no timeout. |
| kernel_name : str, optional |
| Name of kernel to use for execution |
| (e.g., ``python2`` for standard Python 2 kernel, ``python3`` for standard Python 3 kernel). |
| Defaults to ``''`` (i.e., kernel specified in notebook). |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_jupyter(paths, program = 'notebook.ipynb') |
| """ |
|
|
| try: |
| program = norm_path(program) |
|
|
| with open(program) as f: |
| message = 'Processing notebook: `%s`' % program |
| write_to_makelog(paths, message) |
| print(colored(message, 'cyan')) |
| |
| if not kernel_name: |
| kernel_name = 'python%s' % sys.version_info[0] |
| ep = ExecutePreprocessor(timeout = timeout, kernel_name = kernel_name) |
| nb = nbformat.read(f, as_version = 4) |
| ep.preprocess(nb, {'metadata': {'path': '.'}}) |
| |
| with open(program, 'wt') as f: |
| nbformat.write(nb, f) |
| except: |
| error_message = 'Error with `run_jupyter`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_lyx(paths, program, doctype = '', **kwargs): |
| """.. Run LyX script using system command. |
| |
| Compiles document ``program`` using system command, with document specified |
| in the form of ``script.lyx``. Status messages are appended to file ``makelog``. |
| PDF outputs are written in directory ``output_dir``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| 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). |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| output_dir : str |
| Directory to write PDFs. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_lyx(paths, program = 'script.lyx') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| output_dir = get_path(paths, 'output_dir') |
| direct = LyXDirective(output_dir = output_dir, |
| doctype = doctype, |
| application = 'lyx', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
| |
| |
| if direct.doctype: |
| temp_name = os.path.join(direct.program_name + '_' + direct.doctype) |
| temp_program = os.path.join(direct.program_dir, temp_name + '.lyx') |
| |
| beamer = False |
| shutil.copy2(direct.program, temp_program) |
|
|
| for line in fileinput.input(temp_program, inplace = True, backup = '.bak'): |
| if r'\textclass beamer' in line: |
| beamer = True |
| if direct.doctype == 'handout' and beamer and (r'\options' in line): |
| line = line.rstrip('\n') + ', handout\n' |
| elif direct.doctype == 'comments' and (r'\begin_inset Note Note' in line): |
| line = line.replace('Note Note', 'Note Greyedout') |
| |
| print(line) |
| else: |
| temp_name = direct.program_name |
| temp_program = direct.program |
|
|
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.option, temp_program) |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'LyX program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
|
|
| |
| temp_pdf = os.path.join(direct.program_dir, temp_name + '.pdf') |
| output_pdf = os.path.join(direct.output_dir, direct.program_name + '.pdf') |
|
|
| if temp_pdf != output_pdf: |
| shutil.copy2(temp_pdf, output_pdf) |
| os.remove(temp_pdf) |
| |
| |
| if direct.doctype: |
| os.remove(temp_program) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_lyx`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_latex(paths, program, **kwargs): |
| """.. Run LaTeX script using system command. |
| |
| Compiles document ``program`` using system command, with document specified |
| in the form of ``script.tex``. Status messages are appended to file ``makelog``. |
| PDF outputs are written in directory ``output_dir``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| output_dir : str |
| Directory to write PDFs. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Note |
| ---- |
| This function creates and removes a directory named ``latex_auxiliary_dir``. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_latex(paths, program = 'script.tex') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| output_dir = get_path(paths, 'output_dir') |
| direct = LyXDirective(output_dir = output_dir, |
| application = 'latex', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
| |
| temp_name = direct.program_name |
| temp_program = direct.program |
|
|
| |
| os.mkdir('latex_auxiliary_dir') |
| |
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.option, temp_program) |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'LaTeX program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
|
|
| |
| temp_pdf = os.path.join('latex_auxiliary_dir', temp_name + '.pdf') |
| output_pdf = os.path.join(direct.output_dir, direct.program_name + '.pdf') |
|
|
| if temp_pdf != output_pdf: |
| shutil.copy2(temp_pdf, output_pdf) |
| shutil.rmtree('latex_auxiliary_dir') |
| |
| |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_latex`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_mathematica(paths, program, **kwargs): |
| """.. Run Mathematica script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.m``. Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_mathematica(paths, program = 'script.m') |
| """ |
| |
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = ProgramDirective(application = 'math', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
|
|
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.program, direct.option) |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'Mathematica program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_mathematica`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_matlab(paths, program, **kwargs): |
| """.. Run Matlab script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.m``. Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_matlab(paths, program = 'script.m') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = ProgramDirective(application = 'matlab', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
| |
| |
| program_log = os.path.join(os.getcwd(), direct.program_name + '.log') |
|
|
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.option, direct.program, direct.program_name + '.log') |
| exit_code, stderr = direct.execute_command(command) |
| if exit_code != 0: |
| error_message = 'Matlab program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| direct.move_program_output(program_log, direct.log) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_matlab`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_perl(paths, program, **kwargs): |
| """.. Run Perl script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.pl``. Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Arguments for system command. Defaults to no arguments. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_perl(paths, program = 'script.pl') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = ProgramDirective(application = 'perl', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
| |
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.option, direct.program, direct.args) |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'Perl program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_perl`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_python(paths, program, **kwargs): |
| """.. Run Python script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.py``. Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Arguments for system command. Defaults to no arguments. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_python(paths, program = 'script.py') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = ProgramDirective(application = 'python', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
|
|
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.option, direct.program, direct.args) |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'Python program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_python`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_r(paths, program, **kwargs): |
| """.. Run R script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.R``. Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_r(paths, program = 'script.R') |
| """ |
| |
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = ProgramDirective(application = 'r', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
|
|
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.option, direct.program) |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'R program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_r`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
| |
|
|
| def run_sas(paths, program, lst = '', **kwargs): |
| """.. Run SAS script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.sas``. Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| lst : str, optional |
| Path of program lst. Program lst is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_sas(paths, program = 'script.sas') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = SASDirective(application = 'sas', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
|
|
| |
| program_log = os.path.join(os.getcwd(), direct.program_name + '.log') |
| program_lst = os.path.join(os.getcwd(), direct.program_name + '.lst') |
| |
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.option, direct.program) |
| exit_code, stderr = direct.execute_command(command) |
| if exit_code != 0: |
| error_message = 'SAS program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| direct.move_program_output(program_log) |
| direct.move_program_output(program_lst) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_sas`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_stat_transfer(paths, program, **kwargs): |
| """.. Run StatTransfer script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.stc`` or ``script.stcmd``. |
| Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_stat_transfer(paths, program = 'script.stc') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = ProgramDirective(application = 'st', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
|
|
| |
| command = metadata.commands[direct.osname][direct.application] % (direct.executable, direct.program) |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'StatTransfer program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_stat_transfer`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_stata(paths, program, **kwargs): |
| """.. Run Stata script using system command. |
| |
| Runs script ``program`` using system command, with script specified |
| in the form of ``script.do``. Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| program : str |
| Path of script to run. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Note |
| ---- |
| When a do-file contains a space in its name, different version of Stata save the |
| corresponding log file with different names. Some versions of Stata truncate the |
| name to everything before the first space of the do-file name. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of program log. Program log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| executable : str, optional |
| Executable to use for system command. |
| Defaults to executable specified in :ref:`default settings<default settings>`. |
| option : str, optional |
| Options for system command. Defaults to options specified in :ref:`default settings<default settings>`. |
| args : str, optional |
| Not applicable. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| .. code-block:: python |
| |
| run_stata(paths, program = 'script.do') |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = ProgramDirective(application = 'stata', |
| program = program, |
| makelog = makelog, |
| **kwargs) |
|
|
| |
| program_name = direct.program.split(" ")[0] |
| program_name = os.path.split(program_name)[-1] |
| program_name = os.path.splitext(program_name)[0] |
| program_log_partial = os.path.join(os.getcwd(), program_name + '.log') |
| |
| |
| program_log_full = os.path.join(os.getcwd(), direct.program_name + '.log') |
|
|
| |
| if direct.osname == "posix": |
| direct.program = re.escape(direct.program) |
|
|
| |
| command = metadata.commands[direct.osname]['stata'] % (direct.executable, direct.option, direct.program) |
| exit_code, stderr = direct.execute_command(command) |
| if exit_code != 0: |
| error_message = 'Stata program executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| try: |
| output = direct.move_program_output(program_log_partial, direct.log) |
| except: |
| output = direct.move_program_output(program_log_full, direct.log) |
| _check_stata_output(output) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `run_stata`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
| |
| |
| def _check_stata_output(output): |
| """.. Check Stata output""" |
| |
| regex = "end of do-file[\s]*r\([0-9]*\);" |
| if re.search(regex, output): |
| error_message = 'Stata program executed with errors.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, 'See makelog for more detail.'), None) |
| |
|
|
| def execute_command(paths, command, **kwargs): |
| """.. Run system command. |
| |
| Runs system command `command` with shell execution boolean ``shell``. |
| Outputs are appended to file ``makelog`` and written to system command log file ``log``. |
| Status messages are appended to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| command : str |
| System command to run. |
| shell : `bool`, optional |
| See `here <https://docs.python.org/3/library/subprocess.html#frequently-used-arguments>`_. |
| Defaults to ``True``. |
| log : str, optional |
| Path of system command log. System command log is only written if specified. |
| Defaults to ``''`` (i.e., not written). |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Note |
| ---- |
| We recommend leaving all other parameters to their defaults. |
| |
| Other Parameters |
| ---------------- |
| osname : str, optional |
| Name of OS. Used to check if OS is supported. Defaults to ``os.name``. |
| |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| The following code executes the ``ls`` command, |
| writes outputs to system command log file ``'file'``, |
| and appends outputs and/or status messages to ``paths['makelog']``. |
| |
| .. code-block:: python |
| |
| execute_command(paths, 'ls', log = 'file') |
| """ |
| |
| try: |
| makelog = get_path(paths, 'makelog') |
| direct = Directive(makelog = makelog, **kwargs) |
|
|
| |
| exit_code, stderr = direct.execute_command(command) |
| direct.write_log() |
| if exit_code != 0: |
| error_message = 'Command executed with errors. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ProgramError(error_message, stderr), None) |
| except ProgramError: |
| raise |
| except: |
| error_message = 'Error with `execute_command`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| write_to_makelog(paths, error_message + '\n\n' + traceback.format_exc()) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def run_module(root, module, build_script = 'make.py', osname = None): |
| """.. Run module. |
| |
| Runs script `build_script` in module directory `module` relative to root of repository `root`. |
| |
| Parameters |
| ---------- |
| root : str |
| Directory of root. |
| module: str |
| Name of module. |
| build_script : str |
| Name of build script. Defaults to ``make.py``. |
| osname : str, optional |
| Name of OS. Used to determine syntax of system command. Defaults to ``os.name``. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| The following code runs the script ``root/module/make.py``. |
| |
| .. code-block:: python |
| |
| run_module(root = 'root', module = 'module') |
| """ |
|
|
| osname = osname if osname else os.name |
|
|
| try: |
| module_dir = os.path.join(root, module) |
| os.chdir(module_dir) |
|
|
| build_script = norm_path(build_script) |
| if not os.path.isfile(build_script): |
| raise CritError(messages.crit_error_no_file % build_script) |
|
|
| message = 'Running module `%s`' % module |
| message = format_message(message) |
| message = colored(message, attrs = ['bold']) |
| print('\n' + message) |
|
|
| status = os.system('%s %s' % (metadata.default_executables[osname]['python'], build_script)) |
| if status != 0: |
| raise ProgramError() |
| except ProgramError: |
| sys.exit() |
| except: |
| error_message = 'Error with `run_module`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| __all__ = ['run_stata', 'run_matlab', 'run_perl', 'run_python', |
| 'run_jupyter', 'run_mathematica', 'run_stat_transfer', |
| 'run_lyx', 'run_latex', 'run_r', 'run_sas', |
| 'execute_command', 'run_module'] |
