| |
| 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 datetime |
| import traceback |
|
|
| 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 |
| from gslab_make.private.utility import convert_to_list, norm_path, get_path, glob_recursive, format_message |
|
|
|
|
| def start_makelog(paths): |
| """.. Start make log. |
| |
| Writes file ``makelog``, recording start time. |
| Sets make log status to boolean ``True``, which is used by other functions to confirm make log exists. |
| |
| Note |
| ---- |
| The make log start condition is used by other functions to confirm a make log exists. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Returns |
| ------- |
| None |
| """ |
|
|
| try: |
| makelog = get_path(paths, 'makelog') |
| metadata.makelog_started = True |
| |
| if makelog: |
| makelog = norm_path(makelog) |
| message = 'Starting makelog file at: `%s`' % makelog |
| print(colored(message, metadata.color_success)) |
| |
| with io.open(makelog, 'w', encoding = 'utf8', errors = 'ignore') as MAKELOG: |
| time_start = str(datetime.datetime.now().replace(microsecond = 0)) |
| working_dir = os.getcwd() |
| print(messages.note_dash_line, file = MAKELOG) |
| print(messages.note_makelog_start + time_start, file = MAKELOG) |
| print(messages.note_working_directory + working_dir, file = MAKELOG) |
| print(messages.note_dash_line, file = MAKELOG) |
| except: |
| error_message = 'Error with `start_makelog`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| def end_makelog(paths): |
| """.. End make log. |
| |
| Appends to file ``makelog``, recording end time. |
| |
| Note |
| ---- |
| We technically allow for writing to a make log even after the make log has ended. |
| We do not recommend this for best practice. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Returns |
| ------- |
| None |
| """ |
| |
| try: |
| makelog = get_path(paths, 'makelog') |
|
|
| if makelog: |
| makelog = norm_path(makelog) |
| message = 'Ending makelog file at: `%s`' % makelog |
| print(colored(message, metadata.color_success)) |
|
|
| if not (metadata.makelog_started and os.path.isfile(makelog)): |
| raise_from(CritError(messages.crit_error_no_makelog % makelog), None) |
|
|
| with io.open(makelog, 'a', encoding = 'utf8', errors = 'ignore') as MAKELOG: |
| time_end = str(datetime.datetime.now().replace(microsecond = 0)) |
| working_dir = os.getcwd() |
| print(messages.note_dash_line, file = MAKELOG) |
| print(messages.note_makelog_end + time_end, file = MAKELOG) |
| print(messages.note_working_directory + working_dir, file = MAKELOG) |
| print(messages.note_dash_line, file = MAKELOG) |
| except: |
| error_message = 'Error with `end_makelog`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
| |
|
|
| def write_to_makelog(paths, message): |
| """.. Write to make log. |
| |
| Appends string ``message`` to file ``makelog``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| message : str |
| Message to append. |
| |
| Path Keys |
| --------- |
| makelog : str |
| Path of makelog. |
| |
| Returns |
| ------- |
| None |
| """ |
|
|
| makelog = get_path(paths, 'makelog') |
|
|
| if makelog: |
| makelog = norm_path(makelog) |
|
|
| if not (metadata.makelog_started and os.path.isfile(makelog)): |
| raise_from(CritError(messages.crit_error_no_makelog % makelog), None) |
|
|
| with io.open(makelog, 'a', encoding = 'utf8', errors = 'ignore') as MAKELOG: |
| print(message, file = MAKELOG) |
| |
| |
| def log_files_in_output(paths, |
| depth = float('inf')): |
| """.. Log files in output directory. |
| |
| Logs the following information for all files contained in directory ``output_dir``. |
| |
| - File name (in file ``output_statslog``) |
| - Last modified (in file ``output_statslog``) |
| - File size (in file ``output_statslog``) |
| - File head (in file ``output_headslog``, optional) |
| |
| When walking through directory ``output_dir``, float ``depth`` determines level of depth to walk. |
| Status messages are appended to file ``makelog``. |
| |
| Include additional output directories to walk through |
| (typically directories that you wish to keep local) in directory list ``output_local_dir``. |
| |
| Parameters |
| ---------- |
| paths : dict |
| Dictionary of paths. Dictionary should contain values for all keys listed below. |
| depth : float, optional |
| Level of depth when walking through output directory. Defaults to infinite. |
| |
| Path Keys |
| --------- |
| output_dir : str |
| Path of output directory. |
| output_local_dir : str, list, optional |
| Path or list of paths of local output directories. Defaults to ``[]`` (i.e., none). |
| output_statslog : str |
| Path to write output statistics log. |
| output_headslog : str, optional |
| Path to write output headers log. |
| makelog : str |
| Path of makelog. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| The following code will log information for all files contained in |
| only the first level of ``paths['output_dir']``. |
| Therefore, files contained in subdirectories will be ignored. |
| |
| .. code-block:: python |
| |
| log_files_in_outputs(paths, depth = 1) |
| |
| The following code will log information for any file in ``paths['output_dir']``, |
| regardless of level of subdirectory. |
| |
| .. code-block :: python |
| |
| log_files_in_outputs(paths, depth = float('inf')) |
| """ |
| |
| try: |
| output_dir = get_path(paths, 'output_dir') |
| output_local_dir = get_path(paths, 'output_local_dir', throw_error = False) |
| output_statslog = get_path(paths, 'output_statslog') |
| output_headslog = get_path(paths, 'output_headslog', throw_error = False) |
| |
| if output_local_dir: |
| output_local_dir = convert_to_list(output_local_dir, 'dir') |
| else: |
| output_local_dir = [] |
|
|
| output_files = glob_recursive(output_dir, depth) |
| output_local_files = [f for dir_path in output_local_dir for f in glob_recursive(dir_path, depth)] |
| output_files = set(output_files + output_local_files) |
|
|
| if output_statslog: |
| output_statslog = norm_path(output_statslog) |
| _write_stats_log(output_statslog, output_files) |
| |
| if output_headslog: |
| output_headslog = norm_path(output_headslog) |
| _write_heads_log(output_headslog, output_files) |
| |
| message = 'Output logs successfully written!' |
| write_to_makelog(paths, message) |
| print(colored(message, metadata.color_success)) |
| except: |
| error_message = 'Error with `log_files_in_output`. 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 _write_stats_log(statslog_file, output_files): |
| """.. Write statistics log. |
| |
| Logs the following information to ``statslog_file`` for all files contained in list ``output_files``. |
| |
| - File name |
| - Last modified |
| - File size |
| |
| Parameters |
| ---------- |
| statslog_file : str |
| Path to write statistics log. |
| output_files : list |
| List of output files to log statistics. |
| |
| Returns |
| ------- |
| None |
| """ |
|
|
| header = "file name | last modified | file size" |
| |
| with io.open(statslog_file, 'w', encoding = 'utf8', errors = 'ignore') as STATSLOG: |
| print(header, file = STATSLOG) |
|
|
| for file_name in output_files: |
| stats = os.stat(file_name) |
| last_mod = datetime.datetime.utcfromtimestamp(round(stats.st_mtime)) |
| file_size = stats.st_size |
|
|
| print("%s | %s | %s" % (file_name, last_mod, file_size), file = STATSLOG) |
|
|
|
|
| |
| |
| |
|
|
| def _write_heads_log(headslog_file, output_files, num_lines = 10): |
| """.. Write headers log. |
| |
| Logs the following information to ``headslog_file`` for all files contained in file list ``output_files``: |
| |
| Parameters |
| ---------- |
| headslog_file : str |
| Path to write headers log. |
| output_files list |
| List of output files to log headers. |
| num_lines: ``int``, optional |
| Number of lines for headers. Default is ``10``. |
| |
| Returns |
| ------- |
| None |
| """ |
|
|
| header = "File headers" |
|
|
| with io.open(headslog_file, 'w', encoding = 'utf8', errors = 'ignore') as HEADSLOG: |
| print(header, file = HEADSLOG) |
| print(messages.note_dash_line, file = HEADSLOG) |
| |
| for file_name in output_files: |
| print("%s" % file_name, file = HEADSLOG) |
| print(messages.note_dash_line, file = HEADSLOG) |
| |
| try: |
| with io.open(file_name, 'r', encoding = 'utf8', errors = 'ignore') as f: |
| for i in range(num_lines): |
| line = f.readline().rstrip('\n') |
| print(line, file = HEADSLOG) |
| except: |
| print("Head not readable or less than %s lines" % num_lines, file = HEADSLOG) |
| print(messages.note_dash_line, file = HEADSLOG) |
|
|
|
|
| __all__ = ['start_makelog', 'end_makelog', 'write_to_makelog', 'log_files_in_output'] |
