tecio-python 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

tecio/__init__.py

@@ -9,7 +9,7 @@ from importlib import metadata
 try:
     __version__ = metadata.version("tecio")
 except metadata.PackageNotFoundError:
-    __version__ = "0.3.2"
+    __version__ = "0.3.3"
 
 from . import cli, libtecio
 from ._constants import (
@@ -28,7 +28,20 @@ from ._constants import (
 from ._containers import VariableList, ZoneList
 from ._dat_read import TecplotDatReader
 from ._dat_write import TecplotDatWriter
-from ._io import AppendReadWrite, AppendWrite, open
+from ._io import (
+    AppendReadWrite,
+    AppendWrite,
+    FileSummary,
+    ZoneSummary,
+    get_file_type,
+    get_num_variables,
+    get_num_zones,
+    get_title,
+    get_variable_list,
+    get_zone_list,
+    open,
+    peek,
+)
 from ._plt_read import TecplotPltReader
 from ._plt_write import TecplotPltWriter
 from ._reader import (
@@ -82,6 +95,15 @@ del _cls
 __all__ = [
     "libtecio",
     "open",
+    "peek",
+    "get_variable_list",
+    "get_zone_list",
+    "get_num_zones",
+    "get_num_variables",
+    "get_title",
+    "get_file_type",
+    "FileSummary",
+    "ZoneSummary",
     "cli",
     "AppendWrite",
     "AppendReadWrite",

tecio/_dat_read.py

@@ -14,8 +14,9 @@ and (for data values) PLT.
 from __future__ import annotations
 
 import contextlib
+import os
 import re
-from typing import Any
+from typing import Any, NamedTuple
 
 import numpy as np
 import numpy.typing as npt
@@ -299,6 +300,93 @@ def _next_token_is_value(text: str, i: int) -> bool:
     return not (j < n and text[j] == "=")
 
 
+def _determine_zone_type(kv: dict[str, str]) -> ZoneType:
+    """Determine a zone's type from its header key-value pairs.
+
+    Shared by the full parser and the metadata-only scanner so both agree on the same
+    modern/legacy keyword rules.
+
+    Two header dialects are supported:
+        * Modern: ``ZONETYPE=FEQuadrilateral, DATAPACKING=POINT``
+        * Legacy: ``F=FEPOINT, ET=QUADRILATERAL``
+
+    The FE-vs-ordered distinction comes from ``ZONETYPE`` (modern) or ``F``
+    (legacy). ``ET`` (element type) only ever appears on finite-element zones, so it
+    merely names the element *shape* once a zone is already known to be FE. Modern
+    keywords win when present.
+
+    Args:
+        kv: Zone header key-value pairs (leading ``ZONE`` keyword already stripped), as
+            returned by :func:`_kv_split`.
+
+    Returns:
+        The zone's type. Unlike the full parser, does not reject FEPOLYGON/FEPOLYHEDRON,
+        those just aren't readable for data, the header itself is perfectly legible.
+
+    Raises:
+        ValueError: If a legacy FE header (``F=FEPOINT``/``FEBLOCK``) is
+            missing the required ``ET`` keyword.
+
+    Example:
+        >>> _determine_zone_type({"T": '"z"', "I": "5"})
+        <ZoneType.ORDERED: ...>
+    """
+    legacy_is_fe: bool | None = None
+    if "F" in kv:
+        legacy_is_fe, _ = _parse_legacy_format(kv["F"])
+
+    if "ZONETYPE" in kv:
+        zt_raw = kv["ZONETYPE"].rstrip(",").strip().lower()
+        return _STR_TO_ZONETYPE.get(zt_raw, ZoneType.ORDERED)
+    elif legacy_is_fe is False:
+        return ZoneType.ORDERED
+    elif legacy_is_fe or "ET" in kv:
+        if "ET" not in kv:
+            raise ValueError(
+                "Legacy FE zone header specifies F=FEPOINT/FEBLOCK but is "
+                "missing the required ET (element type) keyword."
+            )
+        return _parse_legacy_element_type(kv["ET"])
+    else:
+        return ZoneType.ORDERED
+
+
+def _collect_zone_header_lines(tokens: _LineBuffer) -> list[str]:
+    """Collect a ZONE block's header lines, stopping before data begins.
+
+    Shared by the full parser and the metadata-only scanner (:func:`peek_dat_metadata`)
+    so both agree on exactly where a zone's header ends and its data starts.
+
+    Args:
+        tokens: Positioned at the ``ZONE`` line itself (not yet consumed).
+
+    Returns:
+        Raw header lines, including the leading ``ZONE`` keyword line.
+
+    Example:
+        >>> lines = _collect_zone_header_lines(tokens)
+    """
+    header_lines: list[str] = [tokens.next_stripped()]  # ZONE T=...
+    while tokens.has_more():
+        nxt = tokens.peek_stripped()
+        if not nxt:
+            tokens.next_stripped()
+            continue
+        nxt_upper = nxt.lstrip().upper()
+        # Stop at a new zone, top-level keyword, or the first data line.
+        if nxt_upper.split("=")[0].split()[0] == "ZONE":
+            break
+        if nxt_upper.startswith(("DATASETAUXDATA", "VARAUXDATA")):
+            break
+        first_ch = nxt.lstrip()[0] if nxt.lstrip() else ""
+        # A data line begins with a numeric token (covers leading-dot values such as
+        # ``.5`` and signed values such as ``-1.2e3``).
+        if first_ch in "0123456789+-.":
+            break
+        header_lines.append(tokens.next_stripped())
+    return header_lines
+
+
 def _kv_split(text: str) -> dict[str, str]:
     """Parse a loose ``KEY=VALUE`` string into an upper-cased-key dict.
 
@@ -1022,6 +1110,162 @@ class TecplotDatFEZoneReader(TecplotFEZoneReader):
         return TecplotDatAuxDataReader(self._aux_raw)
 
 
+class _DatZoneInfo(NamedTuple):
+    """Per-zone metadata from a cheap header-only scan."""
+
+    title: str
+    zone_type: ZoneType
+    num_nodes: int | None
+    num_elements: int | None
+
+
+class _DatMetadata(NamedTuple):
+    """Result of :func:`_peek_dat_metadata`."""
+
+    title: str
+    file_type: FileType
+    variable_names: list[str]
+    zones: list[_DatZoneInfo]
+
+
+_ZONE_LINE_RE = re.compile(r"^[ \t]*ZONE\b", re.IGNORECASE | re.MULTILINE)
+_ZONE_DATA_START_RE = re.compile(r"^[ \t]*[0-9+\-.]", re.MULTILINE)
+
+
+def _peek_dat_metadata(path: str | os.PathLike) -> _DatMetadata:
+    """Scan a DAT file's title, variable names, and per-zone metadata only.
+
+    Unlike opening the file normally, never converts a single data value to a number. A
+    single bulk regex pass across the whole file finds every zone header's starting
+    line; each zone's metadata is then extracted from just the handful of lines between
+    that start and the next one (or EOF), reusing the same header-parsing logic the real
+    parser uses, so a zone header can still span multiple lines correctly. The data and
+    connectivity blocks in between are never read at all. A line-by-line Python scan
+    over the whole file (rather than this bulk approach) was tried first and measured
+    slower than a full parse for large files, string-heavy per-line loops in Python
+    don't beat NumPy's bulk numeric parsing, even when doing less work; a single C-level
+    regex pass over the whole file does.
+
+    A zone's ``num_nodes``/``num_elements`` are ``None`` only for the one case they
+    genuinely can't be determined without reading data: an ordered zone whose header
+    omits I/J/K entirely, relying on the reader to infer the point count from the data
+    itself (see :meth:`TecplotDatReader._infer_ordered_point_count`). Every other case,
+    including FE zones, always states its node/element counts directly in the header
+    text.
+
+    Args:
+        path: Path to a ``.dat``/``.tec`` file.
+
+    Returns:
+        Title, file type, variable names, and per-zone metadata (in file order).
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+
+    Example:
+        >>> meta = _peek_dat_metadata("flow.dat")
+        >>> [z.title for z in meta.zones]
+        ['FluidVolume', 'WingSurface']
+    """
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        text = fh.read()
+
+    zone_starts = [m.start() for m in _ZONE_LINE_RE.finditer(text)]
+
+    # File header: everything before the first zone (or the whole file, if it somehow
+    # has none). Mirrors TecplotDatReader._parse_file_header, kept separate rather than
+    # shared with it since that method also populates dataset aux data, which this
+    # function deliberately doesn't scan for. Just a handful of lines regardless of file
+    # size, so no bulk-regex treatment needed here.
+    header_end = zone_starts[0] if zone_starts else len(text)
+    tokens = _LineBuffer(text[:header_end].splitlines(keepends=True))
+
+    title = ""
+    file_type = FileType.FULL
+    variable_names: list[str] = []
+    while tokens.has_more():
+        line = tokens.peek_stripped()
+        if not line:
+            tokens.next_stripped()
+            continue
+        upper_key = (
+            line.split("=")[0].strip().upper() if "=" in line else line.strip().upper()
+        )
+        tokens.next_stripped()
+
+        if upper_key == "TITLE":
+            rhs = line.split("=", 1)[1].strip() if "=" in line else ""
+            title = _unquote(rhs)
+        elif upper_key == "FILETYPE":
+            rhs = line.split("=", 1)[1].strip() if "=" in line else ""
+            file_type = _STR_TO_FILETYPE.get(rhs.strip().lower(), FileType.FULL)
+        elif upper_key == "VARIABLES":
+            rhs = line.split("=", 1)[1].strip() if "=" in line else ""
+            names = _extract_quoted_strings(rhs)
+            while tokens.has_more():
+                nxt = tokens.peek_stripped()
+                if not nxt:
+                    tokens.next_stripped()
+                    continue
+                if nxt.lstrip().startswith('"'):
+                    names.extend(_extract_quoted_strings(tokens.next_stripped()))
+                elif "=" not in nxt.split("#")[0]:
+                    tokens.next_stripped()
+                else:
+                    break
+            variable_names = names
+
+    # Zones: each zone's header lives in the small window between its start and the next
+    # zone's start (or EOF); _collect_zone_header_lines only ever looks at the first
+    # handful of lines in that window before hitting what looks like data, so this stays
+    # cheap regardless of how much data actually follows.
+    zones: list[_DatZoneInfo] = []
+    for i, start in enumerate(zone_starts):
+        end = zone_starts[i + 1] if i + 1 < len(zone_starts) else len(text)
+        # Bounded search directly on the original string
+        data_match = _ZONE_DATA_START_RE.search(text, start, end)
+        header_end = data_match.start() if data_match else end
+        window_tokens = _LineBuffer(text[start:header_end].splitlines(keepends=True))
+        header_lines = _collect_zone_header_lines(window_tokens)
+        header_text = " ".join(header_lines)
+        m_zone = re.match(r"(?i)^ZONE\s*", header_text)
+        if m_zone:
+            header_text = header_text[m_zone.end() :]
+        kv = _kv_split(header_text)
+        zone_title = _unquote(kv.get("T", ""))
+
+        try:
+            zone_type = _determine_zone_type(kv)
+        except ValueError:
+            # A legacy header F=FEPOINT with no ET reports as unknown
+            zones.append(_DatZoneInfo(zone_title, ZoneType.ORDERED, None, None))
+            continue
+
+        num_nodes: int | None
+        num_elements: int | None
+        if zone_type == ZoneType.ORDERED:
+            if "I" not in kv and "J" not in kv and "K" not in kv:
+                # Point count only knowable by reading data -> report unknown
+                num_nodes = None
+                num_elements = None
+            else:
+                zi = int(kv.get("I", "1") or "1")
+                zj = int(kv.get("J", "1") or "1")
+                zk = int(kv.get("K", "1") or "1")
+                num_nodes = zi * zj * zk
+                num_elements = max(zi - 1, 1) * max(zj - 1, 1) * max(zk - 1, 1)
+        else:
+            # FE zones (including FEPOLYGON/FEPOLYHEDRON, which the full parser can't
+            # read data for, but whose header is just as legible as any other zone's)
+            # always state counts directly.
+            num_nodes = int(kv.get("NODES", kv.get("N", "0")) or "0")
+            num_elements = int(kv.get("ELEMENTS", kv.get("E", "0")) or "0")
+
+        zones.append(_DatZoneInfo(zone_title, zone_type, num_nodes, num_elements))
+
+    return _DatMetadata(title, file_type, variable_names, zones)
+
+
 class TecplotDatReader(TecplotReader):
     """Reader for Tecplot ASCII DAT files.
 
@@ -1143,8 +1387,10 @@ class TecplotDatReader(TecplotReader):
 
         while tokens.has_more():
             line = tokens.peek_stripped()
+            if not line:
+                tokens.next_stripped()
+                continue
             upper = line.upper()
-            # if upper.startswith("ZONE"):
             if upper.lstrip().split("=")[0].split()[0] == "ZONE":
                 self._parse_zone(tokens)
             elif upper.startswith("DATASETAUXDATA"):
@@ -1232,7 +1478,9 @@ class TecplotDatReader(TecplotReader):
     def _infer_ordered_point_count(tokens: _LineBuffer, active_count: int) -> int:
         """Infer an ordered zone's point count when I/J/K are all omitted.
 
-        Peeks ahead counting numeric tokens up to the next zone/keyword boundary or end
+        Some legacy exporters write a bare ``ZONE F=POINT`` header with no dimensions at
+        all, relying on the reader to count data rows itself.  Peeks ahead (never
+        consuming) counting numeric tokens up to the next zone/keyword boundary or end
         of file, using the same boundary rule :meth:`_parse_zone` already uses to know
         where a header ends and data begins, then restores the original position so the
         real read (later, driven by the now-known count) starts from the same place.
@@ -1283,25 +1531,7 @@ class TecplotDatReader(TecplotReader):
         """
         # -- Collect header lines ------------------------------------------------------
 
-        header_lines: list[str] = [tokens.next_stripped()]  # ZONE T=...
-
-        while tokens.has_more():
-            nxt = tokens.peek_stripped()
-            if not nxt:
-                tokens.next_stripped()
-                continue
-            nxt_upper = nxt.lstrip().upper()
-            # Stop at a new zone, top-level keyword, or the first data line.
-            if nxt_upper.split("=")[0].split()[0] == "ZONE":
-                break
-            if nxt_upper.startswith(("DATASETAUXDATA", "VARAUXDATA")):
-                break
-            first_ch = nxt.lstrip()[0] if nxt.lstrip() else ""
-            # A data line begins with a numeric token (covers leading-dot values such as
-            # ``.5`` and signed values such as ``-1.2e3``).
-            if first_ch in "0123456789+-.":
-                break
-            header_lines.append(tokens.next_stripped())
+        header_lines = _collect_zone_header_lines(tokens)
 
         header_text = " ".join(header_lines)
 
@@ -1320,38 +1550,13 @@ class TecplotDatReader(TecplotReader):
 
         # -- Determine zone type and data packing --------------------------------------
         #
-        # Two header dialects are supported:
-        #   * Modern:  ZONETYPE=FEQuadrilateral, DATAPACKING=POINT
-        #   * Legacy:  F=FEPOINT, ET=QUADRILATERAL
-        #
-        # The FE-vs-ordered distinction comes from ``ZONETYPE`` (modern) or ``F``
-        # (legacy).  ``ET`` (element type) only ever appears on finite-element zones —
-        # ordered/structured data has no elements — so it merely names the element
-        # *shape* once a zone is already known to be FE, and is ignored on ordered
-        # zones. Modern keywords win when present.
-        legacy_is_fe: bool | None = None
+        # See _determine_zone_type for the modern/legacy keyword rules this shares with
+        # the metadata-only scanner (peek_dat_metadata).
         legacy_packing: DataPacking | None = None
         if "F" in kv:
-            legacy_is_fe, legacy_packing = _parse_legacy_format(kv["F"])
-
-        if "ZONETYPE" in kv:
-            zt_raw = kv["ZONETYPE"].rstrip(",").strip().lower()
-            zone_type = _STR_TO_ZONETYPE.get(zt_raw, ZoneType.ORDERED)
-        elif legacy_is_fe is False:
-            # F=POINT/BLOCK: ordered zone. A stray ET (if any) does not apply.
-            zone_type = ZoneType.ORDERED
-        elif legacy_is_fe or "ET" in kv:
-            # Finite-element zone: F=FEPOINT/FEBLOCK, or an ET keyword with no F (some
-            # exporters omit F). The element shape comes from ET, which is then
-            # required.
-            if "ET" not in kv:
-                raise ValueError(
-                    "Legacy FE zone header specifies F=FEPOINT/FEBLOCK but is "
-                    "missing the required ET (element type) keyword."
-                )
-            zone_type = _parse_legacy_element_type(kv["ET"])
-        else:
-            zone_type = ZoneType.ORDERED
+            _, legacy_packing = _parse_legacy_format(kv["F"])
+
+        zone_type = _determine_zone_type(kv)
 
         if zone_type in _FE_POLY:
             raise ValueError(
@@ -1372,7 +1577,7 @@ class TecplotDatReader(TecplotReader):
 
         if zone_type == ZoneType.ORDERED:
             if "I" not in kv and "J" not in kv and "K" not in kv:
-                # Infer the point count from the data that follows
+                # Infer point count
                 active_count = self.num_vars - len(passive_set) - len(share_map)
                 num_nodes = self._infer_ordered_point_count(tokens, active_count)
                 I = num_nodes  # noqa E741

tecio/_io.py

@@ -40,14 +40,14 @@ from __future__ import annotations
 import os
 import tempfile
 from pathlib import Path
-from typing import Any, Literal, overload
+from typing import Any, Literal, NamedTuple, overload
 
 import numpy as np
 import numpy.typing as npt
 
 from ._constants import FileType, ValueLocation, ZoneType
 from ._containers import ZoneList
-from ._dat_read import TecplotDatReader
+from ._dat_read import TecplotDatReader, _peek_dat_metadata
 from ._dat_write import TecplotDatWriter
 from ._plt_read import TecplotPltReader
 from ._plt_write import TecplotPltWriter
@@ -811,3 +811,252 @@ def open(
         raise ValueError(
             f"Unrecognised mode '{mode}'. Supported modes: 'r', 'w', 'x', 'a', 'a+'"
         )
+
+
+# --------------------------------------------------------------------------------------
+# Lightweight metadata queries
+# --------------------------------------------------------------------------------------
+
+
+def _validated_ext(path: str | os.PathLike) -> str:
+    """Return *path*'s lowercased extension, or raise if unsupported.
+
+    Example:
+        >>> _validated_ext("flow.szplt")
+        '.szplt'
+    """
+    ext = Path(path).suffix.lower()
+    if ext not in _HANDLERS:
+        raise ValueError(
+            f"Unsupported file extension: '{ext}'. Supported: {sorted(_HANDLERS)}"
+        )
+    return ext
+
+
+class ZoneSummary(NamedTuple):
+    """Per-zone metadata from a lightweight :func:`peek` query.
+
+    ``num_nodes``/``num_elements`` are ``None`` only for a DAT ordered zone whose header
+    omits I/J/K entirely (rare; relies on the reader inferring the point count from the
+    data itself, which a lightweight query never does). Every other case, and every
+    SZL/PLT zone, always has both.
+    """
+
+    title: str
+    zone_type: ZoneType
+    num_nodes: int | None
+    num_elements: int | None
+
+
+class FileSummary(NamedTuple):
+    """Whole-file metadata from :func:`peek`, with no variable data touched."""
+
+    title: str
+    file_type: FileType
+    variable_names: list[str]
+    zones: list[ZoneSummary]
+
+
+def get_variable_list(path: str | os.PathLike) -> list[str]:
+    """Return a file's variable names without reading any variable data.
+
+    For SZL and PLT this is already what a normal :func:`open` does, both formats
+    resolve dataset-level metadata (including variable names) up front without touching
+    data arrays, so this is a thin convenience wrapper for those two. DAT is different:
+    opening it normally always reads and numerically converts every value in the file,
+    so this function instead scans just the file's header text, several orders of
+    magnitude cheaper for a file with large data blocks.
+
+    Args:
+        path: Path to a ``.szplt``, ``.plt``/``.bin``, or ``.dat``/``.tec`` file.
+
+    Returns:
+        Variable names, in file order.
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+        ValueError: If the file extension is not recognized.
+
+    Example:
+        >>> get_variable_list("flow.szplt")
+        ['x', 'y', 'z', 'pressure']
+    """
+    ext = _validated_ext(path)
+    if ext in (".dat", ".tec"):
+        return _peek_dat_metadata(path).variable_names
+    with _HANDLERS[ext]["r"](str(path)) as r:
+        return list(r.variables)
+
+
+def get_zone_list(path: str | os.PathLike) -> list[str]:
+    """Return a file's zone titles without reading any variable data.
+
+    Same rationale as :func:`get_variable_list`: already cheap for SZL and PLT
+    (constructing a zone reader only resolves scalar metadata, never variable data),
+    so this is a thin wrapper for those; for DAT, uses a dedicated scan that skips
+    every data and connectivity block entirely.
+
+    Args:
+        path: Path to a ``.szplt``, ``.plt``/``.bin``, or ``.dat``/``.tec`` file.
+
+    Returns:
+        Zone titles, in file order. An unnamed zone contributes an empty string, not
+        a placeholder like ``"Zone 1"``.
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+        ValueError: If the file extension is not recognized.
+
+    Example:
+        >>> get_zone_list("flow.szplt")
+        ['FluidVolume', 'WingSurface']
+    """
+    ext = _validated_ext(path)
+    if ext in (".dat", ".tec"):
+        return [z.title for z in _peek_dat_metadata(path).zones]
+    with _HANDLERS[ext]["r"](str(path)) as r:
+        return [zone.title for zone in r.zones]
+
+
+def get_num_zones(path: str | os.PathLike) -> int:
+    """Return a file's zone count without reading any variable data.
+
+    Cheaper still than :func:`get_zone_list`: for SZL, a single scalar C-library
+    call with no zone objects constructed at all; for PLT and DAT, a count against
+    already-parsed/scanned header metadata.
+
+    Args:
+        path: Path to a ``.szplt``, ``.plt``/``.bin``, or ``.dat``/``.tec`` file.
+
+    Returns:
+        Number of zones in the file.
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+        ValueError: If the file extension is not recognized.
+
+    Example:
+        >>> get_num_zones("flow.szplt")
+        2
+    """
+    ext = _validated_ext(path)
+    if ext in (".dat", ".tec"):
+        return len(_peek_dat_metadata(path).zones)
+    with _HANDLERS[ext]["r"](str(path)) as r:
+        return r.num_zones
+
+
+def get_num_variables(path: str | os.PathLike) -> int:
+    """Return a file's variable count without reading any variable data.
+
+    Cheaper still than :func:`get_variable_list`: for SZL, a single scalar
+    C-library call.
+
+    Args:
+        path: Path to a ``.szplt``, ``.plt``/``.bin``, or ``.dat``/``.tec`` file.
+
+    Returns:
+        Number of variables in the dataset.
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+        ValueError: If the file extension is not recognized.
+
+    Example:
+        >>> get_num_variables("flow.szplt")
+        4
+    """
+    ext = _validated_ext(path)
+    if ext in (".dat", ".tec"):
+        return len(_peek_dat_metadata(path).variable_names)
+    with _HANDLERS[ext]["r"](str(path)) as r:
+        return r.num_vars
+
+
+def get_title(path: str | os.PathLike) -> str:
+    """Return a file's dataset title without reading any variable data.
+
+    Args:
+        path: Path to a ``.szplt``, ``.plt``/``.bin``, or ``.dat``/``.tec`` file.
+
+    Returns:
+        Dataset title string.
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+        ValueError: If the file extension is not recognized.
+
+    Example:
+        >>> get_title("flow.szplt")
+        'Onera M6 wing'
+    """
+    ext = _validated_ext(path)
+    if ext in (".dat", ".tec"):
+        return _peek_dat_metadata(path).title
+    with _HANDLERS[ext]["r"](str(path)) as r:
+        return r.title
+
+
+def get_file_type(path: str | os.PathLike) -> FileType:
+    """Return a file's :class:`~tecio.FileType` without reading any variable data.
+
+    Args:
+        path: Path to a ``.szplt``, ``.plt``/``.bin``, or ``.dat``/``.tec`` file.
+
+    Returns:
+        The file type (``FULL``, ``GRID``, or ``SOLUTION``).
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+        ValueError: If the file extension is not recognized.
+
+    Example:
+        >>> get_file_type("flow.szplt")
+        <FileType.FULL: 0>
+    """
+    ext = _validated_ext(path)
+    if ext in (".dat", ".tec"):
+        return _peek_dat_metadata(path).file_type
+    with _HANDLERS[ext]["r"](str(path)) as r:
+        return r.file_type
+
+
+def peek(path: str | os.PathLike) -> FileSummary:
+    """Return a file's title, file type, variable names, and per-zone summaries.
+
+    A single combined query covering everything :func:`get_variable_list`,
+    :func:`get_zone_list`, :func:`get_title`, and :func:`get_file_type` return, plus
+    each zone's type and size. For DAT, calling several of those functions
+    separately on the same file means scanning it that many times over, this
+    function scans once no matter how much of the summary is needed.
+
+    Args:
+        path: Path to a ``.szplt``, ``.plt``/``.bin``, or ``.dat``/``.tec`` file.
+
+    Returns:
+        Whole-file and per-zone metadata. See :class:`FileSummary` and
+        :class:`ZoneSummary`.
+
+    Raises:
+        FileNotFoundError: If *path* does not exist.
+        ValueError: If the file extension is not recognized.
+
+    Example:
+        >>> summary = peek("flow.szplt")
+        >>> [z.title for z in summary.zones]
+        ['FluidVolume', 'WingSurface']
+    """
+    ext = _validated_ext(path)
+    if ext in (".dat", ".tec"):
+        meta = _peek_dat_metadata(path)
+        zones = [
+            ZoneSummary(z.title, z.zone_type, z.num_nodes, z.num_elements)
+            for z in meta.zones
+        ]
+        return FileSummary(meta.title, meta.file_type, meta.variable_names, zones)
+    with _HANDLERS[ext]["r"](str(path)) as r:
+        zones = [
+            ZoneSummary(zone.title, zone.zone_type, zone.num_nodes, zone.num_elements)
+            for zone in r.zones
+        ]
+        return FileSummary(r.title, r.file_type, list(r.variables), zones)

tecio/cli/tecmerge.py

@@ -9,14 +9,18 @@ time-step sequences, solution times can be assigned automatically from a start t
 either a fixed interval or an end time; each zone also gets a strand ID matching its
 1-based position within its source file, so the same physical block (e.g. a wing zone
 present in every timestep) shares one strand across the whole sequence and can be
-animated as a single, continuous entity in the Tecplot GUI.
+animated as a single, continuous entity in the Tecplot GUI. Merged zones get
+``SourceFile``/``SourceFileName`` aux data record of the source file and path. Grid data
+can also be detected and shared across zones with matching structure instead of
+duplicated in every merged zone.
 
 :Usage:
 
 .. code:: bash
 
     tecmerge [-h] -o PATH [-f] [--title STRING] [--assign-time-strands]
-             [-s VALUE] [-d VALUE | -e VALUE] [--strand ID] FILE [FILE ...]
+             [-s VALUE] [-d VALUE | -e VALUE] [--strand ID] [--merge-grid [LIST]]
+             FILE [FILE ...]
 
 :Positional Arguments:
     ``FILE [FILE ...]``
@@ -63,6 +67,26 @@ animated as a single, continuous entity in the Tecplot GUI.
         per-zone-position assignment described under ``--assign-time-strands``. Has no
         effect without ``--assign-time-strands``.
 
+    ``--merge-grid [LIST]``
+        Detect and share grid data (coordinate variables, and for FE zones,
+        connectivity) across zones with matching zone type and dimensions, instead of
+        writing it fresh in every merged zone. Zones are compared by a
+        ``(zone_type, num_nodes, num_elements)`` signature; the first zone with a given
+        signature (in file, then zone, order) writes its grid fresh, and every later
+        zone with a matching signature, whether from the same file or a different one,
+        shares from it instead. This is not a rigorous check that the underlying data
+        is actually identical, just that it plausibly could be, a false match (e.g. two
+        genuinely different blocks that happen to share dimensions) would silently
+        share the wrong grid.
+
+        Given with no value, grid variables are found automatically by name (``x``,
+        ``X``, ``x-coordinate``, ``xgrid``, and similar common names for X/Y/Z). Given a
+        comma-separated list of 1-based indices or exact names into the union variable
+        list instead (e.g. ``--merge-grid x,y,z`` or ``--merge-grid 1,2,3``), only those
+        variables are treated as the grid; indices and names cannot be mixed in the same
+        list. Solution variables are never affected either way, only variables
+        explicitly identified as the grid are ever shared.
+
 :Returns:
     A new Tecplot file written to the output path containing all zones from every input
     file. Variables absent from a source file are written as passive. Exit code is ``0``
@@ -90,6 +114,16 @@ Examples:
         $ tecmerge --assign-time-strands -s 0.0 -d 0.1 --strand 1 \\
                    "step_*.szplt" -o transient.szplt
 
+    Merge a multiblock time series, sharing each block's grid across timesteps
+    instead of duplicating it::
+
+        $ tecmerge --assign-time-strands -s 0.0 -d 0.1 --merge-grid \\
+                   "step_*.szplt" -o transient.szplt
+
+    Same, but only "x" and "y" are grid variables (a 2-D case with no "z")::
+
+        $ tecmerge --merge-grid x,y "step_*.szplt" -o transient.szplt
+
     Call directly from a Python session::
 
         import tecio.cli.tecmerge.main as tecmerge
@@ -122,6 +156,7 @@ from .. import (
     TecplotSzlWriter,
     TecplotWriter,
     TecplotZoneReader,
+    ValueLocation,
     ZoneType,
 )
 from .. import open as tecio_open
@@ -251,6 +286,22 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         ),
     )
 
+    # Grid sharing
+    parser.add_argument(
+        "--merge-grid",
+        nargs="?",
+        const="__auto__",
+        default=None,
+        type=str,
+        metavar="LIST",
+        help=(
+            "Detect and share the grid (coordinate variables, and connectivity for FE "
+            "zones) with matching zone type and dimensions. To manually specify grid "
+            "coordinates provide a comma-separated list of 1-based indices or exact "
+            "variable names (e.g.  -merge-grid x,y,z or -merge-grid 1,2,3)."
+        ),
+    )
+
     return parser.parse_args(argv)
 
 
@@ -258,6 +309,157 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
 # Helpers
 # --------------------------------------------------------------------------------------
 
+# Guesses of grid variable names automatic grid variable detection for merging
+_AXIS_SYNONYMS: dict[str, frozenset[str]] = {
+    "x": frozenset({
+        "x",
+        "x-coordinate",
+        "x coordinate",
+        "coordinate x",
+        "coord-x",
+        "coordx",
+        "xcoord",
+        "x_coord",
+        "xgrid",
+        "x-grid",
+        "x_grid",
+    }),
+    "y": frozenset({
+        "y",
+        "y-coordinate",
+        "y coordinate",
+        "coordinate y",
+        "coord-y",
+        "coordy",
+        "ycoord",
+        "y_coord",
+        "ygrid",
+        "y-grid",
+        "y_grid",
+    }),
+    "z": frozenset({
+        "z",
+        "z-coordinate",
+        "z coordinate",
+        "coordinate z",
+        "coord-z",
+        "coordz",
+        "zcoord",
+        "z_coord",
+        "zgrid",
+        "z-grid",
+        "z_grid",
+    }),
+}
+
+
+def _autodetect_grid_variables(names: list[str]) -> list[int]:
+    """Return the 1-based indices in *names* that look like X/Y/Z coordinates.
+
+    Matched by exact name (case-insensitive, trimmed) against
+    :data:`_AXIS_SYNONYMS`, checked in X, Y, Z order; an axis with no match among
+    *names* is simply omitted rather than guessed at positionally, unlike the
+    ParaView plugin's coordinate resolution, an incorrect guess here would silently
+    mishandle real data instead of just looking odd on screen, so this only
+    returns indices it's actually confident in.
+
+    Example:
+        >>> _autodetect_grid_variables(["x-grid", "y", "pressure"])
+        [1, 2]
+    """
+    indices: list[int] = []
+    for axis in ("x", "y", "z"):
+        synonyms = _AXIS_SYNONYMS[axis]
+        for i, name in enumerate(names, start=1):
+            if name.strip().lower() in synonyms:
+                indices.append(i)
+                break
+    return indices
+
+
+def _parse_index_or_name_list(value: str) -> list[int | str]:
+    """Parse a comma-separated string of 1-based integers and/or variable names.
+
+    Each token is parsed as an integer where possible; anything else is kept as a
+    name string, resolved against the union variable list once it's known.
+
+    Args:
+        value: String like ``"1,2,3"`` or ``"x,y,z"``.
+
+    Returns:
+        List of ``int`` (1-based index) and/or ``str`` (variable name) tokens, in
+        the order given.
+
+    Example:
+        >>> _parse_index_or_name_list("x,y,z")
+        ['x', 'y', 'z']
+    """
+    tokens: list[int | str] = []
+    for raw in value.split(","):
+        token = raw.strip()
+        try:
+            tokens.append(int(token))
+        except ValueError:
+            tokens.append(token)
+    return tokens
+
+
+def _resolve_grid_variable_indices(
+    explicit: str | None, union_vars: list[str]
+) -> set[int] | None:
+    """Resolve ``--merge-grid``'s value into a set of 1-based union indices.
+
+    Args:
+        explicit: ``None`` if ``--merge-grid`` wasn't given at all (the feature is off);
+            the sentinel ``"__auto__"`` if given with no value (detect by name, see
+            :func:`_autodetect_grid_variables`); otherwise a comma-separated list of
+            indices and/or names, all of one kind, not mixed (matching
+            ``-v``/``--variables`` elsewhere in this project).
+        union_vars: The merge's full union variable list.
+
+    Returns:
+        1-based indices into *union_vars* eligible for grid sharing, or ``None`` if
+        ``--merge-grid`` wasn't given at all. An empty set (rather than ``None``) means
+        the feature is on but nothing was found/specified to share, --merge-grid then
+        has no effect.
+
+    Raises:
+        ValueError: If an explicit index is out of range, an explicit name isn't in
+            *union_vars*, or indices and names are mixed in the same list.
+    """
+    if explicit is None:
+        return None
+    if explicit == "__auto__":
+        return set(_autodetect_grid_variables(union_vars))
+
+    tokens = _parse_index_or_name_list(explicit)
+    has_int = any(isinstance(t, int) for t in tokens)
+    has_name = any(isinstance(t, str) for t in tokens)
+    if has_int and has_name:
+        raise ValueError(
+            "--merge-grid indices and names cannot be mixed in the same list; "
+            f"use all indices or all names, got: {explicit!r}."
+        )
+
+    resolved: set[int] = set()
+    for token in tokens:
+        if isinstance(token, int):
+            if token < 1 or token > len(union_vars):
+                raise ValueError(
+                    f"--merge-grid variable index {token} out of range "
+                    f"[1, {len(union_vars)}]."
+                )
+            resolved.add(token)
+        else:
+            try:
+                resolved.add(union_vars.index(token) + 1)
+            except ValueError:
+                raise ValueError(
+                    f"--merge-grid variable name {token!r} not found; available "
+                    f"names: {', '.join(union_vars)}."
+                ) from None
+    return resolved
+
 
 def _expand_inputs(patterns: list[str]) -> list[Path]:
     """Expand a list of file paths / glob patterns to a sorted list of Paths.
@@ -338,6 +540,9 @@ def _write_zone(
     solution_time: float | None,
     strand_id: int | None,
     zone_index_map: dict[int, int],
+    source_path: Path,
+    grid_var_indices: set[int] | None,
+    grid_reference: int | None,
 ) -> None:
     """Write one zone to *writer* using the reconciled variable list.
 
@@ -348,12 +553,24 @@ def _write_zone(
         writer:           Open writer instance.
         zone:             Source zone reader.
         union_vars:       Full union variable name list.
-        local_index_map:  Map from union index -> local 0-based var index
-                          (``None`` = not present in this file).
+        local_index_map:  Map from union index -> local 0-based var index (``None`` =
+                          not present in this file).
         solution_time:    Override solution time, or ``None`` to keep original.
         strand_id:        Override strand ID, or ``None`` to keep original.
         zone_index_map:   Map 1-based source zone to 1-based output zone index for
                           variable and connectivity sharing.
+        source_path:      Input file this zone came from, recorded as zone-level aux
+                          data (``SourceFile``, ``SourceFileName``) on every merged
+                          zone.
+        grid_var_indices: 1-based union indices of the ``--merge-grid`` grid variables,
+                          or ``None`` if the feature is off.
+        grid_reference:   1-based output zone index to share this zone's grid variables
+                          (and, for FE zones, connectivity) from, if an earlier zone
+                          with a matching (zone_type, num_nodes, num_elements) signature
+                          was already written, else ``None`` (this zone's grid is
+                          written fresh; the caller is responsible for registering its
+                          signature afterward). Ignored entirely when *grid_var_indices*
+                          is ``None``.
     """
     zt = zone.zone_type
 
@@ -362,7 +579,22 @@ def _write_zone(
     passive_vars: list[bool] = []
     var_sharing: list[int] = []
 
-    for local_idx in local_index_map:
+    for union_i, local_idx in enumerate(local_index_map, start=1):
+        is_grid_var = grid_var_indices is not None and union_i in grid_var_indices
+
+        if is_grid_var and grid_reference is not None:
+            # An earlier zone with the same zone_type/num_nodes/num_elements already
+            # wrote this grid so share rather than duplicate
+            passive_vars.append(False)
+            var_sharing.append(grid_reference)
+            if local_idx is not None:
+                loc = zone.variables[local_idx].value_location
+            else:
+                loc = ValueLocation.NODAL
+            active_locs.append(loc)
+            active_data.append(np.array([], dtype=np.float32))
+            continue
+
         if local_idx is None:
             # Variable not in this file -- mark passive.
             passive_vars.append(True)
@@ -410,9 +642,13 @@ def _write_zone(
         if not is_p and sv == 0
     ]
 
-    zone_aux: dict[str, str] | None = None
+    zone_aux: dict[str, str] = {}
     if len(zone.auxdata) > 0:
         zone_aux = dict(zone.auxdata.items())
+    # Always added, source provenance is cheap to record and easy to ignore in the
+    # Tecplot GUI if unwanted
+    zone_aux["SourceFile"] = str(source_path)
+    zone_aux["SourceFileName"] = source_path.name
 
     s_time = solution_time if solution_time is not None else zone.solution_time
     s_id = strand_id if strand_id is not None else zone.strand_id
@@ -430,8 +666,14 @@ def _write_zone(
     if isinstance(zone, TecplotOrderedZoneReader):
         writer.write_ordered_zone(data=writer_data, **common_kw)
     elif isinstance(zone, TecplotFEZoneReader):
-        con_src = zone.shared_connectivity
-        con_remapped = zone_index_map.get(con_src) if con_src is not None else None
+        if grid_var_indices is not None and grid_reference is not None:
+            # Share connectivity from the same reference zone as the grid variables, a
+            # matching (zone_type, num_nodes, num_elements) signature implies the same
+            # mesh, node map included.
+            con_remapped: int | None = grid_reference
+        else:
+            con_src = zone.shared_connectivity
+            con_remapped = zone_index_map.get(con_src) if con_src is not None else None
         fe_kw = common_kw.copy()
 
         # Face-neighbor connections
@@ -530,6 +772,17 @@ def main(argv: Sequence[str] | None = None) -> int:
 
         print(f"\nUnion variable list ({n_union}): {union_vars}")
 
+        try:
+            grid_var_indices = _resolve_grid_variable_indices(
+                args.merge_grid, union_vars
+            )
+        except ValueError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        if grid_var_indices is not None:
+            grid_names = [union_vars[i - 1] for i in sorted(grid_var_indices)]
+            print(f"Grid sharing enabled for variables: {grid_names}")
+
         # Report any variables that will be passive in some files.
         for fi, (_reader, imap) in enumerate(zip(readers, index_maps, strict=False)):
             missing = [union_vars[ui] for ui, li in enumerate(imap) if li is None]
@@ -566,6 +819,8 @@ def main(argv: Sequence[str] | None = None) -> int:
                 writer.add_auxvar_dict(auxvar)
 
             total_zones = 0
+            # Persists sharing registry across every input file for merge grid option
+            signature_registry: dict[tuple[ZoneType, int, int], int] = {}
             for fi, (reader, imap) in enumerate(zip(readers, index_maps, strict=False)):
                 sol_time = times[fi] if times is not None else None
 
@@ -595,6 +850,14 @@ def main(argv: Sequence[str] | None = None) -> int:
                     else:
                         s_id = zone_num
 
+                    grid_reference: int | None = None
+                    signature: tuple[ZoneType, int, int] | None = None
+                    if grid_var_indices is not None and isinstance(
+                        zone, (TecplotOrderedZoneReader, TecplotFEZoneReader)
+                    ):
+                        signature = (zt, zone.num_nodes, zone.num_elements)
+                        grid_reference = signature_registry.get(signature)
+
                     _write_zone(
                         writer=writer,
                         zone=zone,
@@ -603,8 +866,15 @@ def main(argv: Sequence[str] | None = None) -> int:
                         solution_time=sol_time,
                         strand_id=s_id,
                         zone_index_map=zone_index_map,
+                        source_path=input_paths[fi],
+                        grid_var_indices=grid_var_indices,
+                        grid_reference=grid_reference,
                     )
                     zone_index_map[zone_num] = writer.current_zone
+                    if signature is not None and grid_reference is None:
+                        # First zone with this signature should write grid, every later
+                        # zone with a matching signature shares from it
+                        signature_registry[signature] = writer.current_zone
                     total_zones += 1
 
         # Close all readers

tecio_python-0.3.3.data/data/share/plugins/matlab/fecplot.m

@@ -0,0 +1,111 @@
+function f = fecplot(dim, x, y, z, c, node_map, varargin)
+% Filled patch contour for unstructured 2D/3D surface zones
+%
+% Call:
+%     h = feplot(dim, x, y, z, c, node_map, ...)
+%
+% Args:
+%     dim: 2 or 3
+%     x,y[,z]: nodal coordinate column vectors (Nx1)
+%     c: contour values; either nodal (Nx1) or cell-centered (Mcells x 1)
+%     node_map: M x K integer matrix of node indices per cell (K=3 or 4)
+%     varargin: name-value pairs forwarded to patch (e.g. 'EdgeColor','none')
+%
+% Returns:
+%     f: handle to the patch object
+%
+% Notes:
+%  - If c is nodal, uses 'FaceVertexCData' with 'FaceColor'='interp'
+%  - If c is cell-centered, uses 'CData' per-face with 'FaceColor'='flat'
+%  - For dim==3, z must be provided and plotting uses 3D patch (viewable with lighting)
+%  - node_map may contain NaNs for unequal-sided cells; those faces are handled
+
+% Validate dim
+if ~ismember(dim, [2,3])
+    error('dim must be 2 or 3');
+end
+
+% Ensure column vectors
+x = x(:); y = y(:);
+if dim == 3
+    if nargin < 4 || isempty(z)
+        error('z must be provided for dim==3');
+    end
+    z = z(:);
+end
+
+% Determine number of nodes and faces
+nNodes = numel(x);
+[nFaces, ~] = size(node_map);
+
+% Validate node_map indices
+if any(node_map(:) > nNodes) || any(node_map(:) < 0 & ~isnan(node_map(:)))
+    error('node_map contains invalid node indices.');
+end
+
+% Prepare vertices matrix
+if dim == 2
+    verts = [x, y];
+else
+    verts = [x, y, z];
+end
+
+% Determine if c is nodal or cell-centered
+c = c(:);
+isNodal = (numel(c) == nNodes);
+isCell   = (numel(c) == nFaces);
+if ~(isNodal || isCell)
+    error('Length of c must match number of nodes (nodal) or number of faces (cell-centered).');
+end
+
+% Clean node_map: replace zeros -> NaN (if any), ensure double
+node_map = double(node_map);
+node_map(node_map==0) = NaN;
+
+% If node_map contains NaNs for some cells, patch accepts NaN-separated faces.
+% Create faces in appropriate format: patch accepts face vertex indices matrix.
+faces = node_map;
+
+% Build patch arguments
+pArgs = varargin;
+
+if isNodal
+    % Nodal data: use FaceVertexCData with interpolation
+    % Create patch with vertices and faces, supply FaceVertexCData
+    % Set FaceColor to 'interp' and EdgeColor as provided or 'none' by default
+    if ~any(strcmpi('FaceColor',pArgs))
+        pArgs = [{'FaceColor','interp'}, pArgs];
+    end
+    if ~any(strcmpi('EdgeColor',pArgs))
+        pArgs = [{'EdgeColor','none'}, pArgs];
+    end
+    % Create patch
+    f = patch('Vertices', verts, 'Faces', faces, 'FaceVertexCData', c, pArgs{:});
+
+else
+    % Cell-centered: supply per-face CData and use flat coloring
+    if ~any(strcmpi('FaceColor',pArgs))
+        pArgs = [{'FaceColor','flat'}, pArgs];
+    end
+    if ~any(strcmpi('EdgeColor',pArgs))
+        pArgs = [{'EdgeColor','none'}, pArgs];
+    end
+    % patch expects CData as Mx1 or Mx3 color; provide as Mx1
+    faceCData = c;
+    % Create patch
+    f = patch('Vertices', verts, 'Faces', faces, 'CData', faceCData, pArgs{:});
+
+end
+
+% Set colormap and colorbar behavior consistent with contourf
+if ~any(strcmpi('EdgeColor',pArgs))
+    set(f,'EdgeColor','none');
+end
+axis equal
+if dim == 3
+    view(3)
+    camlight headlight
+    lighting gouraud
+end
+colorbar
+end

{tecio_python-0.3.2.data/data/share/tecio → tecio_python-0.3.3.data/data/share}/plugins/paraview/TecplotTecioReader.py

@@ -170,6 +170,9 @@ _AXIS_SYNONYMS: dict[str, frozenset[str]] = {
         "coordx",
         "xcoord",
         "x_coord",
+        "xgrid",
+        "x-grid",
+        "x_grid",
     }),
     "y": frozenset({
         "y",
@@ -180,6 +183,9 @@ _AXIS_SYNONYMS: dict[str, frozenset[str]] = {
         "coordy",
         "ycoord",
         "y_coord",
+        "ygrid",
+        "y-grid",
+        "y_grid",
     }),
     "z": frozenset({
         "z",
@@ -190,6 +196,9 @@ _AXIS_SYNONYMS: dict[str, frozenset[str]] = {
         "coordz",
         "zcoord",
         "z_coord",
+        "zgrid",
+        "z-grid",
+        "z_grid",
     }),
 }
 

{tecio_python-0.3.2.dist-info → tecio_python-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tecio-python
-Version: 0.3.2
+Version: 0.3.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/

{tecio_python-0.3.2.dist-info → tecio_python-0.3.3.dist-info}/RECORD

@@ -1,9 +1,9 @@
-tecio/__init__.py,sha256=ygtKbxih989WAsj0yOhPX4m6nXgLUX8PtpBRT1hNL-k,2852
+tecio/__init__.py,sha256=-aohTaSV10NJQTIkixETvD1r34zjOwS2vOI72xNXwIc,3211
 tecio/_constants.py,sha256=k6o3FSuE2mCTtJ431Bg4hzkgVW34-ENEY3U3pLz6CN0,7190
 tecio/_containers.py,sha256=PmVUwYfImIHB8uCHtA0AWQEcOHGBRkGlkMRrY8ONGZA,10501
-tecio/_dat_read.py,sha256=JNZe2KaaE8LyMeYUTKcvHth7DfLOrp2uskxi1rAQvLM,72979
+tecio/_dat_read.py,sha256=Bm17K53DG6ObX7UQA56ghcJQ5UApIJ7Do7yIDIVslvw,81146
 tecio/_dat_write.py,sha256=bB95ziTg9lMG3DdgIg3LKLxtytRM2_qWFp2TRbgSrO4,39994
-tecio/_io.py,sha256=r1Ov0ky98aX-FY7V07mThprhQVTg-oMbju08OWHAyQQ,31525
+tecio/_io.py,sha256=jC3GG5IgvoVXc7s5zoupTdDEqhwtRX840VGfS5Dq7WE,39759
 tecio/_meta.py,sha256=EqOqejk3wjtvB2KSzXZgn6nzDTvIuQqsYsm_agBpr1M,8028
 tecio/_plt_read.py,sha256=3SRWvqbHeIll_zB_TTUUUWibtEaoeoN0x0C0BYm3XY4,56523
 tecio/_plt_write.py,sha256=kq3waOr5TWInNHbT6YdW2HRw5mN5er_IhLLnPLPyPFU,31735
@@ -19,16 +19,17 @@ tecio/cli/tecaux.py,sha256=1ZCL5Ef_8cfR7TXm8tSxNTAgLZnnyDvIawwnVJhfNYg,36712
 tecio/cli/tecdump.py,sha256=pBWYjVMlQNzan5mgfFeLrvRQluRXAGX3JrM0XHSbXmE,12119
 tecio/cli/tecextract.py,sha256=cM70fcwbQE4ziXVFSkhC1ISOlQpXPz-VFI_votqVynM,19435
 tecio/cli/tecfix.py,sha256=c4DGYJ0O48dHW4HppZ2dLVW8HKKtTBsp1MksxYWgiP8,20313
-tecio/cli/tecmerge.py,sha256=3MiZIqkUpXSkZPHX0lhQdJbvZA6eP6P9B593fykjzyw,22336
+tecio/cli/tecmerge.py,sha256=NQ1NMhjvus9Pt02AJO_ZjL7i7N35BoLwdJ-IpZn5EF0,33614
 tecio/cli/teconvert.py,sha256=x2Xmcyn9O7IB-ioE_f_TkEWLrJcMpMy03FLO3X58DTY,12865
 tecio/cli/tecscale.py,sha256=-uSdjfa82g7LIfcj-liMyXpsKNAAACDGP5fGa_pxiyE,14810
 tecio/cli/tecslice.py,sha256=n442ixabc7S74FZwLwo24GShvR1DavHR_Sh7Q07W3og,36246
 tecio/cli/tecstats.py,sha256=kLPz41JBsmgDRL_YrVRZSp_qoW2c-bmb5NI2eFD691k,20923
-tecio_python-0.3.2.data/data/share/tecio/plugins/paraview/TecplotTecioReader.py,sha256=FQC2KcSSRTvEOeYKLFVW_jkgz2Y-6fV9XikRkcO2GLc,44022
-tecio_python-0.3.2.dist-info/licenses/LICENSE,sha256=WYmcYJG1QFgu1hfo7qrEkZ3Jhcz8NUWe6XUraZvlIFs,10172
-tecio_python-0.3.2.dist-info/licenses/NOTICE,sha256=bDcDOguk8dYN4FpHJCHuCsDgR2VnP5XlK2C4BzVCtwg,340
-tecio_python-0.3.2.dist-info/METADATA,sha256=Rd4pM4RA6ivdVSpjj-7eSskc_n3Nt7IPTYYX4a8hUhE,5102
-tecio_python-0.3.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-tecio_python-0.3.2.dist-info/entry_points.txt,sha256=TH2UnRF700KO0GjeRFwkBBtFKN1PyP2tgrc11OsVNAc,362
-tecio_python-0.3.2.dist-info/top_level.txt,sha256=ayCfhWQNUimgwyaTSyamJ3LbgjloZRWl2vlcZCjYWmQ,6
-tecio_python-0.3.2.dist-info/RECORD,,
+tecio_python-0.3.3.data/data/share/plugins/matlab/fecplot.m,sha256=YYPjn7FmIVcE5K4a73WkO_ZV_sNJ4l0426-OYHFqkos,3206
+tecio_python-0.3.3.data/data/share/plugins/paraview/TecplotTecioReader.py,sha256=JXttRwxlHXbKuqh5V-GRkiEh7ACm1xjvgr2KY9xIUXA,44181
+tecio_python-0.3.3.dist-info/licenses/LICENSE,sha256=WYmcYJG1QFgu1hfo7qrEkZ3Jhcz8NUWe6XUraZvlIFs,10172
+tecio_python-0.3.3.dist-info/licenses/NOTICE,sha256=bDcDOguk8dYN4FpHJCHuCsDgR2VnP5XlK2C4BzVCtwg,340
+tecio_python-0.3.3.dist-info/METADATA,sha256=xwyDjPGDBbW4ZQ7vD-xdc_JUVk6ZeKrfKak46FVeUIw,5102
+tecio_python-0.3.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+tecio_python-0.3.3.dist-info/entry_points.txt,sha256=TH2UnRF700KO0GjeRFwkBBtFKN1PyP2tgrc11OsVNAc,362
+tecio_python-0.3.3.dist-info/top_level.txt,sha256=ayCfhWQNUimgwyaTSyamJ3LbgjloZRWl2vlcZCjYWmQ,6
+tecio_python-0.3.3.dist-info/RECORD,,