| |
| 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 io |
| import sys |
| import glob |
| import yaml |
| import codecs |
| import filecmp |
| import traceback |
|
|
| import gslab_make.private.messages as messages |
| from gslab_make.private.exceptionclasses import CritError |
|
|
|
|
| def decode(string): |
| """Decode string.""" |
|
|
| if (sys.version_info < (3, 0)) and isinstance(string, string_types): |
| string = codecs.decode(string, 'latin1') |
|
|
| return(string) |
|
|
|
|
| def encode(string): |
| """Clean string for encoding.""" |
|
|
| if (sys.version_info < (3, 0)) and isinstance(string, unicode): |
| string = codecs.encode(string, 'utf-8') |
|
|
| return(string) |
|
|
|
|
| def convert_to_list(obj, warning_type): |
| """Convert object to list.""" |
| |
| obj = [obj] if isinstance(obj, string_types) else obj |
| |
| if type(obj) is not list: |
| if (warning_type == 'dir'): |
| raise_from(TypeError(messages.type_error_dir_list % obj), None) |
| elif (warning_type == 'file'): |
| raise_from(TypeError(messages.type_error_file_list % obj), None) |
|
|
| return(obj) |
|
|
|
|
| def norm_path(path): |
| """Normalize path to be OS-compatible.""" |
|
|
| if path: |
| path = re.split('[/\\\\]+', path) |
| path = os.path.sep.join(path) |
| path = os.path.expanduser(path) |
| path = os.path.abspath(path) |
|
|
| return(path) |
|
|
|
|
| def get_path(paths_dict, key, throw_error = True): |
| """Get path for key. |
| |
| Parameters |
| ---------- |
| path_dict : dict |
| Dictionary of paths. |
| key : str |
| Path to get from dictionary. |
| throw_error : bool |
| Return error instead of ``None``. Defaults to ``True``. |
| |
| Returns |
| ------- |
| path : str |
| Path requested. |
| """ |
| |
| try: |
| path = paths_dict[key] |
| if isinstance(path, string_types): |
| path = norm_path(path) |
| elif isinstance(path, list): |
| path = [norm_path(p) for p in path] |
| except KeyError: |
| if throw_error: |
| raise_from(CritError(messages.crit_error_no_key % (key, key)), None) |
| else: |
| path = None |
|
|
| return(path) |
|
|
|
|
| def glob_recursive(path, depth, max_depth = 20, quiet = True): |
| """Walks through path. |
| |
| Notes |
| ----- |
| Takes glob-style wildcards. |
| |
| Parameters |
| ---------- |
| path : str |
| Path to walk through. |
| depth : int |
| Level of depth when walking through path. |
| max_depth : int |
| Maximum level of depth allowed. Defaults to 20. |
| quiet : bool, optional |
| Suppress warning if no files globbed. Defaults to ``True``. |
| |
| Returns |
| ------- |
| path_files : list |
| List of files contained in path. |
| """ |
|
|
| depth = max_depth if depth > max_depth else depth |
| path_walk = norm_path(path) |
| path_files = glob.glob(path_walk) |
|
|
| i = 0 |
| while i <= depth: |
| path_walk = os.path.join(path_walk, "*") |
| glob_files = glob.glob(path_walk) |
| if glob_files: |
| path_files.extend(glob_files) |
| i += 1 |
| else: |
| break |
|
|
| path_files = [p for p in path_files if os.path.isfile(p)] |
| if not path_files and not quiet: |
| print(messages.warning_glob % (path, depth)) |
|
|
| return(path_files) |
|
|
| |
| def file_to_array(file_name): |
| """Read file and extract lines to list. |
| |
| Parameters |
| ---------- |
| file_name : str |
| Path of file to read. |
| |
| Returns |
| ------- |
| array : list |
| List of lines contained in file. |
| """ |
| |
| with io.open(file_name, encoding = 'utf-8') as f: |
| array = [line.strip() for line in f] |
| array = [line for line in array if line] |
| array = [line for line in array if not re.match('\#',line)] |
|
|
| return(array) |
|
|
|
|
| def format_traceback(trace = ''): |
| """Format traceback message. |
| |
| Parameters |
| ---------- |
| trace : str |
| Traceback to format. Defaults to ``traceback.format_exc``. |
| |
| Notes |
| ----- |
| Format trackback for readability to pass into user messages. |
| |
| Returns |
| ------- |
| formatted : str |
| Formatted traceback. |
| """ |
| |
| if not trace: |
| trace = traceback.format_exc() |
|
|
| trace = trace.strip() |
| trace = '\n' + decode(trace) |
| formatted = re.sub('\n', '\n > ', trace) |
|
|
| return(formatted) |
|
|
|
|
| def format_message(message): |
| """Format message.""" |
|
|
| message = message.strip() |
| star_line = '*' * (len(message) + 4) |
| formatted = star_line + '\n* %s *\n' + star_line |
| formatted = formatted % message |
|
|
| return(formatted) |
|
|
|
|
| def format_list(list): |
| """Format list. |
| |
| Parameters |
| ---------- |
| list : list |
| List to format. |
| |
| Notes |
| ----- |
| Format list for readability to pass into user messages. |
| |
| Returns |
| ------- |
| formatted : str |
| Formatted list. |
| """ |
|
|
| formatted = ['`' + str(item) + '`' for item in list] |
| formatted = ", ".join(formatted) |
| |
| return(formatted) |
|
|
|
|
| def open_yaml(path): |
| """Safely loads YAML file.""" |
|
|
| path = norm_path(path) |
|
|
| with io.open(path, 'r') as f: |
| stream = yaml.safe_load(f) |
|
|
| return(stream) |
|
|
|
|
| |
| |
| |
| |
| def check_duplicate(original, copy): |
| """Check duplicate. |
| |
| Parameters |
| ---------- |
| original : str |
| Original path. |
| copy : str |
| Path to check if duplicate. |
| |
| Returns |
| ------- |
| duplicate : bool |
| Destination is duplicate. |
| """ |
|
|
| duplicate = os.path.exists(copy) |
| |
| if duplicate: |
| if os.path.isfile(original): |
| duplicate = filecmp.cmp(original, copy) |
| elif os.path.isdir(copy): |
| dircmp = filecmp.dircmp(original, copy, ignore = ['.DS_Store']) |
| duplicate = parse_dircmp(dircmp) |
| else: |
| duplicate = False |
| |
| return(duplicate) |
| |
|
|
| def parse_dircmp(dircmp): |
| """Parse dircmp to see if directories duplicate. |
| |
| Parameters |
| ---------- |
| dircmp : ``filecmp.dircmp`` |
| dircmp to parse if directories duplicate. |
| |
| Returns |
| ------- |
| duplicate : bool |
| Directories are duplicates. |
| """ |
|
|
| |
| if dircmp.left_only: |
| return False |
| if dircmp.right_only: |
| return False |
| if dircmp.diff_files: |
| return False |
| if dircmp.funny_files: |
| return False |
| if dircmp.common_funny: |
| return False |
|
|
| |
| duplicate = True |
| |
| for subdir in dircmp.subdirs.itervalues(): |
| if duplicate: |
| duplicate = check_duplicate(subdir) |
| else: |
| break |
| |
| return(duplicate) |
