jeffgortmaker
commented
1 month ago Unfortunately I won't be of much help here! Formatting results is beyond the scope of PyBLP.
In my own work (including for the above screenshot) I tend to just build tables custom instead of relying on other packages, which I've found don't really afford enough flexibility (and I always forget how to use their interfaces).
No idea if this is helpful, but here's a copy/paste of a quick class I threw together, iterations of which I've used for making custom tables with Python that are in the style I like.
class TableFormatter:
"""LaTeX table formatter."""
def __init__(self, subtables=1, longtable=False, longtable_continue_start=0):
"""Initialize empty cells."""
assert not (subtables > 1 and longtable)
self.subtables = subtables
self.longtable = longtable
self._longtable_continue_start = longtable_continue_start
self._header_cells = [[] for _ in range(self.subtables)]
self._data_cells = [[] for _ in range(self.subtables)]
self._header_extras = [{} for _ in range(self.subtables)]
self._data_extras = [{} for _ in range(self.subtables)]
def add_header_row(self, values, row=None, subtable=0):
"""Set a row in a header."""
self._add_row(values, row, subtable, header=True)
def add_data_row(self, values, row=None, subtable=0):
"""Set a row."""
self._add_row(values, row, subtable, header=False)
def add_header_line(self, row=None, subtable=0):
"""Add a midrule in a header."""
self._insert_after_row(r'\midrule', row, subtable, header=True)
def add_data_line(self, row=None, subtable=0):
"""Add a midrule."""
self._insert_after_row(r'\midrule', row, subtable, header=False)
def add_header_space(self, row=None, subtable=0):
"""Add vertical space in a header."""
self._insert_after_row(r'\addlinespace', row, subtable, header=True)
def add_data_space(self, row=None, subtable=0):
"""Add vertical space."""
self._insert_after_row(r'\addlinespace', row, subtable, header=False)
def add_header_page_break(self, row=None, subtable=0):
"""Add a page break in a header."""
self._insert_after_row(r'\pagebreak', row, subtable, header=True)
def add_data_page_break(self, row=None, subtable=0):
"""Add vertical space."""
self._insert_after_row(r'\pagebreak', row, subtable, header=False)
def add_header_underline(self, specs, row=None, subtable=0):
"""Add underlines in a header."""
value = ''.join(r'\cmidrule(%s){%s-%s}' % s for s in specs)
self._insert_after_row(value, row, subtable, header=True)
def add_data_underline(self, specs, row=None, subtable=0):
"""Add underlines."""
value = ''.join(r'\cmidrule(%s){%s-%s}' % s for s in specs)
self._insert_after_row(value, row, subtable, header=False)
# noinspection PyTypeChecker
def _add_row(self, values, row, subtable, header):
"""Add a row."""
cells = (self._header_cells if header else self._data_cells)[subtable]
if row is None:
row = len(cells)
for column, value in enumerate(values):
# extend the cells if necessary
while len(cells) < row + 1:
cells.append([])
while len(cells[row]) < column + 1:
cells[row].append('')
# identify multicolumns
columns = 1
alignment = None
if isinstance(value, (list, tuple)) and isinstance(value[0], int):
columns, alignment, value = value
# join multivalued values into a stack
if isinstance(value, (list, tuple)):
value = '\\shortstack{%s}' % ' \\\\ '.join(str(v) for v in value)
else:
value = str(value)
# construct multicolumns
if columns > 1:
value = r'\multicolumn{%s}{%s}{%s}' % (columns, alignment, value)
cells[row][column] = value
def _insert_after_row(self, value, row, subtable, header):
"""Add extra content after a row."""
cells = (self._header_cells if header else self._data_cells)[subtable]
extras = self._header_extras if header else self._data_extras
if row is None:
row = len(cells) - 1
extras[subtable][row] = value
def __str__(self):
"""Format the table."""
formatted = [r'\toprule']
if self.longtable:
for first_head in [True, False]:
if not first_head:
formatted.extend([
r'\midrule',
r'\multicolumn{%s}{c}{Continued from the previous page.} \\' % len(self._data_cells[0][0]),
r'\midrule'
])
for row, values in enumerate(self._header_cells[0]):
if not first_head and row < self._longtable_continue_start:
continue
formatted.append('%s \\\\' % ' & '.join(values))
if row in self._header_extras[0]:
formatted.append(self._header_extras[0][row])
formatted.append(r'\midrule')
formatted.append(r'\endfirsthead' if first_head else r'\endhead')
formatted.extend([
r'\midrule',
r'\multicolumn{%s}{c}{Continued on the next page.} \\' % len(self._data_cells[0][0]),
r'\midrule',
r'\endfoot',
r'\endlastfoot'
])
for row, values in enumerate(self._data_cells[0]):
formatted.append(r'%s \\' % ' & '.join(values))
if row in self._data_extras[0]:
formatted.append(self._data_extras[0][row])
formatted.append(r'\bottomrule')
else:
for subtable in range(self.subtables):
for row, values in enumerate(self._header_cells[subtable]):
formatted.append(r'%s \\' % ' & '.join(values))
if row in self._header_extras[subtable]:
formatted.append(self._header_extras[subtable][row])
formatted.append(r'\midrule')
for row, values in enumerate(self._data_cells[subtable]):
formatted.append(r'%s \\' % ' & '.join(values))
if row in self._data_extras[subtable]:
formatted.append(self._data_extras[subtable][row])
formatted.append(r'\bottomrule' if subtable == self.subtables - 1 else r'\midrule')
return '\n'.join(formatted)
def save(self, path):
"""Save the table to a file."""
with open(path, 'w') as handle:
handle.write(str(self))
mcket747econ
Hello,
I am very new to PyBLP and I have been trying to figure out the best way to export the parameter estimates, standard errors, and other relevant statistics into LaTeX tables. While there are ways to export python dataframes using .to_latex() there does not appear to be a way to export the GMM parameter estimates smoothly. My current solution is to use pyblp within R, and then do some wrangling to get estimates into Stargazer. Do you know of a more efficient approach to produce tables such as those numbered 7 and 8 in Conlon and Gortmaker(2020):
Any help is appreciated!
My current R/Stargazer approach is the following