span-table 0.1.0__tar.gz

span_table-0.1.0/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

span_table-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

span_table-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soami Charan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

span_table-0.1.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: span-table
+Version: 0.1.0
+Summary: span-table is a lightweight Python helper for rendering ASCII tables with merged cells using Rich-style markup.
+Project-URL: Repository, https://github.com/soamicharan/span-table
+Project-URL: Homepage, https://github.com/soamicharan/span-table
+Project-URL: Issues, https://github.com/soamicharan/span-table/issues
+Author-email: Soami Charan <charansoami@gmail.com>
+Maintainer-email: Soami Charan <charansoami@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ascii,merged cells,rich,span,table
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Requires-Dist: rich>=15.0.0
+Description-Content-Type: text/markdown
+
+# span-table
+
+`span-table` is a lightweight Python helper for rendering ASCII tables with merged cells using Rich-style markup.
+
+## Features
+
+- Render table layouts with custom merged spans
+- Support multi-line cell content
+- Uses `rich` box styles for flexible borders
+- Compatible with Python `>=3.14`
+
+## Installation
+
+```bash
+pip install span-table
+```
+
+## Quick Start
+
+```python
+from span_table import span_table
+from rich import print
+
+table = [
+    ["Header 1", "Header 2", "Header3", "Header 4"],
+    ["row 1", "column 2", "column 3", "column 4"],
+    ["row 2", "Cells span columns.", "", ""],
+    ["row 3", "Cells\nspan rows.", "- Cells\n- contain\n- blocks", ""],
+    ["row 4", "", "", ""]
+]
+
+# Spans are defined as ((start_row, start_col), (end_row, end_col)) with zero-based indexes
+my_spans = [
+    ((2, 1), (2, 3)),
+    ((3, 1), (4, 1)),
+    ((3, 2), (4, 3)),
+]
+
+print(span_table(table, my_spans))
+```
+
+This renders:
+
+```text
+┌──────────┬────────────┬──────────┬──────────┐
+│ Header 1 │ Header 2   │ Header3  │ Header 4 │
+├──────────┼────────────┼──────────┼──────────┤
+│ row 1    │ column 2   │ column 3 │ column 4 │
+├──────────┼────────────┴──────────┴──────────┤
+│ row 2    │ Cells span columns.              │
+├──────────┼────────────┬─────────────────────┤
+│ row 3    │ Cells      │ - Cells             │
+├──────────┤ span rows. │ - contain           │
+│ row 4    │            │ - blocks            │
+└──────────┴────────────┴─────────────────────┘
+```
+
+## Advanced Usage
+
+```python
+from span_table import span_table
+from rich import print
+
+table = [
+    ["Time", "[on red]Height[/]", "", "[on green]Weight[/]", ""],
+    ["", "Total", "Change", "Total", "Change"],
+    ["15:30", "1", "2", "3", "4"]
+]
+
+spans = [
+    ((0, 0), (1, 0)),
+    ((0, 1), (0, 2)),
+    ((0, 3), (0, 4))
+]
+
+print(span_table(table, spans))
+```
+
+This renders:
+
+```text
+┌───────┬────────────────┬────────────────┐
+│ Time  │<red bg> Height │<Green BG>Weight│
+│       ├───────┬────────┼───────┬────────┤
+│       │ Total │ Change │ Total │ Change │
+├───────┼───────┼────────┼───────┼────────┤
+│ 15:30 │ 1     │ 2      │ 3     │ 4      │
+└───────┴───────┴────────┴───────┴────────┘
+```
+
+## API
+
+### `span_table(data, spans, box=rich_box.SQUARE) -> str`
+
+Render a text table with optional merged cells.
+
+- `data`: `list[list[str]]` — table rows and columns
+- `spans`: `list[tuple[tuple[int, int], tuple[int, int]]]` — list of merge regions
+- `box`: `rich.box.Box` — optional Rich box style such as `box.SQUARE`
+
+### Span rules
+
+- Each span is a rectangular region defined by a start and end coordinate
+- Coordinates are zero-based: `(row_index, column_index)`
+- Spans can cover a single cell or multiple cells
+- Spans must be within the table bounds
+
+## Rich markup support
+
+Cell values may include Rich markup tags such as `[bold]`, `[italic]`, or color tags but does not support emoji yet. The library preserves markup while measuring text layout.
+
+## Notes
+
+- Ensure each row has the same number of columns
+- Non-merged cells may be omitted from `spans`
+- The library automatically fills any cells not included in spans as standard individual cells

span_table-0.1.0/README.md

@@ -0,0 +1,116 @@
+# span-table
+
+`span-table` is a lightweight Python helper for rendering ASCII tables with merged cells using Rich-style markup.
+
+## Features
+
+- Render table layouts with custom merged spans
+- Support multi-line cell content
+- Uses `rich` box styles for flexible borders
+- Compatible with Python `>=3.14`
+
+## Installation
+
+```bash
+pip install span-table
+```
+
+## Quick Start
+
+```python
+from span_table import span_table
+from rich import print
+
+table = [
+    ["Header 1", "Header 2", "Header3", "Header 4"],
+    ["row 1", "column 2", "column 3", "column 4"],
+    ["row 2", "Cells span columns.", "", ""],
+    ["row 3", "Cells\nspan rows.", "- Cells\n- contain\n- blocks", ""],
+    ["row 4", "", "", ""]
+]
+
+# Spans are defined as ((start_row, start_col), (end_row, end_col)) with zero-based indexes
+my_spans = [
+    ((2, 1), (2, 3)),
+    ((3, 1), (4, 1)),
+    ((3, 2), (4, 3)),
+]
+
+print(span_table(table, my_spans))
+```
+
+This renders:
+
+```text
+┌──────────┬────────────┬──────────┬──────────┐
+│ Header 1 │ Header 2   │ Header3  │ Header 4 │
+├──────────┼────────────┼──────────┼──────────┤
+│ row 1    │ column 2   │ column 3 │ column 4 │
+├──────────┼────────────┴──────────┴──────────┤
+│ row 2    │ Cells span columns.              │
+├──────────┼────────────┬─────────────────────┤
+│ row 3    │ Cells      │ - Cells             │
+├──────────┤ span rows. │ - contain           │
+│ row 4    │            │ - blocks            │
+└──────────┴────────────┴─────────────────────┘
+```
+
+## Advanced Usage
+
+```python
+from span_table import span_table
+from rich import print
+
+table = [
+    ["Time", "[on red]Height[/]", "", "[on green]Weight[/]", ""],
+    ["", "Total", "Change", "Total", "Change"],
+    ["15:30", "1", "2", "3", "4"]
+]
+
+spans = [
+    ((0, 0), (1, 0)),
+    ((0, 1), (0, 2)),
+    ((0, 3), (0, 4))
+]
+
+print(span_table(table, spans))
+```
+
+This renders:
+
+```text
+┌───────┬────────────────┬────────────────┐
+│ Time  │<red bg> Height │<Green BG>Weight│
+│       ├───────┬────────┼───────┬────────┤
+│       │ Total │ Change │ Total │ Change │
+├───────┼───────┼────────┼───────┼────────┤
+│ 15:30 │ 1     │ 2      │ 3     │ 4      │
+└───────┴───────┴────────┴───────┴────────┘
+```
+
+## API
+
+### `span_table(data, spans, box=rich_box.SQUARE) -> str`
+
+Render a text table with optional merged cells.
+
+- `data`: `list[list[str]]` — table rows and columns
+- `spans`: `list[tuple[tuple[int, int], tuple[int, int]]]` — list of merge regions
+- `box`: `rich.box.Box` — optional Rich box style such as `box.SQUARE`
+
+### Span rules
+
+- Each span is a rectangular region defined by a start and end coordinate
+- Coordinates are zero-based: `(row_index, column_index)`
+- Spans can cover a single cell or multiple cells
+- Spans must be within the table bounds
+
+## Rich markup support
+
+Cell values may include Rich markup tags such as `[bold]`, `[italic]`, or color tags but does not support emoji yet. The library preserves markup while measuring text layout.
+
+## Notes
+
+- Ensure each row has the same number of columns
+- Non-merged cells may be omitted from `spans`
+- The library automatically fills any cells not included in spans as standard individual cells

span_table-0.1.0/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from span-table!")
+
+
+if __name__ == "__main__":
+    main()

span_table-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "span-table"
+version = "0.1.0"
+description = "span-table is a lightweight Python helper for rendering ASCII tables with merged cells using Rich-style markup."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "rich>=15.0.0",
+]
+license = { text = "MIT" }
+license-files = ["LICENSE"]
+authors = [{ name = "Soami Charan", email = "charansoami@gmail.com" }]
+maintainers = [{ name = "Soami Charan", email = "charansoami@gmail.com" }]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = ["table", "ascii", "rich", "span", "merged cells"]
+
+[project.urls]
+Repository = "https://github.com/soamicharan/span-table"
+Homepage = "https://github.com/soamicharan/span-table"
+Issues = "https://github.com/soamicharan/span-table/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/span_table"]

span_table-0.1.0/src/span_table/__init__.py

@@ -0,0 +1,3 @@
+from table import span_table
+
+__all__ = ["span_table"]

span_table-0.1.0/src/span_table/cell.py

@@ -0,0 +1,265 @@
+from src.span_table.span import (
+    get_span_column_count,
+    get_span_row_count, 
+    get_span_char_height, 
+    get_span_char_width
+)
+from typing import Literal
+from dataclasses import dataclass
+from rich.box import Box
+from src.span_table.types import SpanType, TableType
+
+@dataclass
+class Cell:
+    text: str
+    row: int
+    column: int
+    row_count: int
+    column_count: int
+
+    def __lt__(self, other):
+        return [self.row, self.column] < [other.row, other.column]
+    
+    @property
+    def left_sections(self):
+        lines = self.text.split('\n')
+        sections = 0
+
+        for i in range(len(lines)):
+            if lines[i].startswith('+'):
+                sections += 1
+        sections -= 1
+
+        return sections
+
+    @property
+    def right_sections(self):
+        lines = self.text.split('\n')
+        sections = 0
+        for i in range(len(lines)):
+            if lines[i].endswith('+'):
+                sections += 1
+        return sections - 1
+
+    @property
+    def top_sections(self):
+        top_line = self.text.split('\n')[0]
+        sections = len(top_line.split('+')) - 2
+
+        return sections
+
+    @property
+    def bottom_sections(self):
+        bottom_line = self.text.split('\n')[-1]
+        sections = len(bottom_line.split('+')) - 2
+
+        return sections
+
+def resolve_border(
+        box: Box, 
+        row: int, 
+        col: int, 
+        total_row: int, 
+        total_col: int, 
+        span: SpanType, 
+        corner: Literal['top_left', 'top_right', 'bottom_left', 'bottom_right']
+):
+    if corner == "top_left":
+        if row == 0 and col == 0:
+            return box.top_left
+        elif 0 < row and col == 0:
+            return box.row_left
+        elif  row == 0 and 0 < col:
+            return box.top_divider
+        else:
+            return box.row_cross
+    elif corner == "top_right":
+        if len(span) > 1:
+            row, col = span[0][0], span[-1][1]
+        if row == 0 and col == (total_col - 1):
+            return box.top_right
+        elif row > 0 and col == (total_col - 1):
+            return box.row_right
+        elif row == 0 and col < (total_col - 1):
+            return box.top_divider
+        else:
+            return box.row_cross
+    elif corner == "bottom_left":
+        if len(span) > 1:
+            row, col = span[-1][0], span[0][1]
+        if row == (total_row - 1) and col == 0:
+            return box.bottom_left
+        elif row == (total_row - 1) and col > 0:
+            return box.bottom_divider
+        elif row < (total_row - 1) and col == 0:
+            return box.row_left
+        else:
+            return box.row_cross
+    elif corner == "bottom_right":
+        if len(span) > 1:
+            row, col = span[-1]
+        if row == (total_row - 1) and col == (total_col - 1):
+            return box.bottom_right
+        elif row == (total_row - 1) and col < (total_col - 1):
+            return box.bottom_divider
+        elif row < (total_row - 1) and col == (total_col - 1):
+            return box.row_right
+        else:
+            return box.row_cross
+      
+
+def make_cell(table: TableType, span: SpanType, widths: list[int], heights: list[int], box: Box) -> Cell:
+    width = get_span_char_width(span, widths)
+    height = get_span_char_height(span, heights)
+    text_row = span[0][0]
+    text_column = span[0][1]
+    text = table[text_row][text_column]
+    total_cols = len(widths)
+    total_rows = len(heights)
+
+    lines = text.plain.split("\n")
+    text.pad_width(width)
+
+    height_difference = height - len(lines)
+    text.append_empty_lines(height_difference, width)
+    output = [
+        ''.join([
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'top_left'), 
+            (width * box.row_horizontal),
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'top_right')
+        ])
+    ]
+
+    for line in text.markup.split('\n'):
+        output.append(box.mid_vertical + line + box.mid_vertical)
+
+    symbol = box.row_horizontal
+
+    output.append(
+        ''.join([
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'bottom_left'), 
+            width * symbol, 
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'bottom_right')
+        ])
+    )
+
+    text = "\n".join(output)
+    row_count = get_span_row_count(span)
+    column_count = get_span_column_count(span)
+    return Cell(text=text, row=text_row, column=text_column, row_count=row_count, column_count=column_count)
+
+
+def merge_cells(cell1: Cell, cell2: Cell, direction: Literal["RIGHT", "TOP", "BOTTOM", "LEFT"], box: Box):
+    cell1_lines = cell1.text.split("\n")
+    cell2_lines = cell2.text.split("\n")
+    if direction == "RIGHT":
+        for i in range(len(cell1_lines)):
+            sub = cell1_lines[i][-1]
+            if cell1_lines[i][-1] == box.mid_vertical and cell2_lines[i][0] == box.row_cross:
+                sub = box.row_left
+            elif cell1_lines[i][-1] == box.row_cross and cell2_lines[i][0] == box.mid_vertical:
+                sub = box.row_right
+            elif cell1_lines[i][-1] == box.row_cross and (cell2_lines[i][0] == box.top_left or cell2_lines[i][0] == box.top_divider):
+                sub = box.top_divider
+            
+            cell1_lines[i] = cell1_lines[i][:-1] + sub + cell2_lines[i][1:]
+        cell1.text = "\n".join(cell1_lines)
+        cell1.column_count += cell2.column_count
+
+    elif direction == "TOP":
+        if cell1_lines[0].count('+') > cell2_lines[-1].count('+'):
+            cell2_lines.pop(-1)
+        else:
+            cell1_lines.pop(0)
+        cell2_lines.extend(cell1_lines)
+        cell1.text = "\n".join(cell2_lines)
+        cell1.row_count += cell2.row_count
+        cell1.row = cell2.row
+        cell1.column = cell2.column
+
+    elif direction == "BOTTOM":
+        merged_cells = ""
+        for top_char, bottom_char in zip(cell1_lines[-1], cell2_lines[0]):
+            if top_char == box.row_cross and bottom_char == box.row_horizontal:
+                merged_cells += box.bottom_divider
+            elif top_char == box.row_horizontal and bottom_char == box.row_cross:
+                merged_cells += box.top_divider
+            else:
+                merged_cells += top_char
+        cell1_lines[-1] = merged_cells
+        cell1_lines.extend(cell2_lines[1:])
+        cell1.text = "\n".join(cell1_lines)
+        cell1.row_count += cell2.row_count
+
+    elif direction == "LEFT":
+        for i in range(len(cell1_lines)):
+            sub = cell1_lines[i]
+            if cell1_lines[i][0] == box.mid_vertical and cell2_lines[i][-1] == box.row_cross:
+                sub = box.row_right + sub[1:]
+            elif cell1_lines[i][0] == box.row_cross and cell2_lines[i][-1] == box.mid_vertical:
+                sub = box.row_left + sub[1:]
+
+            cell1_lines[i] = cell2_lines[i][0:-1] + sub
+        cell1.text = "\n".join(cell1_lines)
+        cell1.column_count += cell2.column_count
+        cell1.row = cell2.row
+        cell1.column = cell2.column
+    
+def merge_all_cells(cells: list[Cell], box: Box) -> str:
+    current = 0
+    while len(cells) > 1:
+        count = 0
+        while count < len(cells):
+            cell1 = cells[current]
+            cell2 = cells[count]
+            merge_direction = get_merge_direction(cell1, cell2)
+            if not merge_direction == "NONE":
+                merge_cells(cell1, cell2, merge_direction, box)
+                if current > count:
+                    current -= 1
+
+                cells.pop(count)
+            else:
+                count += 1
+
+        current += 1
+        if current >= len(cells):
+            current = 0
+
+    return cells[0].text
+
+def get_merge_direction(cell1: Cell, cell2: Cell) -> Literal["RIGHT", "TOP", "BOTTOM", "LEFT", "NONE"]:
+    cell1_left = cell1.column
+    cell1_right = cell1.column + cell1.column_count
+    cell1_top = cell1.row
+    cell1_bottom = cell1.row + cell1.row_count
+    cell2_left = cell2.column
+    cell2_right = cell2.column + cell2.column_count
+    cell2_top = cell2.row
+    cell2_bottom = cell2.row + cell2.row_count
+
+    if (cell1_right == cell2_left and cell1_top == cell2_top and
+            cell1_bottom == cell2_bottom and
+            cell1.right_sections >= cell2.left_sections):
+        return "RIGHT"
+
+    elif (cell1_left == cell2_left and cell1_right == cell2_right and
+            cell1_top == cell2_bottom and
+            cell1.top_sections >= cell2.bottom_sections):
+        return "TOP"
+
+    elif (cell1_left == cell2_left and
+          cell1_right == cell2_right and
+          cell1_bottom == cell2_top and
+          cell1.bottom_sections >= cell2.top_sections):
+        return "BOTTOM"
+
+    elif (cell1_left == cell2_right and
+          cell1_top == cell2_top and
+          cell1_bottom == cell2_bottom and
+          cell1.left_sections >= cell2.right_sections):
+        return "LEFT"
+
+    else:
+        return "NONE"
+

span_table-0.1.0/src/span_table/markup_text.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+from rich.markup import Tag, _parse
+
+
+@dataclass
+class StyleToken:
+    tag: Tag
+
+@dataclass
+class TextToken:
+    text: str
+
+    def pad_width(self, width: int):
+        pad = max(0, width - len(self.text))
+        if pad:
+            self.text += ' ' * pad
+
+class MarkupText:
+    def __init__(self, markup: str):
+        self._tokens: list[StyleToken | TextToken] = []
+        self._parse(markup)
+
+    def _parse(self, markup: str):
+        for _, text, tag in _parse(markup):
+            if text is not None:
+                for line in text.split('\n'):
+                    if line == '':
+                        continue
+                    self._tokens.append(TextToken(f" {line} "))
+            else:
+                self._tokens.append(StyleToken(tag))
+
+    @property
+    def plain(self) -> str:
+        return "\n".join(l.text for l in self.text_tokens)
+
+    @property
+    def markup(self) -> str:
+        markup_text = ""
+        for idx in range(len(self._tokens)):
+            if idx > 0:
+                if isinstance(self._tokens[idx - 1], TextToken) and isinstance(self._tokens[idx], TextToken):
+                    markup_text += "\n"
+
+            if isinstance(self._tokens[idx], TextToken):
+                markup_text += self._tokens[idx].text
+            else:
+                markup_text += f"[{self._tokens[idx].tag.name}]"
+
+        return markup_text
+
+    @property
+    def text_tokens(self) -> list[TextToken]:
+        return [token for token in self._tokens if isinstance(token, TextToken)]
+    
+    def pad_width(self, width: int):
+        for token in self.text_tokens:
+            token.pad_width(width)
+
+    def append_empty_lines(self, count: int, width: int):
+        for _ in range(count):
+            self._tokens.append(TextToken(" " * width))

span_table-0.1.0/src/span_table/span.py

@@ -0,0 +1,128 @@
+from rich.text import Text
+from src.span_table.types import TableType, SpanType
+from src.span_table.markup_text import MarkupText
+
+def check_span(data: TableType, span: SpanType):
+    if not len(span) == 2 or not len(span[0]) == 2 or not len(span[1]) == 2:
+        raise Exception("Span must be tuple of tuples in format ((start row index, start column index), (end row index, end column index))")
+    
+    start_span, end_span = span
+    if not (start_span[0] <= end_span[0] and start_span[1] <= end_span[1]):
+        raise Exception('Spans must be rectangular in shape.')
+
+    if not (0 <= start_span[0] <= end_span[0] < len(data)) or not (0 <= start_span[1] <= end_span[1] < len(data[0])):
+        raise Exception(f"{span} is out of bounds.")
+
+def extend_span(start: tuple[int, int], end: tuple[int, int]) -> SpanType:
+    extended_span = []
+    for row_idx in range(start[0], end[0] + 1):
+        for col_idx in range(start[1], end[1] + 1):
+            extended_span.append((row_idx, col_idx))
+
+    return extended_span
+
+def get_span(spans: list[SpanType], row: int, column: int) -> SpanType | None:
+    for i in range(len(spans)):
+        if (row, column) in spans[i]:
+            return spans[i]
+
+    return None
+
+def convert_cells_to_spans(data: TableType, spans: list[SpanType]) -> list[SpanType]:
+    new_spans = []
+    for row in range(len(data)):
+        for column in range(len(data[0])):
+            span = get_span(spans, row, column)
+            if not span:
+                new_spans.append([(row, column)])
+    
+    new_spans.extend(spans)
+    new_spans = list(sorted(new_spans))
+    return new_spans
+
+def get_span_column_count(span: SpanType) -> int:
+    return max((span[-1][1] - span[0][1]) + 1, 1)
+
+def get_span_row_count(span: SpanType) -> int:
+    return max((span[-1][0] - span[0][0]) + 1, 1)
+
+def get_longest_line_length(text: MarkupText) -> int:
+    return len(max(text.plain.split("\n"), key=lambda line: len(line)))
+
+def get_output_column_widths(table: TableType, spans: list[SpanType]) -> list[int]:
+    widths = [3 for _ in range(len(table[0]))]
+    for row in range(len(table)):
+        for column in range(len(table[row])):
+            span = get_span(spans, row, column)
+            column_count = get_span_column_count(span)
+            text_row = span[0][0]
+            text_column = span[0][1]
+            text = table[text_row][text_column]
+            length = get_longest_line_length(text)
+            if column_count == 1:
+                widths[column] = max(length, widths[column])
+            else:
+                end_column = text_column + column_count
+                available_space = sum(widths[text_column:end_column]) + column_count - 1
+                while length > available_space:
+                    for i in range(text_column, end_column):
+                        widths[i] += 1
+                        available_space = sum(widths[text_column:end_column]) + column_count - 1
+                        if length <= available_space:
+                            break
+    return widths
+
+def get_output_row_heights(table: TableType, spans: list[SpanType]) -> list[int]:
+    heights = [-1 for _ in table]
+    for row in range(len(table)):
+        for column in range(len(table[row])):
+            text = table[row][column]
+            span = get_span(spans, row, column)
+            row_count = get_span_row_count(span)
+            height = len(text.plain.split('\n'))
+            if row_count == 1:
+                heights[row] = max(height, heights[row])
+    
+    for row in range(len(table)):
+        for column in range(len(table[row])):
+            text = table[row][column]
+            span = get_span(spans, row, column)
+            row_count = get_span_row_count(span)
+            height = len(text.plain.split('\n'))
+            if row_count > 1:
+                text_row = span[0][0]
+                text_column = span[0][1]
+                end_row = text_row + row_count
+                text = table[text_row][text_column]
+                height = len(text.plain.split('\n')) - (row_count - 1)
+                add_row = 0
+                while height > sum(heights[text_row:end_row]):
+                    heights[text_row + add_row] += 1
+                    if add_row + 1 < row_count:
+                        add_row += 1
+                    else:
+                        add_row = 0
+    return heights
+
+def get_span_char_width(span: SpanType, column_widths: list[int]) -> int:
+    start_column = span[0][1]
+    column_count = get_span_column_count(span)
+    total_width = 0
+
+    for i in range(start_column, start_column + column_count):
+        total_width += column_widths[i]
+
+    total_width += column_count - 1
+
+    return total_width
+
+def get_span_char_height(span: SpanType, row_heights: list[int]) -> int:
+    start_row = span[0][0]
+    row_count = get_span_row_count(span)
+    total_height = 0
+
+    for i in range(start_row, start_row + row_count):
+        total_height += row_heights[i]
+    
+    total_height += row_count - 1
+    return total_height

span_table-0.1.0/src/span_table/table.py

@@ -0,0 +1,54 @@
+from rich import box as rich_box
+from rich.text import Text
+
+from src.span_table.span import (
+    extend_span, 
+    check_span, 
+    convert_cells_to_spans, 
+    get_output_column_widths,
+    get_output_row_heights,
+)
+from src.span_table.cell import make_cell, merge_all_cells
+from src.span_table.markup_text import MarkupText
+from src.span_table.types import SpanType, TableType
+from typing import Annotated
+
+TableMarkupType = Annotated[list[list[MarkupText]], 'Lists of list of markup type objects']
+
+def check_table(data: TableType):
+    if not type(data) is list:
+        raise Exception("Table data must be a list of lists")
+
+    if len(data) == 0:
+        raise Exception("Table data must contain at least one row and one column")
+
+    for i in range(len(data)):
+        if not type(data[i]) is list:
+            raise Exception("Table data must be a list of lists")
+        
+        if not len(data[i]) == len(data[0]):
+            raise Exception("Each row must have the same number of columns")
+
+def span_table(
+    data: TableType,
+    spans: list[SpanType],
+    box: rich_box.Box = rich_box.SQUARE
+) -> str:
+    check_table(data=data)
+    extended_spans = []
+    for span in spans:
+        check_span(data, span)
+        extended_spans.append(extend_span(*span))
+
+    text_data = [[MarkupText(cell) for cell in row] for row in data]
+    spans = convert_cells_to_spans(text_data, extended_spans)
+    widths = get_output_column_widths(text_data, spans)
+    heights = get_output_row_heights(text_data, spans)
+    cells = [
+        make_cell(text_data, span, widths, heights, box)
+        for span in spans
+    ]
+    cells = list(sorted(cells))
+    grid_table = merge_all_cells(cells, box)
+
+    return grid_table

span_table-0.1.0/src/span_table/types.py

@@ -0,0 +1,5 @@
+from typing import Annotated
+
+SpanType =  Annotated[list[tuple[int, int]], "List of tuples"]
+TableType = Annotated[list[list[str]], "List of list of strings with rich markup"]
+

span_table-0.1.0/uv.lock

@@ -0,0 +1,80 @@
+version = 1
+revision = 3
+requires-python = ">=3.9"
+resolution-markers = [
+    "python_full_version >= '3.10'",
+    "python_full_version < '3.10'",
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.10'",
+]
+dependencies = [
+    { name = "mdurl", marker = "python_full_version < '3.10'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.10'",
+]
+dependencies = [
+    { name = "mdurl", marker = "python_full_version >= '3.10'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py", version = "3.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "markdown-it-py", version = "4.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
+[[package]]
+name = "span-table"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "rich" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "rich", specifier = ">=15.0.0" }]