tableio 0.3__tar.gz → 0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tableio
-Version: 0.3
+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>
@@ -17,8 +17,8 @@ Requires-Dist: build>=1.4.2
 Requires-Dist: wheel>=0.46.3
 Requires-Dist: mformat-ext>=0.6
 Requires-Dist: openpyxl>=3.1.5
-Requires-Dist: types-openpyxl>=3.1.5.20260322
-Requires-Dist: odfdo>=3.22.3
+Requires-Dist: types-openpyxl>=3.1.5.20260402
+Requires-Dist: odfdo>=3.22.4
 Requires-Dist: xlsxwriter>=3.2.9
 Requires-Dist: pylightxl>=1.61
 Dynamic: author
@@ -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,14 +139,16 @@ a better start by reading the examples.
 
 | Version | Date        | Python version | Comment                     |
 |---------|-------------|----------------|-----------------------------|
-| 0.3     | 2023 Apr 01 | 3.12 or newer  | Improved API, more backends |
+| 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  |
 | 0.1     | 2026 Mar 23 | 3.12 or newer  | First released version      |
 
 ## Test summary
 
-- Test result: 1010 passed in 14s
+- Test result: 1173 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.3
+- Built version(s): 0.5
 - Build and test using Python 3.14.3

{tableio-0.3 → 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: 1010 passed in 14s
+- Test result: 1173 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.3
+- Built version(s): 0.5
 - Build and test using Python 3.14.3

{tableio-0.3 → 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,14 +111,16 @@ a better start by reading the examples.
 
 | Version | Date        | Python version | Comment                     |
 |---------|-------------|----------------|-----------------------------|
-| 0.3     | 2023 Apr 01 | 3.12 or newer  | Improved API, more backends |
+| 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  |
 | 0.1     | 2026 Mar 23 | 3.12 or newer  | First released version      |
 
 ## Test summary
 
-- Test result: 1010 passed in 14s
+- Test result: 1173 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.3
+- Built version(s): 0.5
 - Build and test using Python 3.14.3

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

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

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

@@ -5,7 +5,7 @@ from setuptools import setup
 
 setup(
   name='tableio',
-  version='0.3',
+  version='0.5',
   description='Uniform way to write table data to and read from different ' \
     'file formats',
   author='Tom Björkholm',
@@ -21,8 +21,8 @@ setup(
     'wheel >= 0.46.3',
     'mformat-ext >= 0.6',
     'openpyxl >= 3.1.5',
-    'types-openpyxl >= 3.1.5.20260322',
-    'odfdo >= 3.22.3',
+    'types-openpyxl >= 3.1.5.20260402',
+    'odfdo >= 3.22.4',
     'xlsxwriter >= 3.2.9',
     'pylightxl >= 1.61'
   ]

{tableio-0.3 → 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/_archive_rewrite.py

@@ -0,0 +1,80 @@
+#! /usr/bin/env python3
+"""Helpers for rewriting spreadsheet ZIP archives safely.
+
+Spreadsheet writers first save library output to a temporary archive.
+These helpers then build a rewritten copy in a second temporary archive
+and replace the first archive only after both ZIP files are closed.
+"""
+
+# Copyright (c) 2026 Tom Björkholm
+# MIT License
+
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from typing import Callable, Optional
+from zipfile import ZIP_DEFLATED, ZipFile, ZipInfo
+
+
+def temporary_output_path(source_path: Path, suffix: str) -> Path:
+    """Return one missing temporary path next to ``source_path``.
+
+    The temporary file is created in the same directory as
+    ``source_path`` so a later ``Path.replace()`` stays on the same
+    filesystem. The file name uses ``suffix`` and the returned path does
+    not exist when this function returns.
+    """
+    with NamedTemporaryFile(delete=False, dir=source_path.parent,
+                            suffix=suffix) as temp_file:
+        temp_path = Path(temp_file.name)
+    temp_path.unlink()
+    return temp_path
+
+
+def rewrite_zip_archive(
+        archive_path: Path,
+        rewrite_entry: Callable[[ZipInfo, bytes], Optional[bytes]],
+        extra_entries: Optional[dict[str, bytes]] = None) -> None:
+    """Rewrite one ZIP archive by copying it into a new archive.
+
+    The original archive at ``archive_path`` is read entry by entry and
+    a rewritten archive is written to a sibling temporary file. The
+    callback receives each original ``ZipInfo`` together with its bytes.
+    Returning ``None`` drops the entry. Any mapping passed in
+    ``extra_entries`` is appended after copied entries, except for names
+    that were already written.
+
+    The original archive is replaced only after both ZIP files have been
+    closed. This avoids replacing an archive while it is still open,
+    which is a safer pattern on Windows as well as on Unix-like systems.
+
+    Args:
+        archive_path: Path to the archive to rewrite in place.
+        rewrite_entry: Callback invoked once for each original ZIP entry.
+            The callback receives the original ``ZipInfo`` together with
+            the entry bytes. It returns replacement bytes for the output
+            archive, or ``None`` to drop the entry completely.
+        extra_entries: Optional mapping of extra archive members to add
+            after copying rewritten entries. Names that were already
+            written are left unchanged.
+    """
+    temp_path = temporary_output_path(archive_path, archive_path.suffix)
+    try:
+        with ZipFile(archive_path, 'r') as source_zip, \
+                ZipFile(temp_path, 'w',
+                        compression=ZIP_DEFLATED) as target_zip:
+            written_names: set[str] = set()
+            for item in source_zip.infolist():
+                data = rewrite_entry(item, source_zip.read(item.filename))
+                if data is None:
+                    continue
+                target_zip.writestr(item, data)
+                written_names.add(item.filename)
+            if extra_entries is not None:
+                for entry_name, entry_data in extra_entries.items():
+                    if entry_name in written_names:
+                        continue
+                    target_zip.writestr(entry_name, entry_data)
+        temp_path.replace(archive_path)
+    finally:
+        if temp_path.exists():
+            temp_path.unlink()

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.3 → 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.3 → tableio-0.5}/src/tableio/factory.py

@@ -274,6 +274,17 @@ class FactoryFormatInfo:
             raise TableIOFactoryNoCapabilityMatch(msg)
         return ret
 
+    def correct_implementation_name(self, implementation_name: str) -> str:
+        """Correct the implementation name to the correct case."""
+        if implementation_name in self._registry:
+            return implementation_name
+        if implementation_name.lower() in self._lower2correct:
+            return self._lower2correct[implementation_name.lower()]
+        raise TableIOFactoryNoSuchError(
+            f'Implementation "{implementation_name}" is not registered. ' +
+            'Available implementations: ' +
+            f'{", ".join(list(self._registry.keys()))}')
+
 
 class TableIOFactory:
     """Factory class for creating instances of TableIO subclasses.
@@ -416,21 +427,16 @@ class TableIOFactory:
         best_matches = format_info.best_match_names(
             capabilities=capabilities, empty_is_ok=False)
         if implementation is not None:
-            fikeys = list(format_info._registry.keys())  # pylint: disable=protected-access # noqa: E501
-            if implementation not in fikeys:
-                raise TableIOFactoryNoSuchError(
-                    f'Implementation "{implementation}" is not registered. ' +
-                    'Available implementations: ' +
-                    f'{", ".join(list(fikeys))}'
-                )
+            corrected_implementation = \
+                format_info.correct_implementation_name(implementation)
             bmatches_impls = [impl.implementation
                               for impl in best_matches.combined()]
-            if implementation not in bmatches_impls:
+            if corrected_implementation not in bmatches_impls:
                 msg3 = f'Implementation "{implementation}" '
                 msg3 += 'does not match the capabilities. Available matches: '
                 msg3 += f'{", ".join(bmatches_impls)}'
                 raise TableIOFactoryNoCapabilityMatch(msg3)
-            chosen_impl = implementation
+            chosen_impl = corrected_implementation
         else:
             chosen_impl = best_matches.combined()[0].implementation
         format_class = format_info._registry[chosen_impl]  # pylint: disable=protected-access # noqa: E501