tableio 0.6__tar.gz → 0.7__tar.gz

{tableio-0.6/tableio.egg-info → tableio-0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tableio
-Version: 0.6
+Version: 0.7
 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>
@@ -11,14 +11,14 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pip>=26.0.1
+Requires-Dist: pip>=26.1.1
 Requires-Dist: setuptools>=82.0.1
-Requires-Dist: build>=1.4.2
-Requires-Dist: wheel>=0.46.3
+Requires-Dist: build>=1.5.0
+Requires-Dist: wheel>=0.47.0
 Requires-Dist: mformat-ext>=0.6
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: types-openpyxl>=3.1.5.20260402
-Requires-Dist: odfdo>=3.22.4
+Requires-Dist: odfdo>=3.22.7
 Requires-Dist: xlsxwriter>=3.2.9
 Requires-Dist: pylightxl>=1.61
 Dynamic: author
@@ -135,20 +135,10 @@ readers/writers to the factory.
 Even though the API documentation exists, most users and programmers probably get
 a better start by reading the examples.
 
-## Version history
-
-| 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  |
-| 0.1     | 2026 Mar 23 | 3.12 or newer  | First released version      |
-
 ## Test summary
 
-- Test result: 1173 passed in 18s
+- Test result: 1186 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.6
-- Build and test using Python 3.14.3
+- Built version(s): 0.7
+- Build and test using Python 3.14.4

{tableio-0.6 → tableio-0.7}/README.md

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

{tableio-0.6 → tableio-0.7}/README_pypi.md

@@ -107,20 +107,10 @@ readers/writers to the factory.
 Even though the API documentation exists, most users and programmers probably get
 a better start by reading the examples.
 
-## Version history
-
-| 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  |
-| 0.1     | 2026 Mar 23 | 3.12 or newer  | First released version      |
-
 ## Test summary
 
-- Test result: 1173 passed in 18s
+- Test result: 1186 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.6
-- Build and test using Python 3.14.3
+- Built version(s): 0.7
+- Build and test using Python 3.14.4

{tableio-0.6 → tableio-0.7}/pyproject.toml

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

{tableio-0.6 → tableio-0.7}/setup.py

@@ -5,7 +5,7 @@ from setuptools import setup
 
 setup(
   name='tableio',
-  version='0.6',
+  version='0.7',
   description='Uniform way to write table data to and read from different ' \
     'file formats',
   author='Tom Björkholm',
@@ -15,14 +15,14 @@ setup(
   package_dir={'tableio': 'src/tableio'},
   package_data={'tableio': ['src/py.typed']},
   install_requires=[  # pylint: disable=duplicate-code
-    'pip >= 26.0.1',
+    'pip >= 26.1.1',
     'setuptools >= 82.0.1',
-    'build >= 1.4.2',
-    'wheel >= 0.46.3',
+    'build >= 1.5.0',
+    'wheel >= 0.47.0',
     'mformat-ext >= 0.6',
     'openpyxl >= 3.1.5',
     'types-openpyxl >= 3.1.5.20260402',
-    'odfdo >= 3.22.4',
+    'odfdo >= 3.22.7',
     'xlsxwriter >= 3.2.9',
     'pylightxl >= 1.61'
   ]

{tableio-0.6 → tableio-0.7}/src/tableio/factory.py

@@ -285,6 +285,11 @@ class FactoryFormatInfo:
             'Available implementations: ' +
             f'{", ".join(list(self._registry.keys()))}')
 
+    def get_usage(self, implementation_name: str) -> Descriptor:
+        """Get usage information for one implementation."""
+        return self._usage[
+            self.correct_implementation_name(implementation_name)]
+
 
 class TableIOFactory:
     """Factory class for creating instances of TableIO subclasses.
@@ -411,34 +416,10 @@ class TableIOFactory:
                                              matched to any implementation.
         """
         _check_capabilities_for_file_access(file_access, capabilities)
-        correct_name: Optional[str] = None
-        if format_name in self._formats:
-            correct_name = format_name
-        elif format_name.lower() in self._lower2correct:
-            correct_name = self._lower2correct[format_name.lower()]
-        else:
-            raise TableIOFactoryNoSuchError(
-                f'Format "{format_name}" is not registered. ' +
-                'Available formats: ' +
-                f'{", ".join(sorted(list(self._formats.keys())))}'
-            )
-        assert correct_name is not None
-        format_info: FactoryFormatInfo = self._formats[correct_name]
-        best_matches = format_info.best_match_names(
-            capabilities=capabilities, empty_is_ok=False)
-        if implementation is not None:
-            corrected_implementation = \
-                format_info.correct_implementation_name(implementation)
-            bmatches_impls = [impl.implementation
-                              for impl in best_matches.combined()]
-            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 = corrected_implementation
-        else:
-            chosen_impl = best_matches.combined()[0].implementation
+        format_info = self._format_info(format_name)
+        chosen_impl = self._select_implementation_name(
+            format_info=format_info, implementation=implementation,
+            capabilities=capabilities)
         format_class = format_info._registry[chosen_impl]  # pylint: disable=protected-access # noqa: E501
         if args is None:
             return format_class(file_name=file_name, file_access=file_access)
@@ -447,9 +428,47 @@ class TableIOFactory:
         # mypy cannot see which TableIO subclass is being created, so it
         # cannot know which arguments are valid.
 
+    def _correct_format_name(self, format_name: str) -> str:
+        """Correct a registered format name to its stored case."""
+        if format_name in self._formats:
+            return format_name
+        if format_name.lower() in self._lower2correct:
+            return self._lower2correct[format_name.lower()]
+        msg = f'Format "{format_name}" is not registered. '
+        msg += 'Available formats: '
+        msg += f'{", ".join(sorted(list(self._formats.keys())))}'
+        raise TableIOFactoryNoSuchError(msg)
+
+    def _format_info(self, format_name: str) -> FactoryFormatInfo:
+        """Get registered format information by case-insensitive name."""
+        return self._formats[self._correct_format_name(format_name)]
+
+    @staticmethod
+    def _select_implementation_name(
+            format_info: FactoryFormatInfo,
+            implementation: Optional[str],
+            capabilities: Optional[Capabilities]) -> str:
+        """Select the implementation name matching the request."""
+        best_matches = format_info.best_match_names(
+            capabilities=capabilities, empty_is_ok=False)
+        if implementation is None:
+            return best_matches.combined()[0].implementation
+        corrected_implementation = \
+            format_info.correct_implementation_name(implementation)
+        matching_names = [
+            impl.implementation for impl in best_matches.combined()]
+        if corrected_implementation in matching_names:
+            return corrected_implementation
+        msg = f'Implementation "{implementation}" '
+        msg += 'does not match the capabilities. Available matches: '
+        msg += f'{", ".join(matching_names)}'
+        raise TableIOFactoryNoCapabilityMatch(msg)
+
     @staticmethod
     def filter_args(args: OptionalArgs, format_name: str,
-                    implementation: str) -> OptionalArgs:
+                    implementation: Optional[str],
+                    capabilities: Optional[Capabilities] = None
+                    ) -> OptionalArgs:
         """Filter the arguments for a registered format.
 
         Filter the arguments to only include the arguments that are valid for
@@ -462,23 +481,37 @@ class TableIOFactory:
             args: The arguments to filter.
             format_name: The name identifier of the format class to filter the
                          arguments for.
-            implementation: The implementation name to use.
+            implementation: The implementation name to use. If implementation
+                            is specified as None, filtering is done for the
+                            implementation create() would use with a None value
+                            for the implementation parameter.
+            capabilities: The capabilities to match. This is used to determine
+                          the implementation to use if implementation is None.
         Returns:
             The filtered arguments.
         Raises:
             TableIOFactoryNoSuchError: If the format_name is not registered
                                        or the implementation name is not
                                        registered.
+            TableIOFactoryNoCapabilityMatch: If the capabilities cannot be
+                                             matched to the selected
+                                             implementation.
         """
         factory = TableIOFactory.i_get_factory()
         return factory.i_filter_args(args=args, format_name=format_name,
-                                     implementation=implementation)
+                                     implementation=implementation,
+                                     capabilities=capabilities)
 
     def i_filter_args(self, args: OptionalArgs, format_name: str,
-                      implementation: str) -> OptionalArgs:
+                      implementation: Optional[str],
+                      capabilities: Optional[Capabilities] = None
+                      ) -> OptionalArgs:
         """Internally filter the arguments for a registered format."""
-        format_usage = self.i_get_usage(format_name=format_name,
-                                        implementation=implementation)
+        format_info = self._format_info(format_name)
+        chosen_impl = self._select_implementation_name(
+            format_info=format_info, implementation=implementation,
+            capabilities=capabilities)
+        format_usage = format_info.get_usage(chosen_impl)
         if args is None:
             return None
         assert args is not None
@@ -557,12 +590,13 @@ class TableIOFactory:
         return ret
 
     @staticmethod
-    def get_registered_implementations(format_name: Optional[str] = None,
-                                       lower: bool = False,
-                                       upper: bool = False,
-                                       capabilities: Optional[Capabilities]
-                                       = None,
-                                       empty_is_ok: bool = False) -> list[str]:
+    def get_registered_implementations(  # pylint: disable=too-many-arguments,too-many-positional-arguments # noqa: E501
+            format_name: Optional[str] = None,
+            lower: bool = False,
+            upper: bool = False,
+            capabilities: Optional[Capabilities] = None,
+            empty_is_ok: bool = False,
+            alphabetical: bool = True) -> list[str]:
         """Get a list of all registered implementation names.
 
         The list includes all registered implementation names optionally
@@ -590,6 +624,12 @@ class TableIOFactory:
                          If False, a TableIOFactoryNoCapabilityMatch
                          error is raised if no implementations match the
                          capabilities.
+            alphabetical: If True, the implementations are returned in
+                         alphabetical order. If False, the implementations
+                         are returned with the strict matches first and the
+                         nonstrict matches last. Both strict and nonstrict
+                         matches are sorted by priority, from highest to
+                         lowest.
         Returns:
             A list of registered implementation name strings optionally
             filtered to only include implementations that offer the
@@ -602,40 +642,26 @@ class TableIOFactory:
         factory = TableIOFactory.i_get_factory()
         return factory.i_get_registered_implementations(
             format_name=format_name, lower=lower, upper=upper,
-            capabilities=capabilities, empty_is_ok=empty_is_ok)
+            capabilities=capabilities, empty_is_ok=empty_is_ok,
+            alphabetical=alphabetical)
 
-    def i_get_registered_implementations(  # pylint: disable=too-many-arguments,too-many-positional-arguments # noqa: E501
+    # pylint: disable-next=too-many-arguments,too-many-positional-arguments
+    def i_get_registered_implementations(
             self, format_name: Optional[str] = None,
             lower: bool = False, upper: bool = False,
             capabilities: Optional[Capabilities] = None,
-            empty_is_ok: bool = False) -> list[str]:
+            empty_is_ok: bool = False,
+            alphabetical: bool = True) -> list[str]:
         """Internally get a list of registered implementation names."""
         fmtkeys: list[str] = list(self._formats.keys())
         if format_name is not None:
-            fmtkeys = [format_name]
-        implkeys: set[str] = set()
-        if capabilities is not None:
-            implmatches: list[BestMatch] = []
-            for fmtkey in fmtkeys:
-                format_info: FactoryFormatInfo = self._formats[fmtkey]
-                implmatches.append(
-                    format_info.best_match_names(capabilities=capabilities,
-                                                 empty_is_ok=True))
-            implkeys = {
-                impl.implementation for impl in
-                BestMatch.add_list(implmatches).combined()
-              }  # several format names may have the same implementation name
-            if not implkeys and not empty_is_ok:
-                msg = 'No implementations match the capabilities.'
-                raise TableIOFactoryNoCapabilityMatch(msg)
-        else:
-            implkeys = {
-                implkey
-                for fmtkey in fmtkeys
-                for implkey in self._formats[fmtkey]._registry.keys()  # pylint: disable=protected-access # noqa: E501
-            }
+            fmtkeys = [self._correct_format_name(format_name)]
+        best_match = self._implementation_matches(
+            format_names=fmtkeys, capabilities=capabilities,
+            empty_is_ok=empty_is_ok)
+        implkeys = self._implementation_names(best_match, alphabetical)
         ret: list[str] = []
-        for implkey in sorted(implkeys):  # order was lost using a set
+        for implkey in implkeys:
             ret.append(implkey)
             if lower and implkey != implkey.lower():
                 ret.append(implkey.lower())
@@ -643,6 +669,37 @@ class TableIOFactory:
                 ret.append(implkey.upper())
         return ret
 
+    def _implementation_matches(
+            self, format_names: list[str],
+            capabilities: Optional[Capabilities],
+            empty_is_ok: bool) -> BestMatch:
+        """Get matching implementations for the requested format names."""
+        implmatches = [
+            self._formats[format_name].best_match_names(
+                capabilities=capabilities, empty_is_ok=True)
+            for format_name in format_names
+        ]
+        best_match = BestMatch.add_list(implmatches)
+        if len(best_match) == 0 and not empty_is_ok:
+            msg = 'No implementations match the capabilities.'
+            raise TableIOFactoryNoCapabilityMatch(msg)
+        return best_match
+
+    @staticmethod
+    def _implementation_names(best_match: BestMatch,
+                              alphabetical: bool) -> list[str]:
+        """Get implementation names from best matches without duplicates."""
+        names: list[str] = []
+        seen: set[str] = set()
+        for impl in best_match.combined():
+            if impl.implementation in seen:
+                continue
+            seen.add(impl.implementation)
+            names.append(impl.implementation)
+        if alphabetical:
+            return sorted(names)
+        return names
+
     @staticmethod
     def get_usage(format_name: str, implementation: str) -> Descriptor:
         """Get the usage information for a registered format.
@@ -664,28 +721,7 @@ class TableIOFactory:
 
     def i_get_usage(self, format_name: str, implementation: str) -> Descriptor:
         """Internally get the usage information for a registered format."""
-        format_info: Optional[FactoryFormatInfo] = None
-        if format_name in self._formats:
-            format_info = self._formats[format_name]
-        elif format_name.lower() not in self._lower2correct:
-            msg1 = f'Format "{format_name}" is not registered. '
-            msg1 += 'Available formats: '
-            msg1 += f'{", ".join(sorted(list(self._formats.keys())))}'
-            raise TableIOFactoryNoSuchError(msg1)
-        else:
-            format_info = self._formats[self._lower2correct[format_name.lower()]]  # pylint: disable=protected-access # noqa: E501
-        assert format_info is not None
-        fusage = format_info._usage  # pylint: disable=protected-access # noqa: E501
-        if implementation in fusage:
-            return fusage[implementation]
-        l2correct = format_info._lower2correct  # pylint: disable=protected-access # noqa: E501
-        if implementation.lower() not in l2correct:
-            msg2 = f'Implementation "{implementation}" is not registered. '
-            msg2 += 'Available implementations: '
-            msg2 += f'{", ".join(list(format_info._registry.keys()))}'  # pylint: disable=protected-access # noqa: E501
-            raise TableIOFactoryNoSuchError(msg2)
-        correct_name = l2correct[implementation.lower()]
-        return format_info._usage[correct_name]  # pylint: disable=protected-access # noqa: E501
+        return self._format_info(format_name).get_usage(implementation)
 
 
 def create_tableio(format_name: str,  # pylint: disable=too-many-arguments, too-many-positional-arguments # noqa: E501
@@ -729,7 +765,9 @@ def create_tableio(format_name: str,  # pylint: disable=too-many-arguments, too-
 
 
 def filter_args_tableio(args: OptionalArgs, format_name: str,
-                        implementation: str) -> OptionalArgs:
+                        implementation: Optional[str],
+                        capabilities: Optional[Capabilities] = None) \
+                            -> OptionalArgs:
     """Filter the arguments for a registered format.
 
     This is a shortcut for TableIOFactory.filter_args().
@@ -743,15 +781,24 @@ def filter_args_tableio(args: OptionalArgs, format_name: str,
         args: The arguments to filter.
         format_name: The name identifier of the format class to filter
                      the arguments for.
-        implementation: The implementation name to use.
+        implementation: The implementation name to use. If implementation
+                        is specified as None, filtering is done for the
+                        implementation create() would use with a None value
+                        for the implementation parameter.
+        capabilities: The capabilities to match. This is used to determine
+                      the implementation to use if implementation is None.
     Returns:
         The filtered arguments.
     Raises:
         TableIOFactoryNoSuchError: If the format_name or implementation
                                    name is not registered.
+        TableIOFactoryNoCapabilityMatch: If the capabilities cannot be
+                                         matched to the selected
+                                         implementation.
     """
     return TableIOFactory.filter_args(args=args, format_name=format_name,
-                                      implementation=implementation)
+                                      implementation=implementation,
+                                      capabilities=capabilities)
 
 
 def list_registered_tableio(lower: bool = False,
@@ -787,11 +834,12 @@ def list_registered_tableio(lower: bool = False,
                                                  empty_is_ok=empty_is_ok)
 
 
+# pylint: disable-next=too-many-arguments,too-many-positional-arguments
 def list_implementations_tableio(format_name: Optional[str] = None,
-                                 lower: bool = False,
-                                 upper: bool = False,
+                                 lower: bool = False, upper: bool = False,
                                  capabilities: Optional[Capabilities] = None,
-                                 empty_is_ok: bool = False) -> list[str]:
+                                 empty_is_ok: bool = False,
+                                 alphabetical: bool = True) -> list[str]:
     """Get a list of all registered implementation names.
 
     This is a shortcut for TableIOFactory.get_registered_implementations().
@@ -810,6 +858,12 @@ def list_implementations_tableio(format_name: Optional[str] = None,
                      If False, a TableIOFactoryNoCapabilityMatch
                      error is raised if no implementations match the
                      capabilities.
+        alphabetical: If True, the implementations are returned in
+                     alphabetical order. If False, the implementations
+                     are returned with the strict matches first and the
+                     nonstrict matches last. Both strict and nonstrict
+                     matches are sorted by priority, from highest to
+                     lowest.
     Returns:
         A list of registered implementation name strings optionally
         filtered to only include implementations that offer the
@@ -821,7 +875,8 @@ def list_implementations_tableio(format_name: Optional[str] = None,
     """
     return TableIOFactory.get_registered_implementations(
         format_name=format_name, lower=lower, upper=upper,
-        capabilities=capabilities, empty_is_ok=empty_is_ok)
+        capabilities=capabilities, empty_is_ok=empty_is_ok,
+        alphabetical=alphabetical)
 
 
 def usage_tableio(format_name: str, implementation: str) -> Descriptor:

{tableio-0.6 → tableio-0.7}/src/tableio/tableio_excel_openpyxl.py

@@ -7,6 +7,7 @@
 from pathlib import Path
 from typing import Callable, Optional
 from xml.etree import ElementTree as ET
+from zipfile import ZipFile, ZipInfo
 from openpyxl import Workbook, load_workbook
 from openpyxl.styles import Border, Font, PatternFill, Side
 from openpyxl.utils.cell import get_column_letter, range_boundaries
@@ -27,7 +28,25 @@ _HIGHLIGHT_RGB: dict[Color, str] = {
     Color.GREEN: 'FFC6EFCE',
     Color.YELLOW: 'FFFFFF00'
 }
-_XML_NS = {'main': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'}
+_SPREADSHEET_NS = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'
+_REL_NS = 'http://schemas.openxmlformats.org/package/2006/relationships'
+_CONTENT_TYPES_NS = (
+    'http://schemas.openxmlformats.org/package/2006/content-types'
+)
+_XML_NS = {'main': _SPREADSHEET_NS}
+_REL_XML_NS = {'rel': _REL_NS}
+_CONTENT_TYPES_XML_NS = {'ct': _CONTENT_TYPES_NS}
+_SHARED_STRINGS_PATH = 'xl/sharedStrings.xml'
+_WORKBOOK_RELS_PATH = 'xl/_rels/workbook.xml.rels'
+_CONTENT_TYPES_PATH = '[Content_Types].xml'
+_SHARED_STRINGS_REL_TYPE = (
+    'http://schemas.openxmlformats.org/officeDocument/2006/'
+    'relationships/sharedStrings'
+)
+_SHARED_STRINGS_CONTENT_TYPE = (
+    'application/vnd.openxmlformats-officedocument.'
+    'spreadsheetml.sharedStrings+xml'
+)
 _FONT_CHILD_ORDER = [
     'b',
     'i',
@@ -46,6 +65,11 @@ _FONT_CHILD_ORDER = [
 ]
 
 
+def _xml_tag(namespace: str, tag_name: str) -> str:
+    """Return one fully qualified XML tag name."""
+    return f'{{{namespace}}}{tag_name}'
+
+
 def _font_child_sort_key(element: ET.Element) -> int:
     """Return the schema-order key for one Excel font child element."""
     tag_name = element.tag.split('}', 1)[-1]
@@ -63,14 +87,159 @@ def _styles_xml_with_sorted_fonts(data: bytes) -> bytes:
                              xml_declaration=True))
 
 
+def _new_shared_strings_root() -> ET.Element:
+    """Create an empty shared strings XML root element."""
+    return ET.Element(_xml_tag(_SPREADSHEET_NS, 'sst'))
+
+
+def _read_shared_strings_root(file_name: Path) -> ET.Element:
+    """Read the shared strings root, or create an empty one."""
+    try:
+        with ZipFile(file_name, 'r') as archive:
+            data = archive.read(_SHARED_STRINGS_PATH)
+    except KeyError:
+        return _new_shared_strings_root()
+    return ET.fromstring(data)
+
+
+def _shared_string_count(shared_strings_root: ET.Element) -> int:
+    """Return the number of shared string items in the root."""
+    return len(shared_strings_root.findall('main:si', _XML_NS))
+
+
+def _shared_strings_xml(shared_strings_root: ET.Element) -> bytes:
+    """Return finalized shared strings XML bytes."""
+    count_text = str(_shared_string_count(shared_strings_root))
+    shared_strings_root.set('count', count_text)
+    shared_strings_root.set('uniqueCount', count_text)
+    return bytes(ET.tostring(shared_strings_root, encoding='utf-8',
+                             xml_declaration=True))
+
+
+def _inline_string_to_shared_string(
+        cell: ET.Element,
+        shared_strings_root: ET.Element) -> None:
+    """Move one inline string cell value to the shared string table."""
+    inline_string = cell.find('main:is', _XML_NS)
+    if inline_string is None:
+        return
+    shared_index = _shared_string_count(shared_strings_root)
+    shared_item = ET.Element(_xml_tag(_SPREADSHEET_NS, 'si'))
+    for child in list(inline_string):
+        inline_string.remove(child)
+        shared_item.append(child)
+    shared_strings_root.append(shared_item)
+    cell.remove(inline_string)
+    cell.set('t', 's')
+    value = ET.Element(_xml_tag(_SPREADSHEET_NS, 'v'))
+    value.text = str(shared_index)
+    cell.append(value)
+
+
+def _sheet_xml_with_shared_strings(
+        data: bytes,
+        shared_strings_root: ET.Element) -> bytes:
+    """Return sheet XML with inline strings converted to shared strings."""
+    root = ET.fromstring(data)
+    for cell in root.findall('.//main:c[@t="inlineStr"]', _XML_NS):
+        _inline_string_to_shared_string(cell, shared_strings_root)
+    return bytes(ET.tostring(root, encoding='utf-8',
+                             xml_declaration=True))
+
+
+def _content_types_with_shared_strings(data: bytes) -> bytes:
+    """Return content types XML with a shared strings override."""
+    root = ET.fromstring(data)
+    for override in root.findall('ct:Override', _CONTENT_TYPES_XML_NS):
+        if override.get('PartName') == '/' + _SHARED_STRINGS_PATH:
+            return data
+    override = ET.Element(_xml_tag(_CONTENT_TYPES_NS, 'Override'))
+    override.set('PartName', '/' + _SHARED_STRINGS_PATH)
+    override.set('ContentType', _SHARED_STRINGS_CONTENT_TYPE)
+    root.append(override)
+    return bytes(ET.tostring(root, encoding='utf-8',
+                             xml_declaration=True))
+
+
+def _next_relationship_id(root: ET.Element) -> str:
+    """Return the next workbook relationship id."""
+    max_id = 0
+    for relationship in root.findall('rel:Relationship', _REL_XML_NS):
+        rel_id = relationship.get('Id', '')
+        if not rel_id.startswith('rId'):
+            continue
+        try:
+            max_id = max(max_id, int(rel_id[3:]))
+        except ValueError:
+            continue
+    return f'rId{max_id + 1}'
+
+
+def _workbook_rels_with_shared_strings(data: bytes) -> bytes:
+    """Return workbook relationships XML with a shared strings relation."""
+    root = ET.fromstring(data)
+    for relationship in root.findall('rel:Relationship', _REL_XML_NS):
+        if relationship.get('Type') == _SHARED_STRINGS_REL_TYPE:
+            return data
+    relationship = ET.Element(_xml_tag(_REL_NS, 'Relationship'))
+    relationship.set('Id', _next_relationship_id(root))
+    relationship.set('Type', _SHARED_STRINGS_REL_TYPE)
+    relationship.set('Target', 'sharedStrings.xml')
+    root.append(relationship)
+    return bytes(ET.tostring(root, encoding='utf-8',
+                             xml_declaration=True))
+
+
+def _is_worksheet_xml(filename: str) -> bool:
+    """Return True if an archive entry is a worksheet XML file."""
+    return filename.startswith('xl/worksheets/') and filename.endswith('.xml')
+
+
+def _worksheet_rewrites_with_shared_strings(
+        file_name: Path,
+        shared_strings_root: ET.Element) -> dict[str, bytes]:
+    """Return worksheet XML rewrites and update the shared string table."""
+    rewrites: dict[str, bytes] = {}
+    with ZipFile(file_name, 'r') as archive:
+        for filename in archive.namelist():
+            if not _is_worksheet_xml(filename):
+                continue
+            data = archive.read(filename)
+            if b'inlineStr' not in data:
+                continue
+            rewrites[filename] = _sheet_xml_with_shared_strings(
+                data, shared_strings_root)
+    return rewrites
+
+
 def _rewrite_saved_workbook(file_name: Path) -> None:
     """Rewrite the saved workbook so styles XML follows validator order."""
-    def rewrite_entry(item: object, data: bytes) -> bytes:
+    shared_strings_root = _read_shared_strings_root(file_name)
+    worksheet_rewrites = _worksheet_rewrites_with_shared_strings(
+        file_name, shared_strings_root)
+    use_shared_strings = _shared_string_count(shared_strings_root) > 0
+
+    def rewrite_entry(item: ZipInfo, data: bytes) -> Optional[bytes]:
         """Rewrite one workbook archive entry when needed."""
-        if getattr(item, 'filename') == 'xl/styles.xml':
+        filename = item.filename
+        if filename == 'xl/styles.xml':
             return _styles_xml_with_sorted_fonts(data)
+        if use_shared_strings and filename == _SHARED_STRINGS_PATH:
+            return None
+        if use_shared_strings and filename == _CONTENT_TYPES_PATH:
+            return _content_types_with_shared_strings(data)
+        if use_shared_strings and filename == _WORKBOOK_RELS_PATH:
+            return _workbook_rels_with_shared_strings(data)
+        if filename in worksheet_rewrites:
+            return worksheet_rewrites[filename]
         return data
-    rewrite_zip_archive(file_name, rewrite_entry)
+    extra_entries = None
+    if use_shared_strings:
+        extra_entries = {
+            _SHARED_STRINGS_PATH: _shared_strings_xml(shared_strings_root)
+        }
+    rewrite_zip_archive(file_name, rewrite_entry,
+                        extra_entries=extra_entries)
 
 
 class TableIOExcelOpenPyXL(TableIOExcelBased):

{tableio-0.6 → tableio-0.7/tableio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tableio
-Version: 0.6
+Version: 0.7
 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>
@@ -11,14 +11,14 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pip>=26.0.1
+Requires-Dist: pip>=26.1.1
 Requires-Dist: setuptools>=82.0.1
-Requires-Dist: build>=1.4.2
-Requires-Dist: wheel>=0.46.3
+Requires-Dist: build>=1.5.0
+Requires-Dist: wheel>=0.47.0
 Requires-Dist: mformat-ext>=0.6
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: types-openpyxl>=3.1.5.20260402
-Requires-Dist: odfdo>=3.22.4
+Requires-Dist: odfdo>=3.22.7
 Requires-Dist: xlsxwriter>=3.2.9
 Requires-Dist: pylightxl>=1.61
 Dynamic: author
@@ -135,20 +135,10 @@ readers/writers to the factory.
 Even though the API documentation exists, most users and programmers probably get
 a better start by reading the examples.
 
-## Version history
-
-| 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  |
-| 0.1     | 2026 Mar 23 | 3.12 or newer  | First released version      |
-
 ## Test summary
 
-- Test result: 1173 passed in 18s
+- Test result: 1186 passed in 18s
 - No flake8 warnings.
 - No mypy errors found.
-- Built version(s): 0.6
-- Build and test using Python 3.14.3
+- Built version(s): 0.7
+- Build and test using Python 3.14.4

{tableio-0.6 → tableio-0.7}/tableio.egg-info/requires.txt

@@ -1,10 +1,10 @@
-pip>=26.0.1
+pip>=26.1.1
 setuptools>=82.0.1
-build>=1.4.2
-wheel>=0.46.3
+build>=1.5.0
+wheel>=0.47.0
 mformat-ext>=0.6
 openpyxl>=3.1.5
 types-openpyxl>=3.1.5.20260402
-odfdo>=3.22.4
+odfdo>=3.22.7
 xlsxwriter>=3.2.9
 pylightxl>=1.61