tecio-python 0.2.1__tar.gz → 0.2.3__tar.gz

{tecio_python-0.2.1 → tecio_python-0.2.3}/NOTICE

@@ -2,8 +2,8 @@ tecio-python
 Copyright 2025 John Meersman
 
 This product requires the Tecplot TecIO library, which is proprietary software
-owned by Tecplot, Inc. and is not covered by this license.
-Tecplot and TecIO are trademarks of Tecplot, Inc.
+owned by Tecplot, Inc. and is not covered by this license. Tecplot and TecIO
+are trademarks of Tecplot, Inc.
 
 The license agreement for the TecIO compiled shared libraries is located at:
 lib/tecio_license_agreement.txt

{tecio_python-0.2.1/tecio_python.egg-info → tecio_python-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tecio-python
-Version: 0.2.1
+Version: 0.2.3
 Summary: Python interface for reading and writing Tecplot data files
 Project-URL: Homepage, https://github.com/meersman/tecio
 Project-URL: Documentation, https://meersman.github.io/tecio/
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE

{tecio_python-0.2.1 → tecio_python-0.2.3}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tecio-python"
-version = "0.2.1"
+version = "0.2.3"
 description = "Python interface for reading and writing Tecplot data files"
 
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
     "numpy",
 ]
@@ -101,9 +101,19 @@ ignore = ["D203", "D213", "SIM105"]
 [tool.ruff.lint.pydocstyle]
 convention = "google"
 
+[tool.ty.environment]
+root = ["."]
+python-version = "3.11"
+
 [tool.ty.terminal]
 output-format = "concise"
 
+[[tool.ty.overrides]]
+include = ["tecio/plugins/**"]
+
+[tool.ty.overrides.rules]
+unresolved-import = "ignore"
+
 [tool.pytest.ini_options]
 pythonpath = ["tecio"]
 testpaths = ["tests"]

{tecio_python-0.2.1 → tecio_python-0.2.3}/tecio/__init__.py

@@ -9,7 +9,7 @@ from importlib import metadata
 try:
     __version__ = metadata.version("tecio")
 except metadata.PackageNotFoundError:
-    __version__ = "0.0.0"
+    __version__ = "0.2.3"
 
 from . import cli, dat, libtecio, plt, szl
 from ._containers import VariableList, ZoneList

{tecio_python-0.2.1 → tecio_python-0.2.3}/tecio/_containers.py

@@ -138,7 +138,7 @@ class VariableList(Generic[_VarT]):
     """Read-only sequence of variables with positional *and* named access.
 
     Drop-in for the ``list`` previously returned by ``ReadZone.variable``:
-    iteration, ``len()``, and integer indexing are unchanged.  A string key
+    iteration, ``len()``, and integer indexing are unchanged. A string key
     resolves a variable by its exact, case-sensitive name.
 
     Subscripting returns the variable *object*; use its ``.values`` (or the
@@ -157,7 +157,7 @@ class VariableList(Generic[_VarT]):
     def __init__(self, variables: list[_VarT]) -> None:
         self._items: list[_VarT] = variables
         # Built lazily on first name lookup so purely positional use pays no
-        # cost.  For SZL this also avoids issuing a C call per variable name
+        # cost. For SZL this also avoids issuing a C call per variable name
         # until a name is actually requested.
         self._name_index: dict[str, int] | None = None
 

{tecio_python-0.2.1 → tecio_python-0.2.3}/tecio/_io.py

@@ -5,15 +5,15 @@ Supported modes mirror Python's built-in :func:`open`:
     ======  ============================================================================
     Mode    Behaviour
     ======  ============================================================================
-    ``r``   Open existing file for reading.  Raises :exc:`FileNotFoundError` if the file
+    ``r``   Open existing file for reading. Raises :exc:`FileNotFoundError` if the file
             does not exist.
-    ``w``   Open file for writing.  Overwrites any existing file.
+    ``w``   Open file for writing. Overwrites any existing file.
     ``x``   Exclusive creation — open for writing only if the file does **not** already
-            exist.  Raises :exc:`FileExistsError` otherwise.
+            exist. Raises :exc:`FileExistsError` otherwise.
     ``a``   Append — stream all zones from the existing file into a new temporary file,
-            then continue writing new zones into that same file.  On
+            then continue writing new zones into that same file. On
             :meth:`~AppendWrite.close` the temporary file atomically replaces the
-            original path.  Returns an :class:`AppendWrite` object whose write API is
+            original path. Returns an :class:`AppendWrite` object whose write API is
             identical to the format's ``Write`` class.
     ``a+``  Append-read — same streaming copy as ``a``, but the returned
             :class:`AppendReadWrite` object also exposes the full ``Read`` API populated
@@ -24,14 +24,14 @@ Supported modes mirror Python's built-in :func:`open`:
 Note:
     ``"a"`` and ``"a+"`` work by reading the source file in full and re-writing it
     zone-by-zone into a temporary sibling file, then leaving the ``Write`` handle open
-    for the caller to add further zones.  On close the temporary file is atomically
-    renamed over the original path (POSIX) or replaced (Windows).  This is the only safe
+    for the caller to add further zones. On close the temporary file is atomically
+    renamed over the original path (POSIX) or replaced (Windows). This is the only safe
     approach because PLT and SZL are sequential binary formats with no in-place editing
     capability.
 
 Note:
     FEPOLYGON and FEPOLYHEDRON zones are not copied during append operations because the
-    ``Write`` API does not yet expose a poly-zone writer.  A :exc:`NotImplementedError`
+    ``Write`` API does not yet expose a poly-zone writer. A :exc:`NotImplementedError`
     is raised if such zones are encountered in the source file.
 """
 
@@ -120,7 +120,9 @@ def _copy_zones(reader: szl.Read | plt.Read, writer: szl.Write | plt.Write) -> N
     """Stream all zones from *reader* into the open *writer*.
 
     Each zone is copied variable-by-variable at its original data type and value
-    location.  Connectivity (node maps) is copied for FE zones.
+    location. Both variable sharing (``var_sharing``) and FE connectivity sharing
+    (``con_sharing``) are preserved: a zone that shares its connectivity is
+    re-emitted as a share rather than a duplicated node map.
 
     Args:
         reader: An already-opened ``Read`` instance.
@@ -148,7 +150,7 @@ def _copy_zones(reader: szl.Read | plt.Read, writer: szl.Write | plt.Write) -> N
 
         for var in zone.variable:
             passive_vars.append(var.is_passive())
-            sv = var.shared_zone  # None or 0-based zone number (szl convention)
+            sv = var.shared_zone  # None, or the 1-based source-zone index shared from
             # Write API expects 0 = no sharing, positive = 1-based zone source.
             var_sharing.append((sv) if sv is not None else 0)
             value_locations.append(var.value_location)
@@ -187,10 +189,16 @@ def _copy_zones(reader: szl.Read | plt.Read, writer: szl.Write | plt.Write) -> N
         if zt == ZoneType.ORDERED:
             writer.write_ijk_zone(data=active_data, **common_kw)
         else:
+            # Forward connectivity sharing: when shared, pass ``con_sharing`` and omit
+            # the node map so the writer derives the node/cell counts from the source
+            # zone; otherwise write this zone's own node map.
+            cv = zone.shared_connectivity  # None, or 1-based source-zone index
+            con_sharing = cv if cv is not None else 0
             writer.write_fe_zone(
                 zone_type=zt,
                 data=active_data,
-                node_map=zone.node_map,
+                node_map=None if con_sharing else zone.node_map,
+                con_sharing=con_sharing,
                 **common_kw,
             )
 
@@ -203,9 +211,9 @@ def _copy_zones(reader: szl.Read | plt.Read, writer: szl.Write | plt.Write) -> N
 class AppendWrite:
     """Write handle returned by :func:`tecio.open` with ``mode='a'``.
 
-    Appends new zones to an existing Tecplot file.  Internally the existing file is
+    Appends new zones to an existing Tecplot file. Internally the existing file is
     stream-copied zone-by-zone into a temporary sibling file, and the write handle is
-    left open past all copied zones so new zones can be appended.  On :meth:`close` (or
+    left open past all copied zones so new zones can be appended. On :meth:`close` (or
     context-manager exit) the temporary file is atomically renamed over the original
     path — a POSIX rename on Unix, :func:`Path.replace` on Windows.
 
@@ -217,7 +225,7 @@ class AppendWrite:
 
     Note:
         FEPOLYGON and FEPOLYHEDRON zones cannot be copied because the Write API does not
-        yet expose a poly-zone writer.  A :exc:`NotImplementedError` is raised during
+        yet expose a poly-zone writer. A :exc:`NotImplementedError` is raised during
         ``open()`` if such zones are present in the source file.
 
     Example:
@@ -262,32 +270,32 @@ class AppendWrite:
         """Append a structured IJK-ordered zone.
 
         Delegates to the underlying format writer's ``write_ijk_zone``
-        (e.g. :meth:`tecio.szl.Write.write_ijk_zone`).  All parameters from that method
+        (e.g. :meth:`tecio.szl.Write.write_ijk_zone`). All parameters from that method
         are accepted here with one exception: ``variables`` is not meaningful because
         the variable list is fixed at open time from the existing file.
 
         Args:
             data (Sequence[ndarray]): One NumPy array per **active** variable
-                (non-passive, non-shared).  Shape ``(imax[, jmax[, kmax]])`` is inferred
-                automatically.  Fortran (column-major) order is assumed.
-            title (str | None): Zone title.  Defaults to ``"IJK_Zone_{n}"``.
+                (non-passive, non-shared). Shape ``(imax[, jmax[, kmax]])`` is inferred
+                automatically. Fortran (column-major) order is assumed.
+            title (str | None): Zone title. Defaults to ``"IJK_Zone_{n}"``.
             value_locations (Sequence[ValueLocation] | None): Per-variable
-                :class:`~tecio.libtecio.ValueLocation` for active variables.  Defaults
+                :class:`~tecio.libtecio.ValueLocation` for active variables. Defaults
                 to all :attr:`~tecio.libtecio.ValueLocation.NODAL`.
             passive_vars (Sequence[bool | int] | None): Per-variable passive flag for
                 the **full** variable list (length = total variables in the file, not
-                just active ones).  Defaults to all ``False``.
+                just active ones). Defaults to all ``False``.
             var_sharing (Sequence[int] | None): Per-variable share-from zone index
                 (1-based, counting all zones including those copied from the original
-                file).  ``0`` = no sharing.  Defaults to all ``0``.  Sharing grid
+                file).  ``0`` = no sharing. Defaults to all ``0``. Sharing grid
                 coordinates from zone 1 is a common pattern for transient data to avoid
                 duplicating large arrays.
-            solution_time (float): Solution time for transient data.  Defaults to
+            solution_time (float): Solution time for transient data. Defaults to
                 ``0.0``.
-            strand_id (int): Strand ID grouping related time steps.  Zones with the same
-                strand ID animate together in Tecplot 360.  Defaults to ``0`` (static).
+            strand_id (int): Strand ID grouping related time steps. Zones with the same
+                strand ID animate together in Tecplot 360. Defaults to ``0`` (static).
             aux (dict[str, str] | None): Zone-level auxiliary data as ``{name: value}``
-                pairs.  Defaults to ``None``.
+                pairs. Defaults to ``None``.
 
         Example:
             Append a time step, sharing the grid from zone 1:
@@ -313,7 +321,7 @@ class AppendWrite:
         FEPOLYGON and FEPOLYHEDRON are not supported.
 
         Args:
-            zone_type (ZoneType): Element topology.  One of:
+            zone_type (ZoneType): Element topology. One of:
                 :attr:`~tecio.libtecio.ZoneType.FELINESEG`,
                 :attr:`~tecio.libtecio.ZoneType.FETRIANGLE`,
                 :attr:`~tecio.libtecio.ZoneType.FEQUADRILATERAL`,
@@ -341,7 +349,7 @@ class AppendWrite:
             face_nbr_mode (FaceNeighborMode | None): Face-neighbor mode. Defaults to
                 :attr:`~tecio.libtecio.FaceNeighborMode.LOCAL_ONE_TO_ONE`. Ignored when
                 ``face_neighbors`` is ``None``.
-            solution_time (float): Solution time.  Defaults to ``0.0``.
+            solution_time (float): Solution time. Defaults to ``0.0``.
             strand_id (int): Strand ID. Defaults to ``0``.
             aux (dict[str, str] | None): Zone-level auxiliary data.
 
@@ -403,7 +411,7 @@ class AppendReadWrite(AppendWrite):
     """Read + write handle returned by :func:`tecio.open` with ``mode='a+'``.
 
     Inherits all write methods from :class:`AppendWrite` and additionally exposes the
-    full read interface populated from the **original** file.  The read data reflects
+    full read interface populated from the **original** file. The read data reflects
     the file as it existed before any new zones were appended — zones written during the
     current session are not visible via :attr:`zone` until the file is closed and
     re-opened.
@@ -664,7 +672,7 @@ def open(
     """Open a Tecplot file for reading, writing, or appending.
 
     Selects the correct format handler from the file extension and returns the
-    appropriate reader or writer.  All handles are context managers.
+    appropriate reader or writer. All handles are context managers.
 
     Args:
         path (str | os.PathLike): File path. Extension determines the format handler:
@@ -679,9 +687,9 @@ def open(
             - ``'w'`` -- Open Tecplot file for writing, truncating the file first.
             - ``'x'`` -- Open Tecplot file for exclusive creation, failing if the file
               already exists.
-            - ``'a'`` -- Append new zones to an existing file.  The file is
+            - ``'a'`` -- Append new zones to an existing file. The file is
               stream-copied to a temporary file; on close the temporary atomically
-              replaces the original.  Raises :exc:`FileNotFoundError` if the file does
+              replaces the original. Raises :exc:`FileNotFoundError` if the file does
               not exist (use ``'w'`` to create a new file).
             - ``'a+'`` -- Same as ``'a'`` but the returned handle also exposes the full
               read API populated from the original file.
@@ -709,9 +717,9 @@ def open(
              - Dataset title string embedded in the file header.
            * - ``variables``
              - ``None``
-             - Variable name list.  For SZL and PLT this may be deferred to the first
+             - Variable name list. For SZL and PLT this may be deferred to the first
                :meth:`~tecio.szl.Write.write_ijk_zone` or
-               :meth:`~tecio.szl.Write.write_fe_zone` call.  Required at open time for
+               :meth:`~tecio.szl.Write.write_fe_zone` call. Required at open time for
                DAT.
            * - ``file_type``
              - ``FileType.FULL``
@@ -721,7 +729,7 @@ def open(
 
     Keyword Args (modes ``'a'``, ``'a+'``):
         ``title``, ``variables``, and ``file_type`` default to the values read from the
-        existing file.  In most cases you should **not** pass these — they are
+        existing file. In most cases you should **not** pass these — they are
         documented here for completeness.
 
         .. list-table::
@@ -733,7 +741,7 @@ def open(
              - Description
            * - ``title``
              - From file
-             - Override the dataset title in the output file.  Rarely needed — the
+             - Override the dataset title in the output file. Rarely needed — the
                existing title is preserved by default.
            * - ``variables``
              - From file
@@ -742,7 +750,7 @@ def open(
                and any new zones.
            * - ``file_type``
              - From file
-             - Override the file type.  Rarely needed.
+             - Override the file type. Rarely needed.
 
     Returns:
         - ``'r'`` → :class:`tecio.szl.Read`, :class:`tecio.plt.Read`, or
@@ -785,7 +793,7 @@ def open(
 
     if ext not in _HANDLERS:
         raise ValueError(
-            f"Unsupported file extension: '{ext}'.  Supported: {sorted(_HANDLERS)}"
+            f"Unsupported file extension: '{ext}'. Supported: {sorted(_HANDLERS)}"
         )
 
     if mode == "r":
@@ -807,5 +815,5 @@ def open(
 
     else:
         raise ValueError(
-            f"Unrecognised mode '{mode}'.  Supported modes: 'r', 'w', 'x', 'a', 'a+'"
+            f"Unrecognised mode '{mode}'. Supported modes: 'r', 'w', 'x', 'a', 'a+'"
         )

{tecio_python-0.2.1 → tecio_python-0.2.3}/tecio/_meta.py

@@ -2,7 +2,7 @@ r"""Structural metadata records shared by the Tecplot file writers.
 
 The writer for each output format -- SZL (``.szplt``), PLT (``.plt``), and ASCII DAT
 (``.dat``) -- keeps a running, in-memory description of what it has committed to disk:
-the dataset header, auxiliary-data counts, and one record per zone.  Defining that
+the dataset header, auxiliary-data counts, and one record per zone. Defining that
 description once here lets all three writers share a single representation instead of
 each maintaining ad-hoc bookkeeping.
 
@@ -16,10 +16,10 @@ Design notes:
       never the variable data arrays, so the record stays cheap in memory even for files
       with many zones.
     * ``slots=True`` removes the per-instance ``__dict__``, and immutable tuple fields
-      keep the per-variable lists compact.  A :class:`ZoneMeta` is a write-once snapshot
+      keep the per-variable lists compact. A :class:`ZoneMeta` is a write-once snapshot
       and is therefore ``frozen``; :class:`WriterMeta` is mutable because it grows as
       zones are written.
-    * Enum types are imported only under :data:`typing.TYPE_CHECKING`.  With ``from
+    * Enum types are imported only under :data:`typing.TYPE_CHECKING`. With ``from
       __future__ import annotations`` the annotations are never evaluated at runtime,
       which keeps this module free of any import cycle with :mod:`tecio.libtecio`.
 """
@@ -104,7 +104,7 @@ class WriterMeta:
     """Running record of everything a writer has committed to a file.
 
     Populated incrementally as the file header, auxiliary data, and zones are
-    written, so it always reflects the current on-disk state.  It is the single
+    written, so it always reflects the current on-disk state. It is the single
     source of truth for cross-zone validation (for example, resolving the shape
     of a shared variable) and is suitable for summarising the writer state.
 

{tecio_python-0.2.1 → tecio_python-0.2.3}/tecio/cli/__init__.py

@@ -2,18 +2,18 @@
 
 Binary data formats such as ``.plt`` and ``.szplt`` are opaque to standard shell
 utilities, meaning any inspection or manipulation of their contents typically requires
-either dedicated post-processing software or a non-trivial amount of scripting.  For
+either dedicated post-processing software or a non-trivial amount of scripting. For
 routine tasks encountered in CFD and related workflows, verifying zone extents,
 extracting a subset of variables, computing summary statistics, this overhead is
 disproportionate to the complexity of the task itself.
 
 The tools collected here address this by exposing the most common file-level operations
 as console scripts, executable directly from the terminal and composable with standard
-shell pipelines.  Each tool is intentionally narrow in scope: it does one thing and
+shell pipelines. Each tool is intentionally narrow in scope: it does one thing and
 surfaces its result without requiring the user to open a GUI or write any Python.
 
 All scripts are installed automatically alongside the :mod:`tecio` package and are
-available on ``PATH`` immediately after installation.  Every tool accepts ``--help`` for
+available on ``PATH`` immediately after installation. Every tool accepts ``--help`` for
 a full description of its arguments.
 
 """

{tecio_python-0.2.1 → tecio_python-0.2.3}/tecio/cli/tec2mat.py

@@ -2,10 +2,10 @@ r"""Convert a Tecplot data file to a MATLAB ``.mat`` file.
 
 MATLAB is widely used for engineering analysis and post-processing, but it cannot read
 Tecplot binary files directly, and the Tecplot ASCII format is awkward to parse on the
-MATLAB side.  Moving data across normally requires a Tecplot license or a hand-written
+MATLAB side. Moving data across normally requires a Tecplot license or a hand-written
 reader.  ``tec2mat`` bridges this gap by reading any supported Tecplot format
 (``.szplt``, ``.plt``, or ``.dat``) and writing a single MATLAB ``.mat`` file via
-:func:`scipy.io.savemat`.  Each input file maps to exactly one output file
+:func:`scipy.io.savemat`. Each input file maps to exactly one output file
 (``flow.szplt`` -> ``flow.mat``): every zone becomes a named struct, every variable is
 preserved at its native precision, and connectivity and metadata are retained so the
 dataset can be reconstructed in MATLAB without a Tecplot installation.
@@ -22,26 +22,26 @@ dataset can be reconstructed in MATLAB without a Tecplot installation.
 
 :Options:
     ``-o PATH``, ``--output PATH``
-        Output file path.  Defaults to the input file stem with a ``.mat`` extension in
+        Output file path. Defaults to the input file stem with a ``.mat`` extension in
         the same directory as the input file.
 
     ``-f``, ``--force``
-        Overwrite the output file if it already exists.  Without this flag the command
+        Overwrite the output file if it already exists. Without this flag the command
         exits with an error rather than silently clobbering an existing file.
 
     ``-c``, ``--compress``
         Compress the variable arrays inside the ``.mat`` file (passes
-        ``do_compression=True`` to :func:`scipy.io.savemat`).  Reduces file size at the
+        ``do_compression=True`` to :func:`scipy.io.savemat`). Reduces file size at the
         cost of some write/read time.
 
     ``--oned-as {column,row}``
         Orientation for one-dimensional arrays (finite-element nodal/cell vectors and
         the per-variable metadata arrays) in the ``.mat`` file.  ``column`` (the
-        default) writes ``N x 1`` column vectors; ``row`` writes ``1 x N``.  Has no
+        default) writes ``N x 1`` column vectors; ``row`` writes ``1 x N``. Has no
         effect on the two- and three-dimensional arrays of ordered zones.
 
 :Returns:
-    A single MATLAB ``.mat`` file written to the output path.  Exit code is ``0`` on
+    A single MATLAB ``.mat`` file written to the output path. Exit code is ``0`` on
     success and non-zero if the input file cannot be read or the output file already
     exists and ``--force`` is not set.
 
@@ -75,14 +75,14 @@ Output structure:
                                           if this zone shares its connectivity
 
     Variable arrays are stored at their on-disk NumPy dtype, so single/double/integer
-    precision is preserved.  The real variable names are kept only in ``info.var_names``
+    precision is preserved. The real variable names are kept only in ``info.var_names``
     because they are frequently not valid MATLAB field names (e.g. ``"X [ft]"``); the
     per-zone data is addressed by 1-based index (``var_1`` ...) instead.
 
     Passive and shared variables carry no data: their ``var_<k>`` field is an empty
-    matrix ``[]``.  A shared variable is therefore never duplicated on disk -- the data
+    matrix ``[]``. A shared variable is therefore never duplicated on disk -- the data
     lives in its source zone and ``var_shared_from`` records where, so the MATLAB user
-    can dereference it (see the examples below).  Shared FE connectivity follows the
+    can dereference it (see the examples below). Shared FE connectivity follows the
     same convention: a zone sharing its node map has no ``node_map`` field at all, only
     ``node_map_shared_from``.
 
@@ -111,7 +111,7 @@ Examples:
         x = d.zone_1.var_1;        % first variable of the first zone
         p = d.zone_1.var_3;        % third variable
 
-    Variables shared from another zone are stored once.  Resolve them with a small
+    Variables shared from another zone are stored once. Resolve them with a small
     helper that follows ``var_shared_from``::
 
         function v = tecvar(d, zoneIdx, varIdx)
@@ -136,23 +136,23 @@ Examples:
         end
 
 See Also:
-    * :mod:`tecio.cli.teconvert`: Convert between Tecplot file formats (``.szplt``,
+    * :mod:`tecio.cli.teconvert` - Convert between Tecplot file formats (``.szplt``,
       ``.plt``, ``.dat``) without leaving the Tecplot ecosystem.
-    * :mod:`tecio.cli.tecdump`: Inspect the full contents and metadata of a file before
+    * :mod:`tecio.cli.tecdump` - Inspect the full contents and metadata of a file before
       converting it.
 
 Note:
-    ``tec2mat`` requires SciPy (:mod:`scipy.io`).  Install it with ``pip install
+    ``tec2mat`` requires SciPy (:mod:`scipy.io`). Install it with ``pip install
     scipy`` if it is not already available.
 
 Note:
     :func:`scipy.io.savemat` writes the MAT version 5 format and assembles the whole
-    file in memory before writing.  Very large datasets are therefore limited by
+    file in memory before writing. Very large datasets are therefore limited by
     available memory and by the ~4 GB-per-variable ceiling of the MAT v5 format.
 
 Note:
     FEPOLYGON and FEPOLYHEDRON zones are written with their variable data, but their
-    face-based connectivity cannot be read and the ``node_map`` field is omitted.  A
+    face-based connectivity cannot be read and the ``node_map`` field is omitted. A
     warning is printed for each such zone.
 """
 
@@ -191,7 +191,7 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         prog="tec2mat",
         description=(
             # -|-------------------|---------------------------------------------|
-            "Convert a Tecplot file to a MATLAB .mat file.  Each input file maps\n"
+            "Convert a Tecplot file to a MATLAB .mat file. Each input file maps\n"
             "to one output file, with every zone stored as a named struct."
         ),
         epilog=(
@@ -219,7 +219,7 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         default=None,
         metavar="PATH",
         help=(
-            "Output file path.  Defaults to the input file stem with a "
+            "Output file path. Defaults to the input file stem with a "
             ".mat extension in the same directory as the input."
         ),
     )
@@ -247,7 +247,7 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         help=(
             "Orientation for 1-D arrays (FE vectors and per-variable "
             "metadata).  'column' (default) writes Nx1 vectors; 'row' "
-            "writes 1xN.  Ordered-zone arrays are unaffected."
+            "writes 1xN. Ordered-zone arrays are unaffected."
         ),
     )
     return parser.parse_args(argv)
@@ -263,7 +263,7 @@ def _build_info_dict(reader: Any) -> dict[str, Any]:
 
     The returned dict is stored by :func:`scipy.io.savemat` as a MATLAB struct named
     ``info``, holding the dataset title, file type, zone/variable counts, and the
-    ordered list of real variable names as a MATLAB cell array.  The real names are
+    ordered list of real variable names as a MATLAB cell array. The real names are
     kept here as metadata because they are frequently not valid MATLAB field names
     (e.g. ``"X [ft]"``); the per-zone arrays are addressed by 1-based index instead.
 
@@ -288,12 +288,12 @@ def _build_info_dict(reader: Any) -> dict[str, Any]:
 def _zone_to_dict(zone: Any, num_vars: int) -> dict[str, Any]:
     """Build one zone's struct for the output file.
 
-    The returned dict becomes a MATLAB struct (named ``zone_<n>`` by the caller).  It
+    The returned dict becomes a MATLAB struct (named ``zone_<n>`` by the caller). It
     contains the zone metadata, one ``var_<k>`` field per dataset variable (1-based),
     and, for simple finite-element zones, the ``node_map`` connectivity array.
 
     Each ``var_<k>`` holds the variable's data array at its native NumPy dtype, so the
-    on-disk precision is preserved on the MATLAB side.  Passive and shared variables
+    on-disk precision is preserved on the MATLAB side. Passive and shared variables
     carry no data: their ``var_<k>`` field is an empty matrix ``[]`` and the
     per-variable metadata records how to interpret it:
 
@@ -377,7 +377,7 @@ def _zone_to_dict(zone: Any, num_vars: int) -> dict[str, Any]:
     d["var_dtypes"] = np.array(dtypes, dtype=object)
     d["var_shared_from"] = shared_from
 
-    # Connectivity for simple FE zones only.  Ordered zones have no node map, and poly
+    # Connectivity for simple FE zones only. Ordered zones have no node map, and poly
     # zones expose none through the readers.
     #
     # A zone that shares connectivity is handled the same way as a shared variable