tableio 0.4__tar.gz → 0.5__tar.gz

{tableio-0.4/tableio.egg-info → tableio-0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tableio
-Version: 0.4
+Version: 0.5
 Summary: Uniform way to write table data to and read from different file formats
 Author: Tom Björkholm
 Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
@@ -115,6 +115,7 @@ The main features are:
 - using multiple sheets in spreadsheets
 - finding location where some data is present in spreadsheet and doing modifications
   at that position or at positions relative to that position.
+- several border styles for tables
 
 ## Example programs
 
@@ -138,6 +139,7 @@ a better start by reading the examples.
 
 | Version | Date        | Python version | Comment                     |
 |---------|-------------|----------------|-----------------------------|
+| 0.5     | 2026 Apr 07 | 3.12 or newer  | Added table border styles   |
 | 0.4     | 2026 Apr 06 | 3.12 or newer  | Fix .xlsx and .ods syntax   |
 | 0.3     | 2026 Apr 01 | 3.12 or newer  | Improved API, more backends |
 | 0.2     | 2026 Mar 28 | 3.12 or newer  | More features, API changes  |
@@ -145,8 +147,8 @@ a better start by reading the examples.
 
 ## Test summary
 
-- Test result: 1126 passed in 17s
+- Test result: 1173 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.4
+- Built version(s): 0.5
 - Build and test using Python 3.14.3

{tableio-0.4 → tableio-0.5}/README.md

@@ -93,8 +93,8 @@ information about the build system. This README can also be viewed at
 
 ## Test summary
 
-- Test result: 1126 passed in 17s
+- Test result: 1173 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.4
+- Built version(s): 0.5
 - Build and test using Python 3.14.3

{tableio-0.4 → tableio-0.5}/README_pypi.md

@@ -87,6 +87,7 @@ The main features are:
 - using multiple sheets in spreadsheets
 - finding location where some data is present in spreadsheet and doing modifications
   at that position or at positions relative to that position.
+- several border styles for tables
 
 ## Example programs
 
@@ -110,6 +111,7 @@ a better start by reading the examples.
 
 | Version | Date        | Python version | Comment                     |
 |---------|-------------|----------------|-----------------------------|
+| 0.5     | 2026 Apr 07 | 3.12 or newer  | Added table border styles   |
 | 0.4     | 2026 Apr 06 | 3.12 or newer  | Fix .xlsx and .ods syntax   |
 | 0.3     | 2026 Apr 01 | 3.12 or newer  | Improved API, more backends |
 | 0.2     | 2026 Mar 28 | 3.12 or newer  | More features, API changes  |
@@ -117,8 +119,8 @@ a better start by reading the examples.
 
 ## Test summary
 
-- Test result: 1126 passed in 17s
+- Test result: 1173 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.4
+- Built version(s): 0.5
 - Build and test using Python 3.14.3

{tableio-0.4 → tableio-0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tableio"
-version = "0.4"
+version = "0.5"
 authors = [
   { name="Tom Björkholm", email="klausuler_linnet0q@icloud.com" },
 ]

{tableio-0.4 → tableio-0.5}/setup.py

@@ -5,7 +5,7 @@ from setuptools import setup
 
 setup(
   name='tableio',
-  version='0.4',
+  version='0.5',
   description='Uniform way to write table data to and read from different ' \
     'file formats',
   author='Tom Björkholm',

{tableio-0.4 → tableio-0.5}/src/tableio/__init__.py

@@ -11,7 +11,8 @@ from tableio.color import Color
 from tableio.factory import create_tableio, filter_args_tableio, \
     list_implementations_tableio, list_registered_tableio
 from tableio.optional_args import CsvDialect, OptionalArgs, OptionalArgsDict
-from tableio.tableio import Box, FileAccess, Position, TableIO
+from tableio.tableio import TableIO
+from tableio.tableio_types import TableBorderStyle, Box, FileAccess, Position
 from tableio.value_type import CellT, DictData, DictDataMap, Fmt, \
     FmtDictData, FmtDictRow, FmtListData, FmtListRow, ListData, \
     ListDataSeq, ReadResult, Value, ValueFmt
@@ -20,6 +21,7 @@ __all__ = ['create_tableio',
            'TableIO',
            'FileAccess',
            'Box',
+           'TableBorderStyle',
            'Position',
            'OptionalArgs',
            'OptionalArgsDict',

tableio-0.5/src/tableio/border_helper.py

@@ -0,0 +1,196 @@
+#! /usr/bin/env python3
+"""Helpers for working with normalized table borders."""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+from enum import IntEnum
+from typing import NamedTuple, Optional
+
+from tableio.capability import Capabilities, CapabilityNotSupported, \
+    Strictness
+from tableio.tableio_types import TableBorderStyle
+from tableio.value_type import Fmt
+
+
+class BorderWeight(IntEnum):
+    """Semantic weight for one border edge."""
+
+    NONE = 0
+    THIN = 1
+    THICK = 2
+
+
+class CellBorder(NamedTuple):
+    """Border weights for the four edges of one cell."""
+
+    top: BorderWeight
+    right: BorderWeight
+    bottom: BorderWeight
+    left: BorderWeight
+
+
+NO_BORDERS = CellBorder(
+    BorderWeight.NONE,
+    BorderWeight.NONE,
+    BorderWeight.NONE,
+    BorderWeight.NONE)
+"""The absence of borders on all four cell edges."""
+
+
+class CellStyleState(NamedTuple):
+    """Combined cell formatting state used by style-caching backends."""
+
+    fmt: Fmt = Fmt()
+    font_size: Optional[int] = None
+    borders: CellBorder = NO_BORDERS
+
+
+DEFAULT_CELL_STYLE = CellStyleState()
+"""The default cell formatting state with no extra styling."""
+
+
+class _BorderComponents(NamedTuple):
+    """Normalized border weights for one table style."""
+
+    outer: BorderWeight
+    first_row_separator: BorderWeight
+    inner_horizontal: BorderWeight
+    inner_vertical: BorderWeight
+
+
+def _thicker(first: BorderWeight, second: BorderWeight) -> BorderWeight:
+    """Return the thicker of two border weights."""
+    if first >= second:
+        return first
+    return second
+
+
+_STYLE_COMPONENTS: dict[TableBorderStyle, _BorderComponents] = {
+    TableBorderStyle.NONE: _BorderComponents(
+        outer=BorderWeight.NONE,
+        first_row_separator=BorderWeight.NONE,
+        inner_horizontal=BorderWeight.NONE,
+        inner_vertical=BorderWeight.NONE),
+    TableBorderStyle.OUTER_THIN: _BorderComponents(
+        outer=BorderWeight.THIN,
+        first_row_separator=BorderWeight.NONE,
+        inner_horizontal=BorderWeight.NONE,
+        inner_vertical=BorderWeight.NONE),
+    TableBorderStyle.OUTER_THICK: _BorderComponents(
+        outer=BorderWeight.THICK,
+        first_row_separator=BorderWeight.NONE,
+        inner_horizontal=BorderWeight.NONE,
+        inner_vertical=BorderWeight.NONE),
+    TableBorderStyle.OUTER_FIRST_ROW_THIN: _BorderComponents(
+        outer=BorderWeight.THIN,
+        first_row_separator=BorderWeight.THIN,
+        inner_horizontal=BorderWeight.NONE,
+        inner_vertical=BorderWeight.NONE),
+    TableBorderStyle.OUTER_FIRST_ROW_THICK: _BorderComponents(
+        outer=BorderWeight.THICK,
+        first_row_separator=BorderWeight.THICK,
+        inner_horizontal=BorderWeight.NONE,
+        inner_vertical=BorderWeight.NONE),
+    TableBorderStyle.OUTER_THICK_FIRST_ROW_THIN: _BorderComponents(
+        outer=BorderWeight.THICK,
+        first_row_separator=BorderWeight.THIN,
+        inner_horizontal=BorderWeight.NONE,
+        inner_vertical=BorderWeight.NONE),
+    TableBorderStyle.OUTER_FIRST_ROW_THICK_VERTICAL_THIN:
+        _BorderComponents(
+            outer=BorderWeight.THICK,
+            first_row_separator=BorderWeight.THICK,
+            inner_horizontal=BorderWeight.NONE,
+            inner_vertical=BorderWeight.THIN),
+    TableBorderStyle.OUTER_FIRST_ROW_THICK_INNER_THIN: _BorderComponents(
+        outer=BorderWeight.THICK,
+        first_row_separator=BorderWeight.THICK,
+        inner_horizontal=BorderWeight.THIN,
+        inner_vertical=BorderWeight.THIN),
+    TableBorderStyle.OUTER_THICK_INNER_THIN: _BorderComponents(
+        outer=BorderWeight.THICK,
+        first_row_separator=BorderWeight.NONE,
+        inner_horizontal=BorderWeight.THIN,
+        inner_vertical=BorderWeight.THIN),
+    TableBorderStyle.ALL_THIN: _BorderComponents(
+        outer=BorderWeight.THIN,
+        first_row_separator=BorderWeight.NONE,
+        inner_horizontal=BorderWeight.THIN,
+        inner_vertical=BorderWeight.THIN),
+    TableBorderStyle.ALL_THICK: _BorderComponents(
+        outer=BorderWeight.THICK,
+        first_row_separator=BorderWeight.NONE,
+        inner_horizontal=BorderWeight.THICK,
+        inner_vertical=BorderWeight.THICK)
+}
+
+
+class BorderHelper:
+    """Normalize one public table-border style for backend use."""
+
+    def __init__(self, border_style: TableBorderStyle,
+                 capabilities: Capabilities):
+        """Initialize the normalized table-border helper."""
+        self.border_style = self._checked_style(border_style, capabilities)
+        components = _STYLE_COMPONENTS[self.border_style]
+        self.outer = components.outer
+        self.first_row_separator = components.first_row_separator
+        self.inner_horizontal = components.inner_horizontal
+        self.inner_vertical = components.inner_vertical
+
+    @staticmethod
+    def _checked_style(border_style: TableBorderStyle,
+                       capabilities: Capabilities) -> TableBorderStyle:
+        """Return the effective border style after capability handling."""
+        if border_style == TableBorderStyle.NONE:
+            return border_style
+        capability = capabilities.can_write_borders
+        if capability.supported:
+            return border_style
+        if capability.strictness == Strictness.IGNORE:
+            return TableBorderStyle.NONE
+        raise CapabilityNotSupported('write borders to the table')
+
+    def has_borders(self) -> bool:
+        """Return whether any border is active in this normalized style."""
+        return (
+            self.outer != BorderWeight.NONE or
+            self.first_row_separator != BorderWeight.NONE or
+            self.inner_horizontal != BorderWeight.NONE or
+            self.inner_vertical != BorderWeight.NONE)
+
+    def _horizontal_boundary(self, boundary_index: int,
+                             row_count: int) -> BorderWeight:
+        """Return the weight of one horizontal table boundary."""
+        if boundary_index in (0, row_count):
+            weight = self.outer
+        else:
+            weight = self.inner_horizontal
+        if boundary_index == 1:
+            weight = _thicker(weight, self.first_row_separator)
+        return weight
+
+    def _vertical_boundary(self, boundary_index: int,
+                           column_count: int) -> BorderWeight:
+        """Return the weight of one vertical table boundary."""
+        if boundary_index in (0, column_count):
+            return self.outer
+        return self.inner_vertical
+
+    def cell_border(self, row_index: int, column_index: int, row_count: int,
+                    column_count: int) -> CellBorder:
+        """Return the four border edges for one cell in a table."""
+        if row_count < 1:
+            raise ValueError('row_count must be at least 1.')
+        if column_count < 1:
+            raise ValueError('column_count must be at least 1.')
+        if not 0 <= row_index < row_count:
+            raise ValueError('row_index is outside the table.')
+        if not 0 <= column_index < column_count:
+            raise ValueError('column_index is outside the table.')
+        return CellBorder(
+            top=self._horizontal_boundary(row_index, row_count),
+            right=self._vertical_boundary(column_index + 1, column_count),
+            bottom=self._horizontal_boundary(row_index + 1, row_count),
+            left=self._vertical_boundary(column_index, column_count))

{tableio-0.4 → tableio-0.5}/src/tableio/capability.py

@@ -90,6 +90,9 @@ class Capabilities(NamedTuple):
     can_find_value_position: SingleCapability = SingleCapability()
     """The reader/writer class can find the position of a value."""
 
+    can_write_borders: SingleCapability = SingleCapability()
+    """The writer class can write borders to the table."""
+
 
 def single_capability_match(offered: SingleCapability,
                             will_use: SingleCapability,
@@ -246,4 +249,5 @@ CAP_ALL_IMPLEMENTED = Capabilities(can_read=CAP_IMPLEMENTED,
                                    can_read_box=CAP_IMPLEMENTED,
                                    can_write_highlight=CAP_IMPLEMENTED,
                                    multi_sheet=CAP_IMPLEMENTED,
-                                   can_find_value_position=CAP_IMPLEMENTED)
+                                   can_find_value_position=CAP_IMPLEMENTED,
+                                   can_write_borders=CAP_IMPLEMENTED)

{tableio-0.4 → tableio-0.5}/src/tableio/tableio.py

@@ -12,11 +12,13 @@ from typing import NamedTuple, Callable, Optional
 from mformat.mformat import PathLike
 from tableio.capability import Capabilities, SingleCapability, Strictness, \
     CapabilityNotSupported
-from tableio.tableio_types import Box, Descriptor, FileAccess, Position
+from tableio.tableio_types import Box, Descriptor, FileAccess, Position, \
+    TableBorderStyle
 from tableio.value_type import CellT, ListDataSeq, DictDataMap, \
     normalize_dict_data, ReadResult, ListData, Value, Fmt, DictData, \
     FmtListData, FmtDictData, FmtDictRow, row_strip_format_list, \
     row_strip_format_dict
+from tableio.border_helper import BorderHelper
 
 __all__ = ['Box', 'Descriptor', 'FileAccess', 'Position', 'TableIO']
 
@@ -174,6 +176,8 @@ class TableIO:
         """If True, data will be written as a range that can be filtered."""
         box: Optional[Box]
         """The box to write the data into."""
+        borders: BorderHelper
+        """The normalized borders of the table."""
 
     class ImplMetaForDictWrite(NamedTuple):
         """Meta data for writing dict table to pass to implementation."""
@@ -185,22 +189,26 @@ class TableIO:
         first_row_format: Optional[Fmt]
         """The format specification for the first row."""
 
-    def write_table_listdata(self, data: ListDataSeq[CellT],
-                             filtered_data_range: bool = False,
-                             box: Optional[Box] = None) -> Position:
+    def write_table_listdata(
+            self, data: ListDataSeq[CellT],
+            filtered_data_range: bool = False,
+            box: Optional[Box] = None,
+            border_style: TableBorderStyle = TableBorderStyle.NONE) -> \
+            Position:
         """Write a table of list data to the file.
 
         Write a table of list data to the file.
         If a box is provided the data will be written into the box.
         The data must fit into the box.
-        Notice when spefifying a box: It is not allowed to write a
+        Notice when specifying a box: It is not allowed to write a
         table that partly overwrites an existing table.
         Args:
             data: The list data to write.
             filtered_data_range: If True, the data written will be
                                  marked as a data range that can be filtered.
             box: The box to write the data into. If box.bottom or box.right is
-                not None, the data must fill the box.
+                 not None, the data must fill the box.
+            border_style: The border style to apply to the written table.
         Raises:
             ValueError: If the data shape is invalid or does not fit in box.
             CapabilityNotSupported: If a requested capability is unsupported
@@ -214,27 +222,33 @@ class TableIO:
         c_box = self._check_box_write(box)
         self._check_listdimensions(data, c_box)
         c_filt_range = self._check_filtered_data_range(filtered_data_range)
+        c_borders = self._check_border_style(border_style)
         impl_meta: TableIO.ImplMetaForWrite = \
             TableIO.ImplMetaForWrite(filtered_data_range=c_filt_range,
-                                     box=c_box)
+                                     box=c_box,
+                                     borders=c_borders)
         return self._write_table_listdata(data=data, impl_meta=impl_meta)
 
-    def write_table_fmtlistdata(self, data: FmtListData,
-                                filtered_data_range: bool = False,
-                                box: Optional[Box] = None) -> Position:
+    def write_table_fmtlistdata(
+            self, data: FmtListData,
+            filtered_data_range: bool = False,
+            box: Optional[Box] = None,
+            border_style: TableBorderStyle = TableBorderStyle.NONE) -> \
+            Position:
         """Write a table of list data to the file.
 
         Write a table of list data to the file.
         If a box is provided the data will be written into the box.
         The data must fit into the box.
-        Notice when spefifying a box: It is not allowed to write a
+        Notice when specifying a box: It is not allowed to write a
         table that partly overwrites an existing table.
         Args:
             data: The list data to write.
             filtered_data_range: If True, the data written will be
                                  marked as a data range that can be filtered.
             box: The box to write the data into. If box.bottom or box.right is
-                not None, the data must fill the box.
+                 not None, the data must fill the box.
+            border_style: The border style to apply to the written table.
         Raises:
             ValueError: If the data shape is invalid or does not fit in box.
             CapabilityNotSupported: If a requested capability is unsupported
@@ -248,25 +262,28 @@ class TableIO:
         c_box = self._check_box_write(box)
         self._check_listdimensions(row_strip_format_list(data), c_box)
         c_filt_range = self._check_filtered_data_range(filtered_data_range)
+        c_borders = self._check_border_style(border_style)
         impl_meta: TableIO.ImplMetaForWrite = \
             TableIO.ImplMetaForWrite(filtered_data_range=c_filt_range,
-                                     box=c_box)
+                                     box=c_box, borders=c_borders)
         return self._write_table_fmtlistdata(data=data, impl_meta=impl_meta)
 
-    def write_table_dictdata(self,  # pylint: disable=too-many-arguments,too-many-positional-arguments # noqa: E501
-                             data: DictDataMap[CellT],
-                             column_order: list[str],
-                             first_row_format: Optional[Fmt] = None,
-                             missing_ok: bool = False,
-                             extra_ok: bool = False,
-                             filtered_data_range: bool = False,
-                             box: Optional[Box] = None) -> Position:
+    def write_table_dictdata(  # pylint: disable=too-many-arguments,too-many-positional-arguments # noqa: E501
+            self, data: DictDataMap[CellT],
+            column_order: list[str],
+            first_row_format: Optional[Fmt] = None,
+            missing_ok: bool = False,
+            extra_ok: bool = False,
+            filtered_data_range: bool = False,
+            box: Optional[Box] = None,
+            border_style: TableBorderStyle = TableBorderStyle.NONE) -> \
+            Position:
         """Write a table of dict data to the file.
 
         Write a table of dict data to the file.
         If a box is provided the data will be written into the box.
         The data must fit into the box.
-        Notice when spefifying a box: It is not allowed to write a
+        Notice when specifying a box: It is not allowed to write a
         table that partly overwrites an existing table.
         Args:
             data: The dict data to write.
@@ -284,7 +301,8 @@ class TableIO:
             filtered_data_range: If True, the data written will be
                                  marked as a data range that can be filtered.
             box: The box to write the data into. If box.bottom or box.right is
-                not None, the data must fill the box.
+                 not None, the data must fill the box.
+            border_style: The border style to apply to the written table.
         Raises:
             ValueError: If missing_ok is False and data is missing for a
                         column in the column_order.
@@ -303,29 +321,32 @@ class TableIO:
         ndata = normalize_dict_data(data, column_order, missing_ok, extra_ok)
         self._check_dictdimensions(ndata, c_box)
         c_filt_range = self._check_filtered_data_range(filtered_data_range)
+        c_borders = self._check_border_style(border_style)
         common_impl: TableIO.ImplMetaForWrite = \
             TableIO.ImplMetaForWrite(filtered_data_range=c_filt_range,
-                                     box=c_box)
+                                     box=c_box, borders=c_borders)
         impl_meta: TableIO.ImplMetaForDictWrite = \
             TableIO.ImplMetaForDictWrite(common_impl=common_impl,
                                          column_order=column_order,
                                          first_row_format=first_row_format)
         return self._write_table_dictdata(data=ndata, impl_meta=impl_meta)
 
-    def write_table_fmtdictdata(self,  # pylint: disable=too-many-arguments,too-many-positional-arguments # noqa: E501
-                                data: FmtDictData,
-                                column_order: list[str],
-                                first_row_format: Optional[Fmt] = None,
-                                missing_ok: bool = False,
-                                extra_ok: bool = False,
-                                filtered_data_range: bool = False,
-                                box: Optional[Box] = None) -> Position:
+    def write_table_fmtdictdata(  # pylint: disable=too-many-arguments,too-many-positional-arguments # noqa: E501
+            self, data: FmtDictData,
+            column_order: list[str],
+            first_row_format: Optional[Fmt] = None,
+            missing_ok: bool = False,
+            extra_ok: bool = False,
+            filtered_data_range: bool = False,
+            box: Optional[Box] = None,
+            border_style: TableBorderStyle = TableBorderStyle.NONE) -> \
+            Position:
         """Write a table of dict data to the file.
 
         Write a table of dict data to the file.
         If a box is provided the data will be written into the box.
         The data must fit into the box.
-        Notice when spefifying a box: It is not allowed to write a
+        Notice when specifying a box: It is not allowed to write a
         table that partly overwrites an existing table.
         Args:
             data: The dict data to write.
@@ -343,7 +364,8 @@ class TableIO:
             filtered_data_range: If True, the data written will be
                                  marked as a data range that can be filtered.
             box: The box to write the data into. If box.bottom or box.right is
-                not None, the data must fill the box.
+                 not None, the data must fill the box.
+            border_style: The border style to apply to the written table.
         Raises:
             ValueError: If missing_ok is False and data is missing for a
                         column in the column_order.
@@ -370,10 +392,12 @@ class TableIO:
                 FmtDictRow(values=row_values, fmt=row.fmt)
                 for row, row_values in zip(data, normalized_values,
                                            strict=True)]
-        c_filt_range = self._check_filtered_data_range(filtered_data_range)
         common_impl: TableIO.ImplMetaForWrite = \
-            TableIO.ImplMetaForWrite(filtered_data_range=c_filt_range,
-                                     box=c_box)
+            TableIO.ImplMetaForWrite(
+                filtered_data_range=self._check_filtered_data_range(
+                    filtered_data_range),
+                box=c_box,
+                borders=self._check_border_style(border_style))
         impl_meta: TableIO.ImplMetaForDictWrite = \
             TableIO.ImplMetaForDictWrite(common_impl=common_impl,
                                          column_order=column_order,
@@ -749,6 +773,11 @@ class TableIO:
             return False
         raise CapabilityNotSupported('write a filtered data range')
 
+    def _check_border_style(self, border_style: TableBorderStyle) -> \
+            BorderHelper:
+        """Check if the requested table border style is supported."""
+        return BorderHelper(border_style, self.get_capabilities())
+
     def _write_heading(self, heading: str, level: int) -> Position:
         """Write a heading to the file.
 

{tableio-0.4 → tableio-0.5}/src/tableio/tableio_csv.py

@@ -181,7 +181,8 @@ class TableIOCsv(TableIOTextBased):
                             filtered_data_range=not_sup_ignore,
                             can_write_box=not_sup_strict,
                             can_read_box=not_sup_strict,
-                            can_write_highlight=not_sup_ignore)
+                            can_write_highlight=not_sup_ignore,
+                            can_write_borders=not_sup_ignore)
 
     def _end_state(self) -> None:
         """End the state of the CSV file."""

{tableio-0.4 → tableio-0.5}/src/tableio/tableio_excel_openpyxl.py

@@ -8,13 +8,14 @@ from pathlib import Path
 from typing import Callable, Optional
 from xml.etree import ElementTree as ET
 from openpyxl import Workbook, load_workbook
-from openpyxl.styles import Font, PatternFill
+from openpyxl.styles import Border, Font, PatternFill, Side
 from openpyxl.utils.cell import get_column_letter, range_boundaries
 from openpyxl.worksheet.table import Table
 from openpyxl.worksheet.worksheet import Worksheet
 from mformat.mformat import PathLike
 from tableio._archive_rewrite import rewrite_zip_archive, \
     temporary_output_path
+from tableio.border_helper import BorderWeight, CellBorder
 from tableio.color import Color
 from tableio.tableio import Descriptor, FileAccess
 from tableio.tableio_excelbased import TableIOExcelBased
@@ -92,6 +93,7 @@ class TableIOExcelOpenPyXL(TableIOExcelBased):
         self.read_workbook: Optional[Workbook] = None
         self.worksheet: Optional[Worksheet] = None
         self.read_worksheet: Optional[Worksheet] = None
+        self._border_cache: dict[CellBorder, Border] = {}
 
     @classmethod
     def get_capabilities(cls) -> Capabilities:
@@ -109,6 +111,7 @@ class TableIOExcelOpenPyXL(TableIOExcelBased):
         """Open the Excel workbook."""
         if self.workbook is not None:
             raise RuntimeError(f'File {self.file_name} already open')
+        self._border_cache = {}
         if self.file_access == FileAccess.CREATE:
             workbook = Workbook()
             self.workbook = workbook
@@ -256,6 +259,35 @@ class TableIOExcelOpenPyXL(TableIOExcelBased):
         cell.font = Font(bold=fmt.bold, italic=fmt.italic)
         cell.fill = self._highlight_fill(fmt.highlight)
 
+    @staticmethod
+    def _border_side(weight: BorderWeight) -> Side:
+        """Return one OpenPyXL side object for the requested weight."""
+        if weight == BorderWeight.NONE:
+            return Side()
+        if weight == BorderWeight.THIN:
+            return Side(style='thin')
+        return Side(style='medium')
+
+    def _border_value(self, borders: CellBorder) -> Border:
+        """Return one cached OpenPyXL border object."""
+        cached = self._border_cache.get(borders)
+        if cached is not None:
+            return cached
+        border = Border(
+            left=self._border_side(borders.left),
+            right=self._border_side(borders.right),
+            top=self._border_side(borders.top),
+            bottom=self._border_side(borders.bottom))
+        self._border_cache[borders] = border
+        return border
+
+    def _set_cell_borders(self, sheet: object, row: int, column: int,
+                          borders: CellBorder) -> None:
+        """Apply normalized borders to one worksheet cell."""
+        worksheet = get_checked_type(sheet, Worksheet)
+        cell = worksheet.cell(row=row + 1, column=column + 1)
+        cell.border = self._border_value(borders)
+
     def _apply_heading_style(self, row: int, column: int, level: int) -> None:
         """Apply the heading font to one worksheet cell."""
         assert self.worksheet is not None

{tableio-0.4 → tableio-0.5}/src/tableio/tableio_excel_pylightxl.py

@@ -341,7 +341,8 @@ class TableIOExcelPylightxl(TableIOExcelBased):
                             can_read_box=CAP_IMPLEMENTED,
                             can_write_highlight=CAP_IGNORED,
                             multi_sheet=CAP_IMPLEMENTED,
-                            can_find_value_position=CAP_IMPLEMENTED)
+                            can_find_value_position=CAP_IMPLEMENTED,
+                            can_write_borders=CAP_IGNORED)
 
     def open(self) -> None:
         """Open the workbook."""