| |
| 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 io |
| import re |
| import traceback |
| from itertools import chain |
|
|
| import gslab_make.private.messages as messages |
| from gslab_make.private.exceptionclasses import CritError, ColoredError |
| from gslab_make.private.utility import convert_to_list, norm_path, format_message |
|
|
|
|
| def _parse_tag(tag): |
| """.. Parse tag from input.""" |
|
|
| if not re.match('<Tab:(.*)>\n', tag, flags = re.IGNORECASE): |
| raise Exception |
| else: |
| tag = re.sub('<Tab:(.*?)>\n', r'\g<1>', tag, flags = re.IGNORECASE) |
| tag = tag.lower() |
| |
| return(tag) |
| |
| |
| def _parse_data(data, null): |
| """.. Parse data from input. |
| |
| Parameters |
| ---------- |
| data : list |
| Input data to parse. |
| null : str |
| String to replace null characters. |
| |
| Returns |
| ------- |
| data : list |
| List of data values from input. |
| """ |
| null_strings = ['', '.', 'NA'] |
| |
| data = [row.rstrip('\r\n') for row in data] |
| data = [row for row in data if row] |
| data = [row.split('\t') for row in data] |
| data = chain(*data) |
| data = list(data) |
| data = [null if value in null_strings else value for value in data] |
| |
| return(data) |
| |
| |
| def _parse_content(file, null): |
| """.. Parse content from input.""" |
| |
| with io.open(file, 'r', encoding = 'utf-8') as f: |
| content = f.readlines() |
| try: |
| tag = _parse_tag(content[0]) |
| except: |
| raise_from(CritError(messages.crit_error_no_tag % file), None) |
| data = _parse_data(content[1:], null) |
| |
| return(tag, data) |
| |
| |
| def _insert_value(line, value, type, null): |
| """.. Insert value into line. |
| |
| Parameters |
| ---------- |
| line : str |
| Line of document to insert value. |
| value : str |
| Value to insert. |
| type : str |
| Formatting for value. |
| |
| Returns |
| ------- |
| line : str |
| Line of document with inserted value. |
| """ |
| |
| if (type == 'no change'): |
| line = re.sub('\\\\?#\\\\?#\\\\?#', value, line) |
| |
| elif (type == 'round'): |
| if value == null: |
| line = re.sub('(.*?)\\\\?#[0-9]+\\\\?#', r'\g<1>' + value, line) |
| else: |
| try: |
| value = float(value) |
| except: |
| raise_from(CritError(messages.crit_error_not_float % value), None) |
| digits = re.findall('\\\\?#([0-9]+)\\\\?#', line)[0] |
| rounded_value = format(value, '.%sf' % digits) |
| line = re.sub('(.*?)\\\\?#[0-9]+\\\\?#', r'\g<1>' + rounded_value, line) |
| |
| elif (type == 'comma + round'): |
| if value == null: |
| line = re.sub('(.*?)\\\\?#[0-9]+,\\\\?#', r'\g<1>' + value, line) |
| else: |
| try: |
| value = float(value) |
| except: |
| raise_from(CritError(messages.crit_error_not_float % value), None) |
| digits = re.findall('\\\\?#([0-9]+),\\\\?#', line)[0] |
| rounded_value = format(value, ',.%sf' % digits) |
| line = re.sub('(.*?)\\\\?#[0-9]+,\\\\?#', r'\g<1>' + rounded_value, line) |
|
|
| return(line) |
|
|
|
|
| def _insert_tables_lyx(template, tables, null): |
| """.. Fill tables for LyX template. |
| |
| Parameters |
| ---------- |
| template : str |
| Path of LyX template to fill. |
| tables : dict |
| Dictionary ``{tag: values}`` of tables. |
| |
| Returns |
| ------- |
| template : str |
| Filled LyX template. |
| """ |
|
|
| with io.open(template, 'r', encoding = 'utf-8') as f: |
| doc = f.readlines() |
| |
| is_table = False |
|
|
| for i in range(len(doc)): |
| |
| if not is_table and re.match('name "tab:', doc[i]): |
| tag = doc[i].replace('name "tab:','').rstrip('"\n').lower() |
| try: |
| values = tables[tag] |
| entry_count = 0 |
| is_table = True |
| except KeyError: |
| raise_from(CritError(messages.crit_error_no_input_table % tag), None) |
|
|
| |
| if is_table: |
| try: |
| if re.match('.*###', doc[i]): |
| doc[i] = _insert_value(doc[i], values[entry_count], 'no change', null) |
| entry_count += 1 |
| elif re.match('.*#[0-9]+#', doc[i]): |
| doc[i] = _insert_value(doc[i], values[entry_count], 'round', null) |
| entry_count += 1 |
| elif re.match('.*#[0-9]+,#', doc[i]): |
| doc[i] = _insert_value(doc[i], values[entry_count], 'comma + round', null) |
| entry_count += 1 |
| elif re.match('</lyxtabular>', doc[i]): |
| is_table = False |
| if entry_count != len(values): |
| raise_from(CritError(messages.crit_error_too_many_values % tag), None) |
| except IndexError: |
| raise_from(CritError(messages.crit_error_not_enough_values % tag), None) |
| |
| doc = '\n'.join(doc) |
| |
| return(doc) |
|
|
|
|
| def _insert_tables_latex(template, tables, null): |
| """.. Fill tables for LaTeX template. |
| |
| Parameters |
| ---------- |
| template : str |
| Path of LaTeX template to fill. |
| tables : dict |
| Dictionary ``{tag: values}`` of tables. |
| |
| Returns |
| ------- |
| template : str |
| Filled LaTeX template. |
| """ |
|
|
| with io.open(template, 'r', encoding = 'utf-8') as f: |
| doc = f.readlines() |
|
|
| is_table = False |
|
|
| for i in range(len(doc)): |
| |
| if not is_table and re.search('label\{tab:', doc[i]): |
| tag = doc[i].split(':')[1].rstrip('}\n').strip('"').lower() |
| try: |
| values = tables[tag] |
| entry_count = 0 |
| is_table = True |
| except KeyError: |
| raise_from(CritError(messages.crit_error_no_input_table % tag), None) |
|
|
| |
| if is_table: |
| try: |
| line = doc[i].split("&") |
| |
| for j in range(len(line)): |
| if re.search('.*\\\\#\\\\#\\\\#', line[j]): |
| line[j] = _insert_value(line[j], values[entry_count], 'no change', null) |
| entry_count += 1 |
| elif re.search('.*\\\\#[0-9]+\\\\#', line[j]): |
| line[j] = _insert_value(line[j], values[entry_count], 'round', null) |
| entry_count += 1 |
| elif re.search('.*\\\\#[0-9]+,\\\\#', line[j]): |
| line[j] = _insert_value(line[j], values[entry_count], 'comma + round', null) |
| entry_count += 1 |
| |
| doc[i] = "&".join(line) |
| |
| if re.search('end\{tabular\}', doc[i], flags = re.IGNORECASE): |
| is_table = False |
| if entry_count != len(values): |
| raise_from(CritError(messages.crit_error_too_many_values % tag), None) |
| except IndexError: |
| raise_from(CritError(messages.crit_error_not_enough_values % tag), None) |
|
|
| doc = '\n'.join(doc) |
|
|
| return(doc) |
|
|
|
|
| def _insert_tables(template, tables, null): |
| """.. Fill tables for template. |
| |
| Parameters |
| ---------- |
| template : str |
| Path of template to fill. |
| tables : dict |
| Dictionary ``{tag: values}`` of tables. |
| |
| Returns |
| ------- |
| template : str |
| Filled template. |
| """ |
| |
| template = norm_path(template) |
|
|
| if re.search('\.lyx', template): |
| doc = _insert_tables_lyx(template, tables, null) |
| elif re.search('\.tex', template): |
| doc = _insert_tables_latex(template, tables, null) |
|
|
| return(doc) |
|
|
|
|
| def tablefill(inputs, template, output, null = '.'): |
| """.. Fill tables for template using inputs. |
| |
| Fills tables in document ``template`` using files in list ``inputs``. |
| Writes filled document to file ``output``. |
| Null characters in ``inputs`` are replaced with value ``null``. |
| |
| Parameters |
| ---------- |
| inputs : list |
| Input or list of inputs to fill into template. |
| template : str |
| Path of template to fill. |
| output : str |
| Path of output. |
| null : str |
| Value to replace null characters (i.e., ``''``, ``'.'``, ``'NA'``). Defaults to ``'.'``. |
| |
| Returns |
| ------- |
| None |
| |
| Example |
| ------- |
| |
| .. code-block:: |
| |
| ################################################################# |
| # tablefill_readme.txt - Help/Documentation for tablefill.py |
| ################################################################# |
| |
| Description: |
| tablefill.py is a Python module designed to fill LyX/Tex tables with output |
| from text files (usually output from Stata or Matlab). |
| |
| Usage: |
| Tablefill takes as input a LyX (or Tex) file containing empty tables (the template |
| file) and text files containing data to be copied to these tables (the |
| input files), and produces a LyX (or Tex) file with filled tables (the output file). |
| For brevity, LyX will be used to denote LyX or Tex files throughout. |
| |
| Tablefill must first be imported to make.py. This is typically achieved |
| by including the following lines: |
| |
| ``` |
| from gslab_fill.tablefill import tablefill |
| ``` |
| |
| Once the module has been imported, the syntax used to call tablefill is |
| as follows: |
| |
| ``` |
| tablefill(input = 'input_file(s)', template = 'template_file', |
| output = 'output_file') |
| ``` |
| |
| The argument 'template' is the user written LyX file which contains the |
| tables to be filled in. The argument 'input' is a list of the text files |
| containing the output to be copied to the LyX tables. If there are multiple |
| input text files, they are listed as: input = 'input_file_1 input_file_2'. |
| The argument 'output' is the name of the filled LyX file to be produced. |
| Note that this file is created by tablefill.py and should not be edited |
| manually by the user. |
| |
| ########################### |
| Input File Format: |
| ########################### |
| |
| The data needs to be tab-delimited rows of numbers (or characters), |
| preceeded by `<label>`. The < and > are mandatory. The numbers can be |
| arbitrarily long, can be negative, and can also be in scientific notation. |
| |
| Examples: |
| ---------- |
| |
| ``` |
| <tab:Test> |
| 1 2 3 |
| 2 3 1 |
| 3 1 2 |
| ``` |
| |
| ``` |
| <tab:FunnyMat> |
| 1 2 3 23 2 |
| 2 3 |
| 3 1 2 2 |
| 1 |
| ``` |
| (The rows do not need to be of equal length.) |
| |
| Completely blank (no tab) lines are ignored. |
| If a "cell" is merely "." or "[space]", then it is treated as completely |
| missing. That is, in the program: |
| |
| ``` |
| <tab:Test> |
| 1 2 3 |
| 2 . 1 3 |
| 3 1 2 |
| ``` |
| |
| is equivalent to: |
| ``` |
| <tab:Test> |
| 1 2 3 |
| 2 1 3 |
| 3 1 2 |
| ``` |
| |
| This feature is useful as Stata outputs missing values in numerical |
| variables as ".", and missing values in string variables as "[space]". |
| |
| ................................ |
| Scientific Notation Notes: |
| ................................ |
| The scientific notation ihas to be of the form: |
| [numbers].[numbers]e(+/-)[numbers] |
| |
| Examples: |
| ``` |
| 23.2389e+23 |
| -2.23e-2 |
| -0.922e+3 |
| ``` |
| |
| ########################### |
| Template LyX Format: |
| ########################### |
| |
| The LyX template file determines where the numbers from the input files are placed. |
| |
| Every table in the template file (if it is to be filled) must appear within a float. |
| There must be one, and only one, table object inside the float, and the table name |
| must include a label object that corresponds to the label of the required table in |
| the input file. |
| |
| Note that table names cannot be duplicated. For a single template file, each table |
| to be filled must have a unique label, and there must be one, and only one, table with |
| that same label in the text files used as input. Having multiple tables with the |
| same name in the input files or in the template file will cause errors. |
| |
| Note also that labels are NOT case-sensitive. That is, <TAB:Table1> is considered |
| the same as `<tab:table1>`. |
| |
| In the LyX tables, "cells" to be filled with entries from the input text files are |
| indicated by the following tags: |
| |
| `"###" (no quotes)` |
| or |
| `"#[number][,]#" (no quotes)` |
| |
| The first case will result in a literal substitution. I.e. whatever is in the text |
| tables for that cell will be copied over. The second case will convert the data |
| table's number (if in scientific notation) and will truncate this converted number |
| to [number] decimal places. It will automatically round while doing so. |
| |
| If a comma appears after the number (within #[number]#), then it will add commas |
| to the digits to the left of the decimal place. |
| |
| Examples: |
| --------- |
| ``` |
| 2309.2093 + ### = 2309.2093 |
| 2309.2093 + #4# = 2309.2093 |
| 2309.2093 + #5# = 2309.20930 |
| 2309.2093 + #20# = 2309.20930000000000000000 |
| 2309.2093 + #3# = 2309.209 |
| 2309.2093 + #2# = 2309.21 |
| 2309.2093 + #0# = 2309 |
| 2309.2093 + #0,# = 2,309 |
| ``` |
| |
| ``` |
| -2.23e-2 + #2# = -0.0223 + #2# = -0.02 |
| -2.23e-2 + #7# = -0.0223 + #7# = -0.0223000 |
| -2.23e+10 + #7,# = -22300000000 + #7,# = -22,300,000,000.000000 |
| ``` |
| |
| Furthermore, only ###/#num# will be replaced, allowing you to put things around |
| ###/#num# to alter the final output: |
| |
| Examples: |
| -------- |
| |
| ``` |
| 2309.2093 + (#2#) = (2309.21) |
| 2309.2093 + #2#** = 2309.21** |
| 2309.2093 + ab#2#cd = ab2309.21cd |
| ``` |
| |
| If you are doing exact substitution, then you can use characters: |
| |
| Examples: |
| --------- |
| `abc + ### = abc` |
| |
| ................................ |
| Intentionally blank cells: |
| ................................ |
| |
| If you would like to display a blank cell, you can use "---": |
| |
| Examples: |
| --------- |
| ``` |
| --- + ### = --- |
| --- + #3# = --- |
| ``` |
| |
| ###################### |
| # Example Combinations |
| # Of input + template |
| ###################### |
| |
| |
| Example 1 (Simple) |
| ---------- |
| ``` |
| Input: <tab:Test> |
| 1 2 3 |
| 2 1 3 |
| 3 1 2 |
| |
| Template: `<tab:Test> ` (pretend this is what you see in LyX) |
| |
| ### ### ### |
| ### ### ### |
| ### ### ### |
| |
| Result:<tab:Test> |
| 1 2 3 |
| 2 1 3 |
| 3 1 2 |
| ``` |
| |
| Example 2 (More Complicated) |
| ---------- |
| ``` |
| Input: <tab:Test> |
| 1 . 3 |
| 2e-5 1 3.023 |
| . -1 2 3 |
| |
| Template: <tab:Test> (pretend this is what you see in LyX) |
| (###) 2 ### |
| #3# ### #1# |
| NA ### ### ### |
| |
| Result:<tab:Test> |
| (1) 2 3 |
| 0.000 1 3.0 |
| NA -1 2 3 |
| ``` |
| |
| =================== |
| ====Important====== |
| =================== |
| By design, missings in input table and "missings" in template do not have to |
| line up. |
| |
| Example 3 (LyX) |
| ---------- |
| ``` |
| Input: <tab:Test> |
| 1 . 3 |
| 2e-5 . 3.023 |
| . -1 2 |
| |
| Template: <tab:Test> |
| ### ### abc |
| abc #2# #3# |
| NA ### ### |
| |
| Result:<tab:Test> |
| 1 3 abc |
| abc 0.00 3.023 |
| NA -1 2 |
| |
| Recall that to the program, the above input table is no different from: |
| 1 3 |
| 2e-5 3.023 |
| -1 2 |
| ``` |
| |
| It doesn't "know" where the numbers should be placed within a row, only what |
| the next number to place should be. |
| |
| Similarly: |
| |
| Example 4 (LyX) |
| ---------- |
| ``` |
| Input: <tab:Test> |
| 1 1 2 |
| 1 1 3 |
| 2 -1 2 |
| |
| Template: <tab:Test> |
| ### ### ### |
| abc abc abc |
| ### #2# #3# |
| ### ### ### |
| |
| Result:<tab:Test> |
| 1 1 2 |
| abc abc abc |
| 1 1.00 3.000 |
| 2 -1 2 |
| ``` |
| |
| If a row in the template has no substitutions, then it's not really a row from |
| the program's point of view. |
| |
| |
| ###################### |
| # Error Logging |
| ###################### |
| |
| If an error occurs during the call to tablefill, it will be displayed in the |
| command window. When make.py finishes, the user will be able to scroll up |
| through the output and examine any error messages. Error messages, which |
| include a description of the error type and a traceback to the line of code |
| where the error occured, can also be retuned as a string object using the |
| following syntax: |
| |
| exitmessage = tablefill( input = 'input_file(s)', template = 'template_file', |
| output = 'output_file' ) |
| |
| Lines can then be added to make.py to output this string to a log file using |
| standard Python and built in gslab_make commands. |
| |
| |
| ###################### |
| # Common Errors |
| ###################### |
| |
| Common mistakes which can lead to errors include: |
| |
| - Mismatch between the length of the LyX table and the corresponding text table. |
| If the LyX table has more entries to be filled than the text table has entries to |
| fill from, this will cause an error and the table will not be filled. |
| |
| - Use of numerical tags (e.g. #1#) to fill non-numerical data. This will cause |
| an error. Non-numerical data can only be filled using "###", as it does not make |
| sense to round or truncate this data. |
| |
| - Multiple table objects in the same float. Each table float in the template LyX |
| file can only contain one table object. If a float contains a second table object, |
| this table will not be filled. |
| |
| |
| ###################### |
| # Boldfacing entries |
| ###################### |
| |
| It is straightforward to develop functions that conditionally write entries of |
| tables in boldface; functions may do so by inserting '\series bold' in the lines |
| of the filled LyX file immeadiately before phrases that the user wishes to make bold. |
| """ |
|
|
| try: |
| inputs = convert_to_list(inputs, 'file') |
| inputs = [norm_path(file) for file in inputs] |
| content = [_parse_content(file, null) for file in inputs] |
| tables = {tag:data for (tag, data) in content} |
| if (len(content) != len(tables)): |
| raise_from(CritError(messages.crit_error_duplicate_tables), None) |
|
|
| doc = _insert_tables(template, tables, null) |
|
|
| with io.open(output, 'w', encoding = 'utf-8') as f: |
| f.write(doc) |
| except: |
| error_message = 'Error with `tablefill`. Traceback can be found below.' |
| error_message = format_message(error_message) |
| raise_from(ColoredError(error_message, traceback.format_exc()), None) |
|
|
|
|
| __all__ = ['tablefill'] |
