table-renderer 0.3.0__tar.gz → 0.5.0__tar.gz

{table_renderer-0.3.0 → table_renderer-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table-renderer
-Version: 0.3.0
+Version: 0.5.0
 Summary: A Python library for rendering structured tables as high-quality images or HTML.
 Keywords: table,renderer,rendering,image,html,weasyprint,pdfium,report
 Author: pTaunium
@@ -17,6 +17,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: jinja2~=3.0
 Requires-Dist: pillow~=12.0
 Requires-Dist: pypdfium2~=5.0
+Requires-Dist: typing-extensions>=4.5.0
 Requires-Dist: weasyprint>=68.1
 Requires-Python: >=3.12, <3.15
 Description-Content-Type: text/markdown
@@ -44,7 +45,7 @@ Description-Content-Type: text/markdown
 - **Auto-Crop**: Automatically crops images to the actual table area using visual detection, eliminating unnecessary white space.
 - **Continuous Long Tables**: Automatically stitches multiple PDF pages into a single continuous long image, preventing content from being cut off.
 - **Object-Oriented API**: Clean `Table` -> `Row/Column` -> `Cell` hierarchy with fluent interface support.
-- **Cascading Styles**: Manage visual styles effortlessly with "Global Defaults + Local Overrides."
+- **Cascading Styles**: Manage visual styles effortlessly with logical precedence: `Cell` > `Row` > `Column` > `Table`.
 - **Multi-language Font Support**: Support for font stacks (e.g., different fonts for English and Chinese).
 - **Customizable Resolution**: Adjustable DPI for high-resolution output (e.g., 300 DPI for print).
 - **Lightweight Deployment**: No heavy browser dependencies (like Chromium), making it ideal for Docker/K8s.
@@ -82,8 +83,8 @@ from table_renderer import Table
 
 # 1. Initialize a 3x3 table
 table = Table(3, 3)
-table.set_width(600)
 table.set_border(width=1, color="black", style="solid")
+table.set_width(400)
 
 # 2. Set header style (Row 0)
 header = table.get_row(0)
@@ -95,7 +96,7 @@ table.cell(0, 1).set_text("Category")
 table.cell(0, 2).set_text("Price")
 
 # 3. Add content and demonstrate merging
-table.cell(1, 0).set_text("MacBook Pro").span(rows=1, cols=2)
+table.cell(1, 0).set_text("MacBook Pro").set_span(rows=1, cols=2)
 table.cell(1, 2).set_text("$2,000")
 
 table.cell(2, 0).set_text("Magic Mouse")
@@ -105,8 +106,8 @@ table.cell(2, 2).set_text("$79")
 # 4. Global column styling (align prices to the right)
 table.get_column(2).set_align(horizontal="right").set_width(100)
 
-# 5. Export to image with custom DPI and padding
-table.to_image("report.png", dpi=300, padding=20)
+# 5. Export to image with custom DPI, padding, and background color
+table.to_image("report.png", dpi=300, padding=20, background_color="white")
 ```
 
 ---
@@ -119,7 +120,7 @@ Use the anchor-based design to merge cells by specifying the starting cell and t
 
 ```python
 # Merge first row, first two columns (1 row, 2 columns)
-table.cell(0, 0).span(rows=1, cols=2).set_text("Merged Header")
+table.cell(0, 0).set_span(rows=1, cols=2).set_text("Merged Header")
 ```
 
 ### 2. Font Management
@@ -149,12 +150,13 @@ table.cell(1, 1).set_image("https://example.com/image.jpg", width=100)
 
 ### 4. Layout & Sizing
 
-Mix fixed widths, percentages, and auto-sizing.
+Mix fixed widths, heights, percentages, and auto-sizing.
 
 ```python
 table.set_width(800)                  # Total table width
-table.get_column(0).set_width(200)    # Fixed 200px
+table.get_column(0).set_width(200)    # Fixed column width (200px)
 table.get_column(1).set_width("auto") # Distribute remaining space
+table.get_row(0).set_height(100)      # Fixed row height (100px)
 ```
 
 **Handling Extremely Wide Tables:**

{table_renderer-0.3.0 → table_renderer-0.5.0}/README.md

@@ -21,7 +21,7 @@
 - **Auto-Crop**: Automatically crops images to the actual table area using visual detection, eliminating unnecessary white space.
 - **Continuous Long Tables**: Automatically stitches multiple PDF pages into a single continuous long image, preventing content from being cut off.
 - **Object-Oriented API**: Clean `Table` -> `Row/Column` -> `Cell` hierarchy with fluent interface support.
-- **Cascading Styles**: Manage visual styles effortlessly with "Global Defaults + Local Overrides."
+- **Cascading Styles**: Manage visual styles effortlessly with logical precedence: `Cell` > `Row` > `Column` > `Table`.
 - **Multi-language Font Support**: Support for font stacks (e.g., different fonts for English and Chinese).
 - **Customizable Resolution**: Adjustable DPI for high-resolution output (e.g., 300 DPI for print).
 - **Lightweight Deployment**: No heavy browser dependencies (like Chromium), making it ideal for Docker/K8s.
@@ -59,8 +59,8 @@ from table_renderer import Table
 
 # 1. Initialize a 3x3 table
 table = Table(3, 3)
-table.set_width(600)
 table.set_border(width=1, color="black", style="solid")
+table.set_width(400)
 
 # 2. Set header style (Row 0)
 header = table.get_row(0)
@@ -72,7 +72,7 @@ table.cell(0, 1).set_text("Category")
 table.cell(0, 2).set_text("Price")
 
 # 3. Add content and demonstrate merging
-table.cell(1, 0).set_text("MacBook Pro").span(rows=1, cols=2)
+table.cell(1, 0).set_text("MacBook Pro").set_span(rows=1, cols=2)
 table.cell(1, 2).set_text("$2,000")
 
 table.cell(2, 0).set_text("Magic Mouse")
@@ -82,8 +82,8 @@ table.cell(2, 2).set_text("$79")
 # 4. Global column styling (align prices to the right)
 table.get_column(2).set_align(horizontal="right").set_width(100)
 
-# 5. Export to image with custom DPI and padding
-table.to_image("report.png", dpi=300, padding=20)
+# 5. Export to image with custom DPI, padding, and background color
+table.to_image("report.png", dpi=300, padding=20, background_color="white")
 ```
 
 ---
@@ -96,7 +96,7 @@ Use the anchor-based design to merge cells by specifying the starting cell and t
 
 ```python
 # Merge first row, first two columns (1 row, 2 columns)
-table.cell(0, 0).span(rows=1, cols=2).set_text("Merged Header")
+table.cell(0, 0).set_span(rows=1, cols=2).set_text("Merged Header")
 ```
 
 ### 2. Font Management
@@ -126,12 +126,13 @@ table.cell(1, 1).set_image("https://example.com/image.jpg", width=100)
 
 ### 4. Layout & Sizing
 
-Mix fixed widths, percentages, and auto-sizing.
+Mix fixed widths, heights, percentages, and auto-sizing.
 
 ```python
 table.set_width(800)                  # Total table width
-table.get_column(0).set_width(200)    # Fixed 200px
+table.get_column(0).set_width(200)    # Fixed column width (200px)
 table.get_column(1).set_width("auto") # Distribute remaining space
+table.get_row(0).set_height(100)      # Fixed row height (100px)
 ```
 
 **Handling Extremely Wide Tables:**

{table_renderer-0.3.0 → table_renderer-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "table-renderer"
-version = "0.3.0"
+version = "0.5.0"
 description = "A Python library for rendering structured tables as high-quality images or HTML."
 readme = "README.md"
 license = "MIT"
@@ -27,6 +27,7 @@ dependencies = [
   "jinja2~=3.0",
   "pillow~=12.0",
   "pypdfium2~=5.0",
+  "typing-extensions>=4.5.0",
   "weasyprint>=68.1",
 ]
 

{table_renderer-0.3.0 → table_renderer-0.5.0}/src/table_renderer/__init__.py

@@ -6,6 +6,6 @@ try:
     __version__ = importlib.metadata.version("table-renderer")
 except importlib.metadata.PackageNotFoundError:
     # Package is not installed (e.g. during local development without pip install -e .)
-    __version__ = "0.3.0"
+    __version__ = "0.5.0"
 
 __all__ = ["Cell", "Column", "Row", "Style", "StyledObject", "Table", "__version__"]

table_renderer-0.5.0/src/table_renderer/backends/__init__.py

@@ -0,0 +1,6 @@
+"""Rendering backends for table-renderer."""
+
+from .base import ImageRenderer
+from .weasyprint_renderer import WeasyPrintRenderer
+
+__all__ = ["ImageRenderer", "WeasyPrintRenderer"]

table_renderer-0.5.0/src/table_renderer/backends/base.py

@@ -0,0 +1,44 @@
+"""Protocol defining the image rendering backend interface."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from PIL.Image import Image
+
+    from table_renderer.models.table import Table
+
+
+class ImageRenderer(Protocol):
+    """Interface for rendering a Table model to an image.
+
+    All rendering backends must implement this interface. This allows
+    swapping the underlying rendering engine (e.g., WeasyPrint, Blitz)
+    without changing the public API or HTML generation logic.
+    """
+
+    def render(
+        self,
+        table: Table,
+        *,
+        dpi: int = 144,
+        padding: int = 10,
+        background_color: str = "transparent",
+    ) -> Image:
+        """Render a Table to a tightly-cropped PIL Image.
+
+        The returned image should be cropped to content bounds
+        (plus the specified padding). It is the backend's
+        responsibility to ensure no excess whitespace.
+
+        Args:
+            table: The Table data model to render.
+            dpi: Target resolution in dots per inch.
+            padding: Pixels of padding around content.
+            background_color: Background color.
+
+        Returns:
+            A PIL Image (RGBA mode) tightly cropped to the table.
+        """
+        ...

table_renderer-0.5.0/src/table_renderer/backends/weasyprint_renderer.py

@@ -0,0 +1,271 @@
+"""WeasyPrint-based rendering backend."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from weasyprint import HTML
+
+from table_renderer.html_generator import render_to_html
+
+if TYPE_CHECKING:
+    from PIL.Image import Image
+
+    from table_renderer.models.cell import Cell
+    from table_renderer.models.table import Table
+
+_DEFAULT_COL_WIDTH = 100
+_DEFAULT_FONT_SIZE = 16
+_CELL_PADDING = 8
+_LINE_HEIGHT_RATIO = 1.4
+_MIN_PAGE_WIDTH = 200
+_MIN_PAGE_HEIGHT = 200
+_PAGE_PADDING = 60  # body padding (20px * 2) + safety margin
+
+
+class WeasyPrintRenderer:
+    """Renders tables via WeasyPrint (HTML → PDF → raster image).
+
+    This is the default rendering backend. It converts HTML to PDF
+    via WeasyPrint, rasterizes the PDF pages to bitmaps via pypdfium2,
+    and auto-crops excess whitespace from the PDF page.
+    """
+
+    def render(
+        self,
+        table: Table,
+        *,
+        dpi: int = 144,
+        padding: int = 10,
+        background_color: str = "transparent",
+    ) -> Image:
+        """Render a Table to a tightly-cropped PIL Image.
+
+        Args:
+            table: The Table data model to render.
+            dpi: Target resolution in dots per inch.
+            padding: Pixels of padding around content.
+            background_color: Background color.
+
+        Returns:
+            A PIL Image (RGBA mode) tightly cropped to the table.
+        """
+        page_css = _estimate_page_css(table)
+        html = render_to_html(
+            table, background_color=background_color, extra_css=page_css
+        )
+
+        # WeasyPrint v53+ removed write_png, so we render to PDF then convert
+        pdf_bytes = HTML(string=html).write_pdf()
+        full_page_image = _pdf_to_image(pdf_bytes, dpi=dpi)
+        return _auto_crop(full_page_image, padding=padding)
+
+
+def _estimate_page_css(table: Table) -> str:
+    """Generate ``@page`` CSS rules with estimated canvas size.
+
+    Estimates the PDF page dimensions based on the actual table
+    content — column widths, font sizes, text line counts, and
+    embedded image heights — rather than fixed magic numbers.
+
+    Args:
+        table: The Table object to estimate dimensions for.
+
+    Returns:
+        A CSS string containing the ``@page`` rule.
+    """
+    estimated_width = _estimate_width(table)
+    estimated_height = _estimate_height(table)
+
+    return (
+        "@page {\n"
+        f"    size: {estimated_width}px {estimated_height}px;"
+        " /* Dynamically estimated size */\n"
+        "    margin: 0;\n"
+        "}"
+    )
+
+
+def _estimate_width(table: Table) -> int:
+    """Estimate the required page width in pixels.
+
+    Uses explicit column widths where available and falls back
+    to a default per-column width for unset columns.
+
+    Args:
+        table: The Table to estimate width for.
+
+    Returns:
+        Estimated width in pixels.
+    """
+    if not table._cells:
+        return _MIN_PAGE_WIDTH
+
+    # If the table has an explicit pixel width, use it directly
+    if isinstance(table.width, int):
+        return max(_MIN_PAGE_WIDTH, table.width + _PAGE_PADDING)
+
+    # Sum column widths: use explicit value or default
+    total_width = 0
+    for col in table._col_objects:
+        if isinstance(col.width, int):
+            total_width += col.width
+        else:
+            total_width += _DEFAULT_COL_WIDTH
+
+    return max(_MIN_PAGE_WIDTH, total_width + _PAGE_PADDING)
+
+
+def _estimate_height(table: Table) -> int:
+    """Estimate the required page height in pixels.
+
+    Calculates a per-row height based on the tallest cell in
+    each row, considering font size, number of text lines, and
+    embedded image height.
+
+    Args:
+        table: The Table to estimate height for.
+
+    Returns:
+        Estimated height in pixels.
+    """
+    if not table._cells:
+        return _MIN_PAGE_HEIGHT
+
+    # Resolve the table-level default font size
+    table_font_size = table.style.font_size or _DEFAULT_FONT_SIZE
+
+    total_height = 0
+    for row_idx, row_cells in enumerate(table._cells):
+        row_obj = table._row_objects[row_idx]
+
+        # If an explicit integer height is provided, use it
+        if isinstance(row_obj.height, int):
+            total_height += row_obj.height
+            continue
+
+        # Resolve row-level font size
+        row_font_size = row_obj.style.font_size or table_font_size
+
+        row_height = 0
+        for cell in row_cells:
+            if cell.is_merged:
+                continue
+
+            cell_height = _estimate_cell_height(cell, default_font_size=row_font_size)
+            row_height = max(row_height, cell_height)
+
+        total_height += row_height
+
+    return max(_MIN_PAGE_HEIGHT, total_height + _PAGE_PADDING)
+
+
+def _estimate_cell_height(cell: Cell, *, default_font_size: int) -> int:
+    """Estimate the height of a single cell in pixels.
+
+    Accounts for font size, number of text lines (split by newlines),
+    cell padding, and embedded image height.
+
+    Args:
+        cell: The Cell to estimate.
+        default_font_size: Inherited font size if the cell has none set.
+
+    Returns:
+        Estimated cell height in pixels.
+    """
+    font_size = cell.style.font_size or default_font_size
+
+    # Text height: number of lines * font_size * line-height + padding
+    line_count = max(1, cell.value.count("\n") + 1) if cell.value else 1
+    text_height = int(line_count * font_size * _LINE_HEIGHT_RATIO) + _CELL_PADDING * 2
+
+    # Image height (if present)
+    image_height = (cell.image_height or 0) + (_CELL_PADDING if cell.image_path else 0)
+
+    return text_height + image_height
+
+
+def _pdf_to_image(pdf_bytes: bytes, *, dpi: int) -> Image:
+    """Convert PDF bytes to a single stitched PIL Image.
+
+    Renders each page of the PDF at the specified DPI and
+    stitches them vertically into one tall image.
+
+    Args:
+        pdf_bytes: Raw PDF bytes.
+        dpi: Target resolution in dots per inch.
+
+    Returns:
+        A PIL RGBA Image with all pages stitched vertically.
+    """
+    import pypdfium2 as pdfium
+    from PIL import Image
+
+    with pdfium.PdfDocument(pdf_bytes) as pdf:
+        rendered_pages = []
+        scale_factor = dpi / 72  # PDF standard resolution is 72 DPI
+
+        # Render each page to a PIL Image
+        for page in pdf:
+            # fill_color=(255, 255, 255, 0) ensures transparent background
+            bitmap = page.render(scale=scale_factor, fill_color=(255, 255, 255, 0))
+            page_image = bitmap.to_pil()
+            rendered_pages.append(page_image)
+            bitmap.close()
+
+        if not rendered_pages:
+            return Image.new("RGBA", (1, 1), (255, 255, 255, 0))
+
+        # Stitch all pages vertically into one long image
+        total_width = max(img.width for img in rendered_pages)
+        total_height = sum(img.height for img in rendered_pages)
+        stitched = Image.new("RGBA", (total_width, total_height), (255, 255, 255, 0))
+
+        y_offset = 0
+        for img in rendered_pages:
+            stitched.paste(img, (0, y_offset))
+            y_offset += img.height
+
+    return stitched
+
+
+def _auto_crop(image: Image, *, padding: int) -> Image:
+    """Crop excess PDF page whitespace around the table.
+
+    WeasyPrint renders to a full PDF page, so the rendered image
+    typically has large margins that need to be trimmed.
+
+    Args:
+        image: The source PIL Image.
+        padding: Pixels of padding to preserve around content.
+
+    Returns:
+        The cropped image.
+    """
+    import PIL.ImageOps
+    from PIL import Image
+
+    # Find the bounding box of non-transparent/non-white content.
+    # Use 'L' (grayscale) mode to reduce memory usage (1 byte per pixel vs 3).
+    if image.mode == "RGBA":
+        # Flatten RGBA onto a white grayscale background
+        grayscale = Image.new("L", image.size, 255)
+        grayscale.paste(image.convert("L"), mask=image.getchannel("A"))
+    else:
+        # For RGB or other modes, just convert to grayscale
+        grayscale = image.convert("L")
+
+    # Invert and find bbox of "ink" (non-white pixels)
+    inverted = PIL.ImageOps.invert(grayscale)
+    bbox = inverted.getbbox()
+
+    if bbox:
+        # Expand crop region by the requested padding, clamped to image bounds
+        left, top, right, bottom = bbox
+        left = max(0, left - padding)
+        top = max(0, top - padding)
+        right = min(image.width, right + padding)
+        bottom = min(image.height, bottom + padding)
+        image = image.crop((left, top, right, bottom))
+
+    return image

table_renderer-0.5.0/src/table_renderer/html_generator.py

@@ -0,0 +1,126 @@
+"""HTML generation from Table models.
+
+This module converts Table data models into HTML document strings.
+It provides shared utilities that rendering backends can use, but
+is not tied to any specific rendering engine.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from jinja2 import Environment, FileSystemLoader, Template
+
+if TYPE_CHECKING:
+    from .models.table import Table
+
+# HTML template loaded from templates/table.html.j2
+_JINJA_ENV: Environment | None = None
+
+
+def _get_template() -> Template:
+    """Return the cached Jinja2 table template, initializing the environment on first call."""
+    global _JINJA_ENV
+    if _JINJA_ENV is None:
+        template_dir = Path(__file__).parent / "templates"
+        _JINJA_ENV = Environment(loader=FileSystemLoader(template_dir))  # noqa: S701
+    return _JINJA_ENV.get_template("table.html.j2")
+
+
+def _format_length(value: int | str) -> str:
+    """Format an integer as pixels, or return a string CSS value as is."""
+    return f"{value}px" if isinstance(value, int) else value
+
+
+def _prepare_render_context(
+    table: Table, *, background_color: str = "transparent"
+) -> dict[str, Any]:
+    """Prepare the Jinja2 template context from a Table model.
+
+    Handles merge-flag setup, font-face resolution, image URL
+    resolution, and extraction of column/row/cell data.
+
+    Args:
+        table: The Table object to prepare.
+        background_color: The background color of the body.
+
+    Returns:
+        A dict suitable for passing to ``Template.render()``.
+    """
+    table._prepare_render()
+
+    font_faces = []
+    for font_path in table.font_files:
+        font_name = os.path.splitext(os.path.basename(font_path))[0]
+        # Convert path to absolute file URL for rendering engines
+        absolute_font_path = os.path.abspath(font_path)
+        font_faces.append({"name": font_name, "path": f"file://{absolute_font_path}"})
+
+    cell_matrix = []
+    for row_index in range(len(table._cells)):
+        cell_row = []
+        for col_index in range(len(table._cells[0])):
+            cell = table._cells[row_index][col_index]
+
+            # Handle Image URL resolution
+            cell.image_url = ""
+            if cell.image_path:
+                if cell.image_path.startswith(("http://", "https://")):
+                    cell.image_url = cell.image_path
+                else:
+                    absolute_image_path = os.path.abspath(cell.image_path)
+                    cell.image_url = f"file://{absolute_image_path}"
+
+            cell_row.append(cell)
+        cell_matrix.append(cell_row)
+
+    return {
+        "background_color": background_color,
+        "table_width": _format_length(table.width),
+        "table_style": table.style.to_css(),
+        "font_faces": font_faces,
+        "columns": [
+            {
+                "index": c.index,
+                "width": _format_length(c.width),
+                "style": c.style.to_css(),
+            }
+            for c in table._col_objects
+        ],
+        "rows": [
+            {
+                "index": r.index,
+                "height": _format_length(r.height),
+                "style": r.style.to_css(),
+            }
+            for r in table._row_objects
+        ],
+        "cells": cell_matrix,
+    }
+
+
+def render_to_html(
+    table: Table,
+    *,
+    background_color: str = "transparent",
+    extra_css: str = "",
+) -> str:
+    """Generate the HTML representation of the table.
+
+    Args:
+        table: The Table object to render.
+        background_color: The background color of the body.
+        extra_css: Additional CSS to inject into the document head.
+            Used by backends to add engine-specific rules
+            (e.g., ``@page`` rules for WeasyPrint).
+
+    Returns:
+        A string containing the complete HTML document.
+    """
+    context = _prepare_render_context(table, background_color=background_color)
+    context["extra_css"] = extra_css
+    template = _get_template()
+
+    return template.render(**context)

{table_renderer-0.3.0 → table_renderer-0.5.0}/src/table_renderer/models/__init__.py

@@ -1,8 +1,7 @@
-from .base import StyledObject
 from .cell import Cell
 from .column import Column
 from .row import Row
-from .style import Style
+from .style import Style, StyledObject
 from .table import Table
 
 __all__ = ["Cell", "Column", "Row", "Style", "StyledObject", "Table"]

{table_renderer-0.3.0 → table_renderer-0.5.0}/src/table_renderer/models/cell.py

@@ -1,6 +1,8 @@
 from typing import Self
 
-from .base import StyledObject
+from typing_extensions import deprecated
+
+from .style import StyledObject
 
 
 class Cell(StyledObject):
@@ -56,9 +58,8 @@ class Cell(StyledObject):
         self.image_height = height
         return self
 
-    def span(self, *, rows: int = 1, cols: int = 1) -> Self:
-        """
-        Set the row and column span for merging.
+    def set_span(self, *, rows: int = 1, cols: int = 1) -> Self:
+        """Set the row and column span for merging.
 
         Args:
             rows: Number of rows to span.
@@ -70,3 +71,26 @@ class Cell(StyledObject):
         self.row_span = rows
         self.col_span = cols
         return self
+
+    @deprecated("Use `set_span` instead.")
+    def span(self, *, rows: int = 1, cols: int = 1) -> Self:
+        """Set the row and column span for merging.
+
+        .. deprecated::
+            Use :meth:`set_span` instead.
+
+        Args:
+            rows: Number of rows to span.
+            cols: Number of columns to span.
+
+        Returns:
+            The cell itself for chaining.
+        """
+        import warnings
+
+        warnings.warn(
+            "Cell.span() is deprecated, use Cell.set_span() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.set_span(rows=rows, cols=cols)

{table_renderer-0.3.0 → table_renderer-0.5.0}/src/table_renderer/models/column.py

@@ -1,6 +1,6 @@
 from typing import Self
 
-from .base import StyledObject
+from .style import StyledObject
 
 
 class Column(StyledObject):