https://github.com/janfasnacht/tabwrap
Wrap LaTeX table fragments into complete documents for research workflows
https://github.com/janfasnacht/tabwrap
academic latex research statistics tables
Last synced: about 1 month ago
JSON representation
Wrap LaTeX table fragments into complete documents for research workflows
- Host: GitHub
- URL: https://github.com/janfasnacht/tabwrap
- Owner: janfasnacht
- License: mit
- Created: 2025-05-05T02:35:19.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2026-05-05T09:32:41.000Z (about 2 months ago)
- Last Synced: 2026-05-05T10:11:39.221Z (about 2 months ago)
- Topics: academic, latex, research, statistics, tables
- Language: Python
- Homepage: https://pypi.org/project/tabwrap/
- Size: 267 KB
- Stars: 0
- Watchers: 1
- Forks: 1
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# tabwrap
[](https://pypi.org/project/tabwrap/)
[](https://pypi.org/project/tabwrap/)
[](https://opensource.org/licenses/MIT)
**Wrap LaTeX table fragments into complete documents for research workflows**
A simple Python tool that transforms statistical programming output (LaTeX table fragments) into compiled PDFs, PNGs, or SVGs. Perfect for researchers who need to quickly inspect, share, and explore tables from Stata, R, Python, and other statistical tools.
**Web Interface**: [tabwrap.janfasnacht.com](https://tabwrap.janfasnacht.com)
## What it does
`tabwrap` takes incomplete LaTeX table fragments like this:
```latex
\begin{tabular}{lcr}
\toprule
Variable & Coefficient & P-value \\
\midrule
Intercept & 1.23 & 0.045 \\
\bottomrule
\end{tabular}
```
And automatically wraps them into complete, compilable LaTeX documents with:
- Auto-detected packages (booktabs, tabularx, siunitx, etc.)
- Proper document structure and preambles
- Auto-fit page sized to the table
- Multi-file batch processing with error recovery
- Combined PDFs with table of contents
- PNG output with automatic cropping, SVG support
- Enhanced error reporting with suggestions
## Quick Start
### Prerequisites
**LaTeX Distribution Required:** tabwrap needs a LaTeX installation to compile documents.
- **Windows**: [MiKTeX](https://miktex.org/download) or [TeX Live](https://tug.org/texlive/)
- **macOS**: [MacTeX](https://tug.org/mactex/) or `brew install --cask mactex`
- **Linux**: `sudo apt-get install texlive-full` or equivalent
**Optional for PNG output**: [ImageMagick](https://imagemagick.org/script/download.php)
### Installation
#### Recommended (CLI tools):
```bash
pipx install tabwrap
```
#### Standard Python installation:
```bash
pip install tabwrap
```
#### With API support:
```bash
pip install tabwrap[api]
```
### Basic Usage
```bash
# Compile a single table
tabwrap regression_table.tex
# Process all tables in a folder
tabwrap ./results_tables/
# Output PNG
tabwrap table.tex -p
# Batch process with combined PDF
tabwrap ./tables/ -r -c # recursive + combine PDFs
# Show filename headers and keep intermediate files
tabwrap data/ --header --keep-tex
```
## Features
### Error Handling
```
⚠️ 1 of 3 files failed to compile:
📋 Failed files:
• bad_table.tex
Invalid tabular content: No tabular environment found
✅ Successfully compiled: table1.tex, table2.tex
```
### Smart Package Detection
Automatically detects and includes required packages:
- `booktabs` for \\toprule, \\midrule, \\bottomrule
- `tabularx` for \\begin{tabularx}
- `siunitx` for \\SI{}{}, \\num{}
- `multirow` for \\multirow
- And many more...
For commands that need a `\newcommand` rather than a package, tabwrap injects
the definition directly. For example, `\sym{**}` from Stata's `esttab` gets a
matching `\newcommand{\sym}` in the preamble. Use `--preamble` for arbitrary
preamble lines outside the curated rule set.
### Flexible Output Options
```bash
# Output formats
tabwrap table.tex # PDF output (default)
tabwrap table.tex -p # PNG output with auto-cropping
tabwrap table.tex --svg # SVG output (vector graphics)
# Batch processing
tabwrap folder/ -r # Process subdirectories recursively
tabwrap folder/ -j # Parallel processing (4-6x faster)
tabwrap folder/ -c # Combine into single PDF with TOC
# Layout and formatting
tabwrap table.tex --header # Show filename as header
```
### Shell Completion
tabwrap supports shell completion for bash, zsh, and fish:
```bash
# Bash - add to ~/.bashrc
tabwrap --completion bash >> ~/.bashrc
# Zsh - add to ~/.zshrc
tabwrap --completion zsh >> ~/.zshrc
# Fish - save to completions directory
tabwrap --completion fish > ~/.config/fish/completions/tabwrap.fish
```
## CLI Reference
```
Usage: tabwrap [OPTIONS] [INPUT_PATH]
Arguments:
INPUT_PATH .tex file or directory to process [default: current directory]
Output Options:
-o, --output PATH Output directory [default: current directory]
--suffix TEXT Output filename suffix [default: _compiled]
-p, --png Output PNG instead of PDF
--svg Output SVG instead of PDF
Processing Options:
-r, --recursive Process subdirectories recursively
-j, --parallel Process files in parallel for faster batch compilation
--max-workers INTEGER Maximum number of parallel workers [default: CPU cores]
-c, --combine Combine multiple PDFs with table of contents
Formatting Options:
--header Show filename as header in output
--packages TEXT Comma-separated LaTeX packages (auto-detected if empty)
--preamble TEXT Extra preamble lines (e.g. \newcommand) inserted verbatim after \usepackage
Advanced Options:
--keep-tex Keep generated LaTeX files and compilation logs for debugging
--completion [bash|zsh|fish] Generate shell completion script
--help Show this message and exit
```
### Common Usage Patterns
```bash
# Basic compilation
tabwrap table.tex # PDF output
tabwrap table.tex -p # PNG output
tabwrap table.tex --svg # SVG output
# Batch processing
tabwrap folder/ # All .tex files in folder
tabwrap folder/ -r # Include subdirectories
tabwrap folder/ -j # Parallel processing (faster)
tabwrap folder/ -c # Combined PDF with TOC
# Formatting options
tabwrap table.tex --header # Show filename header
tabwrap table.tex --preamble '\newcommand{\sig}[1]{\textbf{#1}}' # Inject preamble lines (e.g. custom \newcommand)
# Output control
tabwrap table.tex -o output/ # Custom output directory
tabwrap table.tex --suffix _final # Custom filename suffix
```
## API Usage
### Python Library
For programmatic access:
```python
from tabwrap import TabWrap
compiler = TabWrap()
result = compiler.compile_tex(
input_path="table.tex",
output_dir="output/",
png=True,
)
print(f"Compiled to: {result}")
```
### Web API
Run the FastAPI server for web applications:
```bash
# Install with API dependencies
pip install tabwrap[api]
# Start the API server
python -m tabwrap.api
# API endpoints
# GET /api/health - Service health check
# POST /api/compile - Compile LaTeX table fragment
```
## Research Workflow Integration
### Stata
```stata
esttab using "regression_results.tex", replace booktabs
! tabwrap regression_results.tex -p
```
### R
```r
library(xtable)
xtable(model) %>%
print(file = "model_table.tex", include.rownames = FALSE)
system("tabwrap model_table.tex")
```
### Python
```python
df.to_latex("data_summary.tex", index=False)
os.system("tabwrap data_summary.tex -p")
```
## Development
### Contributing
1. Fork the repository
2. Create a feature branch: `git checkout -b feature-name`
3. Make changes and add tests
4. Run tests: `poetry run pytest`
5. Submit a pull request
### Development Setup
```bash
git clone https://github.com/janfasnacht/tabwrap.git
cd tabwrap
poetry install
poetry run pytest # Run tests
```
### Building and Testing
```bash
poetry build # Build distribution packages
poetry run tabwrap --help # Test CLI
make test # Run full test suite
make test-coverage # Generate coverage report
```
## License
MIT License - see [LICENSE](LICENSE) file for details.