| ''' | |
| ################################################################# | |
| # 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. | |
| ''' | |