| |
| 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 <https://docs.python.org/3.4/library/string.html#format-string-syntax>`__ |
| 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 <https://docs.python.org/3.4/library/string.html#format-string-syntax>`__ |
| 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 <https://docs.python.org/3.4/library/string.html#format-string-syntax>`__ |
| 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 <https://www.gnu.org/software/findutils/manual/html_node/find_html/Shell-Pattern-Matching.html>`__). |
| 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 <https://docs.python.org/3.4/library/string.html#format-string-syntax>`__ |
| 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 <https://www.gnu.org/software/findutils/manual/html_node/find_html/Shell-Pattern-Matching.html>`__). |
| 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 <https://docs.python.org/3.4/library/string.html#format-string-syntax>`__ |
| 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 <https://www.gnu.org/software/findutils/manual/html_node/find_html/Shell-Pattern-Matching.html>`__). |
| 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 <https://docs.python.org/3.4/library/string.html#format-string-syntax>`__ |
| 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 <https://www.gnu.org/software/findutils/manual/html_node/find_html/Shell-Pattern-Matching.html>`__). |
| 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'] |
