flexablelib 2.0.1__tar.gz → 2.0.3__tar.gz

{flexablelib-2.0.1 → flexablelib-2.0.3}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.0.3](https://github.com/Opus-Perpetuus/flexablelib/compare/v2.0.2...v2.0.3) (2026-10-28)
+
+### Features
+
+* ``to_excel`` / ``from_excel`` preserve merged cell ranges (openpyxl)
+
+## [2.0.2](https://github.com/Opus-Perpetuus/flexablelib/compare/v2.0.1...v2.0.2) (2026-10-28)
+
+### Bug Fixes
+
+* redraw vertical-merge vertices as edges/tees instead of leftover corners
+
 ## [2.0.1](https://github.com/Opus-Perpetuus/flexablelib/compare/v2.0.0...v2.0.1) (2026-10-28)
 
 

{flexablelib-2.0.1/flexablelib.egg-info → flexablelib-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexablelib
-Version: 2.0.1
+Version: 2.0.3
 Summary: Flexible console and HTML tables for Python
 Home-page: https://github.com/Opus-Perpetuus/flexablelib
 Download-URL: 

{flexablelib-2.0.1 → flexablelib-2.0.3}/flexablelib/merges.py

@@ -204,7 +204,12 @@ def _region_bounds(region, layout, index_offset):
         return None
 
     first, last = drawn[0], drawn[-1]
-    return (layout.spans[first][0], layout.spans[last][1]), layout.spans[first], last
+    return (
+        (layout.spans[first][0], layout.spans[last][1]),
+        layout.spans[first],
+        first,
+        last,
+    )
 
 
 def apply(lines, row_line_map, regions, column_widths, composition,
@@ -235,7 +240,7 @@ def apply(lines, row_line_map, regions, column_widths, composition,
         bounds = _region_bounds(region, layout, index_offset)
         if bounds is None:
             continue
-        (start, end), (cell_start, cell_end), last_span = bounds
+        (start, end), (cell_start, cell_end), first_span, last_span = bounds
         span_width = end - start - margin * 2
         if span_width < 1:
             continue
@@ -277,13 +282,16 @@ def apply(lines, row_line_map, regions, column_widths, composition,
         # Paint over the separator lines that fall inside the block, so the
         # merged region reads as one cell top to bottom.
         #
-        # Where such a line meets the rule at the block's right edge, that
-        # junction no longer has a line coming in from the left, so the four
-        # way character is wrong there. The body rule's own left character is
-        # exactly the three-way junction needed ('├' where '┼' was).
+        # Blanking the horizontal run removes the arms that fed each vertex.
+        # Rebuild those vertices from the style's own characters:
+        #   - right edge, more columns: body left ('├' where '┼' was)
+        #   - right edge, table border: vertical right ('│' where '┤' was)
+        #   - left edge, prior columns: body right ('┤' where '┼' was)
+        #   - left edge, table border: vertical left ('│' where '├' was)
         body_rule = composition.table_body_line
-        junction = body_rule.left if body_rule is not None else None
+        v_lines = composition.vertical_table_body_lines
         joins_more_columns = last_span + 1 < len(layout.spans)
+        joins_prev_columns = first_span > 0
 
         covered = set(target_lines)
         for line_index in range(min(target_lines), max(target_lines)):
@@ -293,8 +301,17 @@ def apply(lines, row_line_map, regions, column_widths, composition,
             if visible_width(line) < end:
                 continue
             rewritten = _repaint(line, start, end, blank)
-            if junction and joins_more_columns and visible_width(rewritten) > end:
-                rewritten = _repaint(rewritten, end, end + 1, junction)
+            if body_rule is not None or v_lines is not None:
+                if visible_width(rewritten) > end:
+                    if joins_more_columns and body_rule is not None and body_rule.left:
+                        rewritten = _repaint(rewritten, end, end + 1, body_rule.left)
+                    elif not joins_more_columns and v_lines is not None and v_lines.right:
+                        rewritten = _repaint(rewritten, end, end + 1, v_lines.right)
+                if start > 0:
+                    if joins_prev_columns and body_rule is not None and body_rule.right:
+                        rewritten = _repaint(rewritten, start - 1, start, body_rule.right)
+                    elif not joins_prev_columns and v_lines is not None and v_lines.left:
+                        rewritten = _repaint(rewritten, start - 1, start, v_lines.left)
             lines[line_index] = rewritten
 
     return lines

{flexablelib-2.0.1 → flexablelib-2.0.3}/flexablelib/readers.py

@@ -344,7 +344,8 @@ def from_excel(table_class, path, sheet=None, has_header: bool = True,
             'Install it with: pip install flexablelib[excel]'
         )
 
-    workbook = load_workbook(filename=path, read_only=True, data_only=True)
+    # read_only hides merged cell ranges; we need them to rebuild merges.
+    workbook = load_workbook(filename=path, read_only=False, data_only=True)
     try:
         if sheet is None:
             worksheet = workbook.active
@@ -357,14 +358,44 @@ def from_excel(table_class, path, sheet=None, has_header: bool = True,
             ['' if cell is None else cell for cell in row]
             for row in worksheet.iter_rows(values_only=True)
         ]
+        merge_ranges = [
+            (merged.min_row, merged.min_col, merged.max_row, merged.max_col)
+            for merged in worksheet.merged_cells.ranges
+        ]
     finally:
         workbook.close()
 
     if not rows:
         return table_class(**options)
     if has_header:
-        return _new_table(table_class, rows[0], rows[1:], parse_numbers,
-                          **options)
-    width = max(len(row) for row in rows)
-    headers = [f'column {i + 1}' for i in range(width)]
-    return _new_table(table_class, headers, rows, parse_numbers, **options)
+        table = _new_table(table_class, rows[0], rows[1:], parse_numbers,
+                           **options)
+        header_rows = 1
+    else:
+        width = max(len(row) for row in rows)
+        headers = [f'column {i + 1}' for i in range(width)]
+        table = _new_table(table_class, headers, rows, parse_numbers, **options)
+        header_rows = 0
+
+    # Excel rows/cols are 1-based. Body rows start after the header row when
+    # has_header is set. Skip merges that only cover the header.
+    for min_row, min_col, max_row, max_col in merge_ranges:
+        # Header-only or header-spanning merges are not table body merges.
+        if min_row <= header_rows:
+            continue
+        first_row = min_row - header_rows - 1
+        last_row = max_row - header_rows - 1
+        first_column = min_col - 1
+        last_column = max_col - 1
+        if first_row == last_row and first_column == last_column:
+            continue
+        if last_row < 0 or last_column < 0:
+            continue
+        if last_row >= table.row_count or last_column >= table.column_count:
+            continue
+        try:
+            table.merge_cells(first_row, first_column, last_row, last_column)
+        except ValueError:
+            # Overlaps or single cells from odd sheets: skip rather than fail.
+            continue
+    return table

{flexablelib-2.0.1 → flexablelib-2.0.3}/flexablelib/table.py

@@ -4127,6 +4127,7 @@ class Table(object):
         """
         Build a table from a worksheet in an .xlsx file.
 
+        Excel merged ranges are restored as ``merge_cells`` regions.
         Requires openpyxl: pip install flexablelib[excel]
         """
         from .readers import from_excel
@@ -4195,7 +4196,8 @@ class Table(object):
         Write an .xlsx workbook.
 
         Numbers are written as numbers so the spreadsheet can compute with
-        them. Requires openpyxl: pip install flexablelib[excel]
+        them. ``merged_regions`` become real Excel merges. Requires openpyxl:
+        pip install flexablelib[excel]
         """
         from .writers import to_excel
         return to_excel(self, path, sheet_name, include_index, autofit,

{flexablelib-2.0.1 → flexablelib-2.0.3}/flexablelib/writers.py

@@ -557,4 +557,26 @@ def to_excel(table, path, sheet_name: str = 'Sheet1',
     if freeze_header:
         worksheet.freeze_panes = 'A2'
 
+    # Mirror flexablelib merged regions as Excel merged cells. Table coordinates
+    # ignore the optional index column and the header row lives on Excel row 1.
+    col_offset = 2 if include_index else 1
+    for region in getattr(table, 'merged_regions', []):
+        start_row = region.first_row + 2
+        end_row = region.last_row + 2
+        start_col = region.first_column + col_offset
+        end_col = region.last_column + col_offset
+        top_left = worksheet.cell(row=start_row, column=start_col)
+        if region.value is not None:
+            top_left.value = _plain(region.value)
+        top_left.alignment = Alignment(
+            horizontal={'l': 'left', 'r': 'right', 'c': 'center'}.get(
+                region.align, 'center'),
+            vertical='center',
+            wrap_text=True,
+        )
+        worksheet.merge_cells(
+            start_row=start_row, start_column=start_col,
+            end_row=end_row, end_column=end_col,
+        )
+
     workbook.save(path)

{flexablelib-2.0.1 → flexablelib-2.0.3/flexablelib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flexablelib
-Version: 2.0.1
+Version: 2.0.3
 Summary: Flexible console and HTML tables for Python
 Home-page: https://github.com/Opus-Perpetuus/flexablelib
 Download-URL: 

{flexablelib-2.0.1 → flexablelib-2.0.3}/flexablelib.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ flexablelib.egg-info/requires.txt
 flexablelib.egg-info/top_level.txt
 tests/test_cells.py
 tests/test_columns.py
+tests/test_excel.py
 tests/test_features.py
 tests/test_issues.py
 tests/test_merges.py

{flexablelib-2.0.1 → flexablelib-2.0.3}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flexablelib",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Flexible console and HTML tables for Python: styles, merges, colors, widths, decimal alignment.",
   "main": "__init__.py",
   "scripts": {

flexablelib-2.0.3/tests/test_excel.py

@@ -0,0 +1,110 @@
+"""
+Excel import / export.
+
+Round-trips plain tables and merged regions through openpyxl workbooks.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from flexablelib import Table
+
+
+pytest.importorskip('openpyxl')
+
+
+def build_table():
+    table = Table()
+    table.add_column('Region', ['Norte', 'Norte', 'Sur', 'Sur'])
+    table.add_column('Month', ['Jan', 'Feb', 'Jan', 'Feb'])
+    table.add_column('Sales', [120.5, 98.25, 210.0, 175.75])
+    return table
+
+
+def test_to_excel_and_from_excel_round_trip_values(tmp_path):
+    path = tmp_path / 'plain.xlsx'
+    table = build_table()
+    table.to_excel(path)
+
+    loaded = Table.from_excel(path)
+
+    assert loaded.headers == ['Region', 'Month', 'Sales']
+    assert loaded.rows[0][0] == 'Norte'
+    assert loaded.rows[0][2] == 120.5
+
+
+def test_to_excel_writes_merged_cells(tmp_path):
+    from openpyxl import load_workbook
+
+    path = tmp_path / 'merged.xlsx'
+    table = build_table()
+    table.merge_cells(0, 0, last_row=1, value='Norte')
+    table.merge_cells(0, 1, last_column=2, value='Q1')
+    table.to_excel(path)
+
+    workbook = load_workbook(path)
+    ranges = {str(r) for r in workbook.active.merged_cells.ranges}
+    workbook.close()
+
+    assert 'A2:A3' in ranges
+    assert 'B2:C2' in ranges
+
+
+def test_from_excel_restores_merged_regions(tmp_path):
+    path = tmp_path / 'round.xlsx'
+    table = build_table()
+    table.merge_cells(0, 0, last_row=1, value='Norte')
+    table.merge_cells(2, 0, last_column=1, value='Sur block')
+    table.to_excel(path)
+
+    loaded = Table.from_excel(path)
+
+    assert len(loaded.merged_regions) == 2
+    regions = {(r.first_row, r.first_column, r.last_row, r.last_column)
+               for r in loaded.merged_regions}
+    assert (0, 0, 1, 0) in regions
+    assert (2, 0, 2, 1) in regions
+    assert 'Norte' in str(loaded)
+    assert 'Sur block' in str(loaded)
+
+
+def test_to_excel_shifts_merges_when_index_included(tmp_path):
+    from openpyxl import load_workbook
+
+    path = tmp_path / 'indexed.xlsx'
+    table = build_table()
+    table.show_index = True
+    table.merge_cells(0, 0, last_row=1, value='Norte')
+    table.to_excel(path, include_index=True)
+
+    workbook = load_workbook(path)
+    ranges = {str(r) for r in workbook.active.merged_cells.ranges}
+    workbook.close()
+
+    # Index column is A; body Region is B → B2:B3
+    assert 'B2:B3' in ranges
+
+
+def test_from_excel_sheet_selection(tmp_path):
+    from openpyxl import Workbook
+
+    path = tmp_path / 'multi.xlsx'
+    workbook = Workbook()
+    first = workbook.active
+    first.title = 'One'
+    first.append(['A'])
+    first.append([1])
+    second = workbook.create_sheet('Two')
+    second.append(['X', 'Y'])
+    second.append(['x1', 'y1'])
+    second.append(['x2', 'y2'])
+    second.merge_cells('A2:A3')
+    workbook.save(path)
+    workbook.close()
+
+    loaded = Table.from_excel(path, sheet='Two')
+    assert loaded.headers == ['X', 'Y']
+    assert len(loaded.merged_regions) == 1
+    region = loaded.merged_regions[0]
+    assert (region.first_row, region.first_column, region.last_row, region.last_column) == (0, 0, 1, 0)

{flexablelib-2.0.1 → flexablelib-2.0.3}/tests/test_merges.py

@@ -51,6 +51,65 @@ def test_a_vertical_merge_removes_the_rules_between_its_rows():
     assert rendered.count('Norte') == 1
 
 
+
+def test_vertical_merge_turns_left_border_into_an_edge():
+    """Vertices on a body rule inside a vertical merge must become edges.
+
+    The horizontal arms into the merged cell are gone, so a left-border
+    '├' becomes the vertical edge '│', and the right junction keeps the
+    three-way '├' that opens the remaining columns.
+    """
+    table = build_table()
+    table.merge_cells(0, 0, last_row=1, value='Norte')
+
+    sep = next(
+        line for line in str(table).splitlines()
+        if '├───────┼────────┤' in line or line.startswith('│        ├')
+    )
+
+    assert sep.startswith('│')
+    assert '├───────┼────────┤' in sep
+    assert not sep.startswith('├')
+
+
+def test_vertical_merge_in_middle_column_uses_left_and_right_tees():
+    table = build_table()
+    table.merge_cells(0, 1, last_row=1, value='M')
+
+    sep = next(line for line in str(table).splitlines() if '       ' in line and '┤' in line and line.count('├') >= 1)
+
+    assert '├────────┤       ├────────┤' in sep
+
+
+def test_vertical_merge_on_last_column_turns_right_border_into_an_edge():
+    table = build_table()
+    table.merge_cells(0, 2, last_row=1, value='S')
+
+    sep = next(line for line in str(table).splitlines() if line.endswith('│') and '┤        │' in line)
+
+    assert sep.endswith('│')
+    assert '├────────┼───────┤        │' in sep
+
+
+def test_vertical_merge_vertices_follow_grid_ascii_style():
+    table = build_table('grid')
+    table.merge_cells(0, 0, last_row=1, value='Norte')
+
+    sep = next(line for line in str(table).splitlines() if '+-------+' in line and line.startswith('|'))
+
+    assert sep.startswith('|        +')
+
+
+def test_vertical_merge_vertices_follow_bold_borderline_style():
+    table = build_table('bold_borderline')
+    table.merge_cells(0, 0, last_row=1, value='Norte')
+
+    sep = next(line for line in str(table).splitlines() if '╟───────┼────────╢' in line)
+
+    assert sep.startswith('║')
+    assert '║        ╟───────┼────────╢' in sep
+
+
 def test_a_block_merge_covers_both_directions():
     table = build_table()
     table.merge_cells(0, 0, 1, 1, value='Block')