# -*- 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 traceback from termcolor import colored import colorama colorama.init() import gslab_make.private.metadata as metadata from gslab_make.private.exceptionclasses import ColoredError from gslab_make.private.movedirective import MoveList from gslab_make.private.utility import get_path, format_message from gslab_make.write_logs import write_to_makelog def _create_links(paths, file_list): """.. Create symlinks from list of files containing linking instructions. Create symbolic links using instructions contained in files of list ``file_list``. Instructions are `string formatted `__ using paths dictionary ``paths``. Symbolic links are written in directory ``move_dir``. Status messages are appended to file ``makelog``. Parameters ---------- paths : dict Dictionary of paths. Dictionary should contain values for all keys listed below. Dictionary additionally used to string format linking instructions. file_list : str, list File or list of files containing linking instructions. Path Keys --------- move_dir : str Directory to write links. makelog : str Path of makelog. Returns ------- source_map : list List of (source, destination) for each symlink created. """ move_dir = get_path(paths, 'move_dir') move_list = MoveList(file_list, move_dir, paths) if move_list.move_directive_list: os.makedirs(move_dir) source_map = move_list.create_symlinks() else: source_map = [] return(source_map) def _create_copies(paths, file_list): """.. Create copies from list of files containing copying instructions. Create copies using instructions contained in files of list ``file_list``. Instructions are `string formatted `__ using paths dictionary ``paths``. Copies are written in directory ``move_dir``. Status messages are appended to file ``makelog``. Parameters ---------- paths : dict Dictionary of paths. Dictionary should contain values for all keys listed below. Dictionary additionally used to string format copying instructions. file_list : str, list File or list of files containing copying instructions. Path Keys --------- move_dir : str Directory to write copies. makelog : str Path of makelog. Returns ------- source_map : list List of (source, destination) for each copy created. """ move_dir = get_path(paths, 'move_dir') move_list = MoveList(file_list, move_dir, paths) if move_list.move_directive_list: os.makedirs(move_dir) source_map = move_list.create_copies() else: source_map = [] return(source_map) def link_inputs(paths, file_list): """.. Create symlinks to inputs from list of files containing linking instructions. Create symbolic links using instructions contained in files of list ``file_list``. Instructions are `string formatted `__ using paths dictionary ``paths``. Symbolic links are written in directory ``input_dir``. Status messages are appended to file ``makelog``. Instruction files on how to create symbolic links (destinations) from targets (sources) should be formatted in the following way. .. code-block:: md # Each line of instruction should contain a destination and source delimited by a `|` # Lines beginning with # are ignored destination | source .. Note:: Symbolic links can be created to both files and directories. .. Note:: Instruction files can be specified with the * shell pattern (see `here `__). Destinations and their sources can also be specified with the * shell pattern. The number of wildcards must be the same for both destinations and sources. Parameters ---------- paths : dict Dictionary of paths. Dictionary should contain values for all keys listed below. Dictionary additionally used to string format linking instructions. file_list : str, list File or list of files containing linking instructions. Path Keys --------- input_dir : str Directory to write symlinks. makelog : str Path of makelog. Returns ------- source_map : list List of (source, destination) for each symlink created. Example ------- Suppose you call the following function. .. code-block:: python link_inputs(paths, ['file1'], formatting_dict) Suppose ``paths`` contained the following values. .. code-block:: md paths = {'root': '/User/root/', 'makelog': 'make.log', 'input_dir': 'input'} Now suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | {root}/source1 The ``{root}`` in the instruction file would be string formatted using ``paths``. Therefore, the function would parse the instruction as: .. code-block:: md destination1 | /User/root/source1 Example ------- The following code would use instruction files ``file1`` and ``file2`` to create symbolic links. .. code-block:: python link_inputs(paths, ['file1', 'file2']) Suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | source1 destination2 | source2 Symbolic links ``destination1`` and ``destination1`` would be created in directory ``paths['input_dir']``. Their targets would be ``source1`` and ``source2``, respectively. Example ------- Suppose you have the following targets. .. code-block:: md source1 source2 source3 Specifying ``destination* | source*`` in one of your instruction files would create the following symbolic links in ``paths['input_dir']``. .. code-block:: md destination1 destination2 destination3 """ try: paths['move_dir'] = get_path(paths, 'input_dir') source_map = _create_links(paths, file_list) message = 'Input links successfully created!' write_to_makelog(paths, message) print(colored(message, metadata.color_success)) return(source_map) except: error_message = 'An error was encountered with `link_inputs`. 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 link_externals(paths, file_list): """.. Create symlinks to externals from list of files containing linking instructions. Create symbolic links using instructions contained in files of list ``file_list``. Instructions are `string formatted `__ using paths dictionary ``paths``. Symbolic links are written in directory ``external_dir``. Status messages are appended to file ``makelog``. Instruction files on how to create symbolic links (destinations) from targets (sources) should be formatted in the following way. .. code-block:: md # Each line of instruction should contain a destination and source delimited by a `|` # Lines beginning with # are ignored destination | source .. Note:: Symbolic links can be created to both files and directories. .. Note:: Instruction files can be specified with the * shell pattern (see `here `__). Destinations and their sources can also be specified with the * shell pattern. The number of wildcards must be the same for both destinations and sources. Parameters ---------- paths : dict Dictionary of paths. Dictionary should contain values for all keys listed below. Dictionary additionally used to string format linking instructions. file_list : str, list File or list of files containing linking instructions. Path Keys --------- external_dir : str Directory to write symlinks. makelog : str Path of makelog. Returns ------- source_map : list List of (source, destination) for each symlink created. Example ------- Suppose you call the following function. .. code-block:: python link_externals(paths, ['file1'], formatting_dict) Suppose ``paths`` contained the following values. .. code-block:: md paths = {'root': '/User/root/', 'makelog': 'make.log', 'input_dir': 'input'} Now suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | {root}/source1 The ``{root}`` in the instruction file would be string formatted using ``paths``. Therefore, the function would parse the instruction as: .. code-block:: md destination1 | /User/root/source1 Example ------- The following code would use instruction files ``file1`` and ``file2`` to create symbolic links. .. code-block:: python link_externals(paths, ['file1', 'file2']) Suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | source1 destination2 | source2 Symbolic links ``destination1`` and ``destination1`` would be created in directory ``paths['external_dir']``. Their targets would be ``source1`` and ``source2``, respectively. Example ------- Suppose you have the following targets. .. code-block:: md source1 source2 source3 Specifying ``destination* | source*`` in one of your instruction files would create the following symbolic links in ``paths['external_dir']``. .. code-block:: md destination1 destination2 destination3 """ try: paths['move_dir'] = get_path(paths, 'external_dir') source_map = _create_links(paths, file_list) message = 'External links successfully created!' write_to_makelog(paths, message) print(colored(message, metadata.color_success)) return(source_map) except: error_message = 'An error was encountered with `link_externals`. 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 copy_inputs(paths, file_list): """.. Create copies to inputs from list of files containing copying instructions. Create copies using instructions contained in files of list ``file_list``. Instructions are `string formatted `__ using paths dictionary ``paths``. Copies are written in directory ``input_dir``. Status messages are appended to file ``makelog``. Instruction files on how to create copies (destinations) from targets (sources) should be formatted in the following way. .. code-block:: md # Each line of instruction should contain a destination and source delimited by a `|` # Lines beginning with # are ignored destination | source .. Note:: Instruction files can be specified with the * shell pattern (see `here `__). Destinations and their sources can also be specified with the * shell pattern. The number of wildcards must be the same for both destinations and sources. Parameters ---------- paths : dict Dictionary of paths. Dictionary should contain values for all keys listed below. Dictionary additionally used to string format copying instructions. file_list : str, list File or list of files containing copying instructions. Path Keys --------- input_dir : str Directory to write copies. makelog : str Path of makelog. Returns ------- source_map : list List of (source, destination) for each copy created. Example ------- Suppose you call the following function. .. code-block:: python copy_inputs(paths, ['file1'], formatting_dict) Suppose ``paths`` contained the following values. .. code-block:: md paths = {'root': '/User/root/', 'makelog': 'make.log', 'input_dir': 'input'} Now suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | {root}/source1 The ``{root}`` in the instruction file would be string formatted using ``paths``. Therefore, the function would parse the instruction as: .. code-block:: md destination1 | /User/root/source1 Example ------- The following code would use instruction files ``file1`` and ``file2`` to create copies. .. code-block:: python copy_inputs(paths, ['file1', 'file2']) Suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | source1 destination2 | source2 Copies ``destination1`` and ``destination1`` would be created in directory ``paths['input_dir']``. Their targets would be ``source1`` and ``source2``, respectively. Example ------- Suppose you have the following targets. .. code-block:: md source1 source2 source3 Specifying ``destination* | source*`` in one of your instruction files would create the following copies in ``paths['input_dir']``. .. code-block:: md destination1 destination2 destination3 """ try: paths['move_dir'] = get_path(paths, 'input_dir') source_map = _create_copies(paths, file_list) message = 'Input copies successfully created!' write_to_makelog(paths, message) print(colored(message, metadata.color_success)) return(source_map) except: error_message = 'An error was encountered with `copy_inputs`. 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 copy_externals(paths, file_list): """.. Create copies to externals from list of files containing copying instructions. Create copies using instructions contained in files of list ``file_list``. Instructions are `string formatted `__ using paths dictionary ``paths``. Copies are written in directory ``external_dir``. Status messages are appended to file ``makelog``. Instruction files on how to create copies (destinations) from targets (sources) should be formatted in the following way. .. code-block:: md # Each line of instruction should contain a destination and source delimited by a `|` # Lines beginning with # are ignored destination | source .. Note:: Instruction files can be specified with the * shell pattern (see `here `__). Destinations and their sources can also be specified with the * shell pattern. The number of wildcards must be the same for both destinations and sources. Parameters ---------- paths : dict Dictionary of paths. Dictionary should contain values for all keys listed below. Dictionary additionally used to string format copying instructions. file_list : str, list File or list of files containing copying instructions. Path Keys --------- external_dir : str Directory to write copies. makelog : str Path of makelog. Returns ------- source_map : list List of (source, destination) for each copy created. Example ------- Suppose you call the following function. .. code-block:: python copy_externals(paths, ['file1'], formatting_dict) Suppose ``paths`` contained the following values. .. code-block:: md paths = {'root': '/User/root/', 'makelog': 'make.log', 'input_dir': 'input'} Now suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | {root}/source1 The ``{root}`` in the instruction file would be string formatted using ``paths``. Therefore, the function would parse the instruction as: .. code-block:: md destination1 | /User/root/source1 Example ------- The following code would use instruction files ``file1`` and ``file2`` to create copies. .. code-block:: python copy_externals(paths, ['file1', 'file2']) Suppose instruction file ``file1`` contained the following text. .. code-block:: md destination1 | source1 destination2 | source2 Copies ``destination1`` and ``destination1`` would be created in directory ``paths['external_dir']``. Their targets would be ``source1`` and ``source2``, respectively. Example ------- Suppose you have the following targets. .. code-block:: md source1 source2 source3 Specifying ``destination* | source*`` in one of your instruction files would create the following copies in ``paths['external_dir']``. .. code-block:: md destination1 destination2 destination3 """ try: paths['move_dir'] = get_path(paths, 'external_dir') source_map = _create_copies(paths, file_list) message = 'External copies successfully created!' write_to_makelog(paths, message) print(colored(message, metadata.color_success)) return(source_map) except: error_message = 'An error was encountered with `copy_externals`. 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) __all__ = ['link_inputs', 'link_externals', 'copy_inputs', 'copy_externals']