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

tecio/__init__.py

@@ -4,12 +4,14 @@ Wraps the TecIO C library for ``.szplt``, ``.plt``, and ``.dat`` formats.
 Requires Python 3.10+, NumPy, and a Tecplot 360 installation.
 """
 
+# ruff: noqa: A004
+
 from importlib import metadata
 
 try:
     __version__ = metadata.version("tecio")
 except metadata.PackageNotFoundError:
-    __version__ = "0.3.2"
+    __version__ = "0.4.0"
 
 from . import cli, libtecio
 from ._constants import (
@@ -28,7 +30,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 (
@@ -41,7 +56,7 @@ from ._reader import (
 )
 from ._szl_read import TecplotSzlReader
 from ._szl_write import TecplotSzlWriter
-from ._writer import TecplotWriter
+from ._writer import EmptyZoneWarning, TecplotWriter
 
 # Ensure these display as their canonical public name in docs and help(),
 # rather than the private module they're actually defined in.
@@ -64,6 +79,7 @@ for _cls in (
     TecplotSzlWriter,
     TecplotPltWriter,
     TecplotDatWriter,
+    EmptyZoneWarning,
     Boolean,
     DataPacking,
     DataType,
@@ -82,6 +98,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",
@@ -100,6 +125,7 @@ __all__ = [
     "TecplotSzlWriter",
     "TecplotPltWriter",
     "TecplotDatWriter",
+    "EmptyZoneWarning",
     "Boolean",
     "DataPacking",
     "DataType",

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
@@ -36,6 +37,7 @@ from ._reader import (
     TecplotReader,
     TecplotVariableReader,
     TecplotZoneReader,
+    convert_face_connections_to_zero_based,
 )
 
 # --------------------------------------------------------------------------------------
@@ -299,6 +301,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.
 
@@ -608,9 +697,9 @@ def _parse_auxdata_line(line: str) -> tuple[str, str]:
 def _apply_varauxdata(line: str, var_auxdata_list: list[dict[str, str]]) -> None:
     """Parse ``VARAUXDATA 1-based-idx name="value"`` and store in list.
 
-    *var_auxdata_list* holds plain, mutable dicts, one per variable (index 0 is an
-    unused placeholder), accumulated during parsing. Wrapped into an immutable
-    TecplotDatAuxDataReader lazily, only once parsing is complete.
+    *var_auxdata_list* holds plain, mutable dicts, one per variable, 0-based,
+    accumulated during parsing. Wrapped into an immutable TecplotDatAuxDataReader
+    lazily, only once parsing is complete.
 
     Example:
         >>> _apply_varauxdata(line, var_auxdata_list)
@@ -618,14 +707,14 @@ def _apply_varauxdata(line: str, var_auxdata_list: list[dict[str, str]]) -> None
     m = re.match(r"(?i)VARAUXDATA\s+(\d+)\s+", line)
     if not m:
         return
-    var_idx = int(m.group(1))  # 1-based
+    var_idx = int(m.group(1)) - 1  # 1-based in text, converted to 0-based
     rest = line[m.end() :]
     eq = rest.find("=")
     if eq < 0:
         return
     name = rest[:eq].strip()
     value = _unquote(rest[eq + 1 :].strip())
-    if 1 <= var_idx < len(var_auxdata_list):
+    if 0 <= var_idx < len(var_auxdata_list):
         var_auxdata_list[var_idx][name] = value
 
 
@@ -839,7 +928,7 @@ class TecplotDatVariableReader(TecplotVariableReader):
 
     @property
     def shared_zone(self) -> int | None:
-        """1-based source zone index if shared, else None."""
+        """0-based source zone index if shared, else None."""
         return self._shared_zone
 
     @property
@@ -897,9 +986,9 @@ class TecplotDatOrderedZoneReader(TecplotOrderedZoneReader):
         self,
         zone_index: int,
         title: str,
-        I: int,  # noqa: E741 - matches Tecplot's own IJK convention
-        J: int,
-        K: int,
+        I: int,  # noqa: E741 N803
+        J: int,  # noqa: N803
+        K: int,  # noqa: N803
         solution_time: float,
         strand_id: int,
         variables: list[TecplotVariableReader],
@@ -1022,6 +1111,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.
 
@@ -1062,9 +1307,9 @@ class TecplotDatReader(TecplotReader):
         # TecplotDatAuxDataReader lazily, only once fully parsed.
         self._dataset_auxdata_raw: dict[str, str] = {}
         self._dataset_auxdata: TecplotAuxDataReader | None = None
-        # Index 0 is an unused placeholder so that 1-based indexing works directly;
-        # populated once num_vars is known, see _parse().
-        self._var_auxdata_raw: list[dict[str, str]] = [{}]
+        # 0-based, one dict per variable; populated once num_vars is known, see
+        # _parse().
+        self._var_auxdata_raw: list[dict[str, str]] = []
         # Raw VARAUXDATA lines seen before the first zone, buffered by
         # _parse_file_header() and applied once _var_auxdata_raw is allocated with the
         # correct length (num_vars isn't known until the header finishes parsing).
@@ -1133,7 +1378,7 @@ class TecplotDatReader(TecplotReader):
         self._parse_file_header(tokens)
 
         # Build per-variable aux data slots now that num_vars is known.
-        self._var_auxdata_raw = [{}] + [{} for _ in range(self.num_vars)]
+        self._var_auxdata_raw = [{} for _ in range(self.num_vars)]
 
         # Now that _var_auxdata exists, apply any VARAUXDATA lines that appeared before
         # the first zone
@@ -1143,8 +1388,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 +1479,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 +1532,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 +1551,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,15 +1578,15 @@ 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
-                J = K = 1
+                J = K = 1  # noqa: N806
             else:
-                I = int(kv.get("I", "1") or "1")  # noqa E741
-                J = int(kv.get("J", "1") or "1")
-                K = int(kv.get("K", "1") or "1")
+                I = int(kv.get("I", "1") or "1")  # noqa: E741 N806
+                J = int(kv.get("J", "1") or "1")  # noqa: N806
+                K = int(kv.get("K", "1") or "1")  # noqa: N806
                 num_nodes = I * J * K
             num_cells = max(I - 1, 1) * max(J - 1, 1) * max(K - 1, 1)
         else:
@@ -1491,12 +1697,15 @@ class TecplotDatReader(TecplotReader):
             else:
                 nodes_per_cell = _NODES_PER_ELEM[zone_type]
                 flat = self._read_int_block(tokens, num_cells * nodes_per_cell)
-                node_map = flat.reshape(num_cells, nodes_per_cell)
+                # Node numbers are 1-based in ASCII; convert to 0-based indices
+                # that point directly into the corresponding coordinate array.
+                node_map = flat.reshape(num_cells, nodes_per_cell) - 1
 
         # -- Read face-neighbor connections (FE zones only, if declared) ---------------
         #
-        # Immediately follows connectivity in the file. Values are already
-        # 1-based in ASCII (unlike PLT's binary layout, no +1 needed here).
+        # Immediately follows connectivity in the file. Values are 1-based in ASCII;
+        # cell references, remote-zone references, and the face ordinal are all
+        # converted to 0-based below.
 
         face_connections: npt.NDArray[np.int64] | None = None
         one_to_one = (
@@ -1510,6 +1719,9 @@ class TecplotDatReader(TecplotReader):
             face_connections = self._read_int_block(
                 tokens, declared_face_connections * values_per
             )
+            face_connections = convert_face_connections_to_zero_based(
+                face_connections, face_neighbor_mode
+            )
         elif face_neighbor_mode is not None:
             # "Many" modes: ragged, each record's own 4th value (nz) gives the
             # count of additional neighbor references that follow it.
@@ -1525,6 +1737,9 @@ class TecplotDatReader(TecplotReader):
             face_connections = (
                 np.concatenate(pieces) if pieces else np.empty(0, dtype=np.int64)
             )
+            face_connections = convert_face_connections_to_zero_based(
+                face_connections, face_neighbor_mode
+            )
 
         # -- Build ReadVariable and ReadZone objects -----------------------------------
 
@@ -1553,13 +1768,13 @@ class TecplotDatReader(TecplotReader):
                     self._zones[src_zone_1based - 1].variables[var_idx].values
                 )
 
-        # This zone's own 1-based index
-        zone_index = len(self._zones) + 1
+        # This zone's own 0-based index
+        zone_index = len(self._zones)
 
         read_vars: list[TecplotVariableReader] = [
             TecplotDatVariableReader(
                 zone_index=zone_index,
-                var_index=idx + 1,
+                var_index=idx,
                 name=name,
                 data=_shaped(
                     var_arrays[idx],
@@ -1567,7 +1782,7 @@ class TecplotDatReader(TecplotReader):
                 ),
                 value_location=var_locs.get(idx, ValueLocation.NODAL),
                 is_passive=(idx in passive_set),
-                shared_zone=share_map.get(idx, None),
+                shared_zone=(share_map[idx] - 1 if idx in share_map else None),
             )
             for idx, name in enumerate(self._variable_names)
         ]
@@ -1586,7 +1801,7 @@ class TecplotDatReader(TecplotReader):
                 auxdata=zone_aux,
                 node_map=node_map,
                 datapacking=packing,
-                shared_connectivity=con_share_zone if con_share_zone else None,
+                shared_connectivity=(con_share_zone - 1) if con_share_zone else None,
                 face_neighbor_mode=face_neighbor_mode,
                 num_face_connections=declared_face_connections or None,
                 face_connections=face_connections,
@@ -1599,9 +1814,9 @@ class TecplotDatReader(TecplotReader):
         zone_index: int,
         title: str,
         zone_type: ZoneType,
-        I: int,  # noqa: E741 - matches Tecplot's own IJK convention
-        J: int,
-        K: int,
+        I: int,  # noqa: E741 N803
+        J: int,  # noqa: N803
+        K: int,  # noqa: N803
         solution_time: float,
         strand_id: int,
         variables: list[TecplotVariableReader],