tecio-python 0.2.2__py3-none-any.whl → 0.2.4__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.0.0"
+    __version__ = "0.2.4"
 
 from . import cli, dat, libtecio, plt, szl
 from ._containers import VariableList, ZoneList

tecio/cli/tec2mat.py

@@ -136,9 +136,9 @@ 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:

tecio/cli/tecdump.py

@@ -70,7 +70,7 @@ Examples:
 See Also:
     * :mod:`tecio.cli.tecstats` - Compute per-zone min, max, and mean statistics without
       printing raw values.
-    * :mod:`tecio.cli.tecfix`: Rewrite a file with invalid variable
+    * :mod:`tecio.cli.tecfix` - Rewrite a file with invalid variable
       arrays set to passive once bad values have been identified.
 """
 

tecio/cli/tecfix.py

@@ -66,9 +66,9 @@ Examples:
         tecfix(["flow.szplt", "--output", "clean.szplt"])
 
 See Also:
-    * :mod:`tecio.cli.tecdump`: Inspect file contents and metadata to
+    * :mod:`tecio.cli.tecdump` - Inspect file contents and metadata to
       identify zones or variables that may require fixing.
-    * :mod:`tecio.cli.tecstats`: Compute per-zone min, max, and mean
+    * :mod:`tecio.cli.tecstats` - Compute per-zone min, max, and mean
       statistics without printing raw values.
 
 Note:

tecio/cli/tecmerge.py

@@ -83,10 +83,10 @@ Examples:
         tecmerge(["part1.szplt", "part2.szplt", "--output", "combined.szplt"])
 
 See Also:
-    * :mod:`tecio.cli.tecextract`: Extract a zone/variable subset from a single file —
+    * :mod:`tecio.cli.tecextract` - Extract a zone/variable subset from a single file —
       the inverse of merging.
-    * :mod:`tecio.cli.tecsplit`: Split a file into separate grid and solution files.
-    * :mod:`tecio.cli.tecslice`: Extract planar slices from volumetric zone data.
+    * :mod:`tecio.cli.tecsplit` - Split a file into separate grid and solution files.
+    * :mod:`tecio.cli.tecslice` - Extract planar slices from volumetric zone data.
 
 """
 
@@ -155,6 +155,7 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         ),
     )
     parser.add_argument(
+        "-f",
         "--force",
         action="store_true",
         default=False,

tecio/cli/teconvert.py

@@ -71,7 +71,7 @@ Examples:
         teconvert(["-dat", "-o", "flow.dat", "flow.szplt"])
 
 See Also:
-    :mod:`tecio.cli.tecextract`: Extract a zone/variable subset while simultaneously
+    :mod:`tecio.cli.tecextract` - Extract a zone/variable subset while simultaneously
     converting format via the output file extension.
 """
 
@@ -132,7 +132,7 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
             "  Explicit output path\n"
             "    $ teconvert -plt -o /tmp/out.plt flow.dat\n"
             "  Overwrite existing\n"
-            "  teconvert --force -dat flow.szplt\n"
+            "    $ teconvert --force -dat flow.szplt\n"
         ),
         formatter_class=lambda prog: argparse.RawDescriptionHelpFormatter(
             prog, width=70, max_help_position=24

tecio/cli/tecscale.py

@@ -80,7 +80,7 @@ Examples:
         tecscale(["-variable", "Pressure", "-scale", "1e-3", "flow.szplt"])
 
 See Also:
-    :mod:`tecio.cli.teconvert`: Convert between Tecplot file formats without applying
+    :mod:`tecio.cli.teconvert` - Convert between Tecplot file formats without applying
     any variable transformation.
 
 """

tecio/cli/tecslice.py

@@ -114,10 +114,10 @@ Examples:
         tecslice(["-i", "::2", "-o", "thinned.szplt", "flow.szplt"])
 
 See Also:
-    * :mod:`tecio.cli.tecextract`: Extract a subset of zones or variables by index
+    * :mod:`tecio.cli.tecextract` - Extract a subset of zones or variables by index
       rather than by positional slice.
-    * :mod:`tecio.cli.tecsplit`: Split a file into separate grid and solution files.
-    * :mod:`tecio.cli.tecmerge`: Merge zones from multiple files into a single output.
+    * :mod:`tecio.cli.tecsplit` - Split a file into separate grid and solution files.
+    * :mod:`tecio.cli.tecmerge` - Merge zones from multiple files into a single output.
 """
 
 from __future__ import annotations
@@ -277,7 +277,7 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         description=(
             # -|--------------------|---------------------------------------------|
             "Slice a Tecplot file along IJK indices (ordered zones) and/or\n"
-            "solution time (all zone types).\n"
+            "solution time (all zone types).\n\n"
             "Slice notation: start:end:skip (any component may be omitted)."
         ),
         epilog=(
@@ -329,9 +329,9 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     ijk = parser.add_argument_group(
         "IJK slicing",
         (
-            "Colon-notation slices for structured axes.  "
-            "Indices are 1-based and inclusive.  "
-            "Applied only to ordered (structured) zones."
+            # -|--------------------|---------------------------------------------|
+            "Colon-notation slices for structured axes. Indices are 1-based and\n"
+            "inclusive. Applied only to ordered (structured) zones."
         ),
     )
     for axis in ("i", "j", "k"):
@@ -351,8 +351,9 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     tslice = parser.add_argument_group(
         "solution-time slicing",
         (
-            "Applied per strand to all zone types.  "
-            "Strand-0 zones are always written unchanged."
+            # -|--------------------|---------------------------------------------|
+            "Applied per strand to all zone types. Strand-0 zones are always\n"
+            "written unchanged."
         ),
     )
     tslice.add_argument(

tecio/cli/tecstats.py

@@ -85,9 +85,9 @@ Examples:
         tecstats(["-zone", "2", "-variable", "3", "flow.szplt"])
 
 See Also:
-    * :mod:`tecio.cli.tecdump`: Inspect the full contents and metadata of a file,
+    * :mod:`tecio.cli.tecdump` - Inspect the full contents and metadata of a file,
       including auxiliary data and raw variable arrays.
-    * :mod:`tecio.cli.tecfix`: Rewrite a file with invalid variable arrays set to
+    * :mod:`tecio.cli.tecfix` - Rewrite a file with invalid variable arrays set to
        passive once bad values have been identified via statistics.
 
 """

tecio/dat/_read.py

@@ -137,6 +137,10 @@ _STR_TO_DATATYPE: dict[str, DataType] = {
 #: Values per line for Write data blocks.
 _VALUES_PER_LINE: int = 5
 
+# Safety cap on the number of grow-and-reparse iterations the vectorized block readers
+# will attempt before giving up and falling back to the tolerant token-by-token parser
+_MAX_FAST_BLOCK_ITERATIONS: int = 64
+
 
 # ======================================================================================
 # Shared internal helpers
@@ -174,6 +178,42 @@ def _strip_comment(line: str) -> str:
     return line[:idx].rstrip() if idx >= 0 else line.rstrip()
 
 
+def _is_float_block_boundary(line: str) -> bool:
+    r"""Return ``True`` if a stripped *line* ends a float data block early.
+
+    Shared by :meth:`Read._read_float_block_slow` (line-by-line) and
+    :meth:`Read._read_float_block_fast` (bulk, on parse failure) so the two readers
+    agree on exactly where a block stops.
+
+    Example:
+        >>> _is_float_block_boundary("ZONE T=\\"next\\"")
+        True
+    """
+    upper = line.lstrip().upper()
+    if not upper:
+        return False
+    if upper.split("=")[0].split()[0] == "ZONE":
+        return True
+    return (
+        upper.startswith(("DATASETAUXDATA", "VARAUXDATA"))
+        or upper.startswith("TITLE")
+        and "=" in upper
+        or upper.startswith("VARIABLES")
+        and "=" in upper
+    )
+
+
+def _is_int_block_boundary(line: str) -> bool:
+    r"""Return ``True`` if a stripped *line* ends an int (connectivity) block.
+
+    Example:
+        >>> _is_int_block_boundary("DATASETAUXDATA foo=\\"bar\\"")
+        True
+    """
+    upper = line.lstrip().upper()
+    return upper.startswith(("ZONE", "DATASETAUXDATA"))
+
+
 def _infer_data_type(arr: npt.NDArray) -> DataType:
     """Return the most appropriate :class:`DataType` for *arr*'s dtype.
 
@@ -569,38 +609,99 @@ def _apply_varauxdata(line: str, var_auxdata_list: list) -> None:
 class _LineBuffer:
     """Peekable iterator over stripped, comment-free text lines.
 
+    Also exposes a small *raw* interface (:meth:`take_raw`, :meth:`position`,
+    :meth:`seek`) used only by the vectorized numeric-block readers
+    (:meth:`Read._read_float_block_fast`/:meth:`Read._read_int_block_fast`).  Those
+    readers bypass per-line comment-stripping for speed and instead detect the rare line
+    that *isn't* plain numeric data (a comment, a header keyword) by letting NumPy's
+    parser fail on it, then falling back to this class's ordinary stripped-line
+    interface. Keeping both interfaces on one object means the fast path can hand back
+    an exact resume position for that fallback via :meth:`position`/:meth:`seek`.
+
     Example:
         >>> buf = _LineBuffer(lines)
     """
 
+    __slots__ = ("_lines", "_peeked", "_peeked_pos", "_pos")
+
     def __init__(self, lines: list[str]) -> None:
         self._lines: list[str] = lines
         self._pos: int = 0
+        # One-line lookahead cache so a peek_stripped() immediately followed by
+        # next_stripped() strips comments/whitespace only once instead of twice.
+        self._peeked: str | None = None
+        self._peeked_pos: int = -1
 
     def has_more(self) -> bool:
         """Return ``True`` if there are unconsumed lines."""
-        return self._pos < len(self._lines)
+        return self._peeked is not None or self._pos < len(self._lines)
 
     def peek_stripped(self) -> str:
         """Return the next non-blank stripped line without consuming it."""
+        if self._peeked is not None:
+            return self._peeked
         pos = self._pos
-        while pos < len(self._lines):
-            raw = _strip_comment(self._lines[pos])
-            stripped = raw.strip()
+        n = len(self._lines)
+        while pos < n:
+            stripped = _strip_comment(self._lines[pos]).strip()
+            pos += 1
             if stripped:
+                self._peeked = stripped
+                self._peeked_pos = pos
                 return stripped
-            pos += 1
+        self._peeked = ""
+        self._peeked_pos = pos
         return ""
 
     def next_stripped(self) -> str:
         """Consume and return the next non-blank stripped line."""
-        while self._pos < len(self._lines):
-            raw = _strip_comment(self._lines[self._pos])
-            self._pos += 1
-            stripped = raw.strip()
-            if stripped:
-                return stripped
-        return ""
+        if self._peeked is None:
+            self.peek_stripped()
+        value = self._peeked or ""
+        self._pos = self._peeked_pos
+        self._peeked = None
+        self._peeked_pos = -1
+        return value
+
+    def take_raw(self, count: int) -> list[str]:
+        """Consume and return up to *count* **unprocessed** source lines.
+
+        Unlike :meth:`next_stripped`, this does not strip comments, skip blank lines, or
+        strip whitespace -- it is a raw slice of the underlying line list, advancing the
+        position by exactly how many lines were returned (fewer than *count* at end of
+        file). Any pending :meth:`peek_stripped` lookahead is discarded first, since
+        this call always resumes from the true unconsumed position.
+
+        Intended only for the numeric fast-path readers, which feed the result straight
+        to a whitespace-tolerant NumPy parser and don't need per-line preprocessing.
+
+        Example:
+            >>> lines = buf.take_raw(64)
+        """
+        self._peeked = None
+        self._peeked_pos = -1
+        end = min(self._pos + count, len(self._lines))
+        out = self._lines[self._pos : end]
+        self._pos = end
+        return out
+
+    def position(self) -> int:
+        """Return an opaque marker for the current position.
+
+        Example:
+            >>> marker = buf.position()
+        """
+        return self._pos
+
+    def seek(self, marker: int) -> None:
+        """Restore the position to a marker previously returned by :meth:`position`.
+
+        Example:
+            >>> buf.seek(marker)
+        """
+        self._pos = marker
+        self._peeked = None
+        self._peeked_pos = -1
 
 
 # ======================================================================================
@@ -706,20 +807,23 @@ class ReadAuxData:
 class ReadVariable:
     """Variable metadata and data for one zone parsed from an ASCII DAT file.
 
-    Interface matches :class:`szl.ReadVariable`.
-
-    Example:
-        >>> var = ReadVariable(name, data, value_location, ...)
+    Args:
+        zone_index: 1-based index of the zone this variable belongs to.
+        var_index:  1-based dataset variable index.
     """
 
     def __init__(
         self,
+        zone_index: int,
+        var_index: int,
         name: str,
         data: npt.NDArray | None,
         value_location: ValueLocation = ValueLocation.NODAL,
         is_passive: bool = False,
         shared_zone: int | None = None,
     ) -> None:
+        self.zone_index: int = zone_index
+        self.var_index: int = var_index
         self._name: str = name
         self._data: npt.NDArray | None = data
         self._value_location: ValueLocation = value_location
@@ -844,6 +948,7 @@ class ReadZone:
     """Zone data parsed from a Tecplot ASCII DAT file.
 
     Attributes:
+        zone_index: 1-based dataset zone index.
         datapacking: :class:`~tecio.libtecio.DataPacking` member reflecting the
             ``DATAPACKING`` keyword found in the zone header (``BLOCK`` or
             ``POINT``). The data arrays are identical either way; this attribute
@@ -853,14 +958,15 @@ class ReadZone:
             automatically resolves to the source zone's array.
 
     Example:
-        >>> zone = ReadZone(title, zone_type, I, J, K, ...)
+        >>> zone = ReadZone(zone_index, title, zone_type, I, J, K, ...)
     """
 
     def __init__(
         self,
+        zone_index: int,
         title: str,
         zone_type: ZoneType,
-        I: int,  # noqa: E741
+        I: int,  # noqa E741
         J: int,
         K: int,
         solution_time: float,
@@ -871,6 +977,7 @@ class ReadZone:
         datapacking: DataPacking = DataPacking.BLOCK,
         shared_connectivity: int | None = None,
     ) -> None:
+        self.zone_index: int = zone_index
         self.title: str = title
         self.zone_type: ZoneType = zone_type
         self.I: int = I
@@ -1052,7 +1159,6 @@ class Read:
         release on exit. Provided for API consistency with the Write classes and to
         support the ``with tecio.open(...) as r:`` pattern.
         """
-        pass
 
     # -- Properties --------------------------------------------------------------------
 
@@ -1264,9 +1370,7 @@ class Read:
             # 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") or nxt_upper.startswith(
-                "VARAUXDATA"
-            ):
+            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
@@ -1332,7 +1436,7 @@ class Read:
             )
 
         if zone_type == ZoneType.ORDERED:
-            I = int(kv.get("I", "1") or "1")  # noqa: E741
+            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")
             num_nodes = I * J * K
@@ -1342,7 +1446,7 @@ class Read:
             # spellings for the node and element counts.
             num_nodes = int(kv.get("NODES", kv.get("N", "0")) or "0")
             num_cells = int(kv.get("ELEMENTS", kv.get("E", "0")) or "0")
-            I, J, K = num_nodes, num_cells, 0  # noqa: E741
+            I, J, K = num_nodes, num_cells, 0  # noqa E741
 
         # Packing: DATAPACKING wins, then legacy F, else BLOCK (Tecplot default).
         if "DATAPACKING" in kv:
@@ -1459,8 +1563,13 @@ class Read:
                     self._zones[src_zone_1based - 1].variable[var_idx].values
                 )
 
+        # This zone's own 1-based index
+        zone_index = len(self._zones) + 1
+
         read_vars = [
             ReadVariable(
+                zone_index=zone_index,
+                var_index=idx + 1,
                 name=name,
                 data=_shaped(
                     var_arrays[idx],
@@ -1475,6 +1584,7 @@ class Read:
 
         self._zones.append(
             ReadZone(
+                zone_index=zone_index,
                 title=zone_title,
                 zone_type=zone_type,
                 I=I,
@@ -1497,26 +1607,98 @@ class Read:
         """Read *n_values* floats from *tokens* into an intermediate float64 array.
 
         This is a pure text-parsing primitive. Callers cast the result to each
-        variable's real dtype  afterward, once individual per-variable arrays have been
+        variable's real dtype afterward, once individual per-variable arrays have been
         split out.
 
+        Dispatches to :meth:`_read_float_block_fast`, a vectorized NumPy parser that
+        handles the overwhelming majority of (well-formed) input in a handful of C-level
+        calls regardless of block size, and falls back to :meth:`_read_float_block_slow`
+        -- a tolerant, token-by-token parser -- only if the fast path can't make sense
+        of what it read (a stray comment or non-numeric token inside the block, or a
+        boundary reached before *n_values* values were collected). The fallback re-reads
+        from *tokens* at the position the fast path started from, so the two never
+        disagree about what was consumed.
+
         See Also:
             :meth:`_read_block_var_data`/:meth:`_read_point_var_data`.
 
         Examples:
             >>> arr = Read._read_float_block(tokens, 100)
         """
+        if n_values <= 0:
+            return np.empty(0, dtype=np.float64)
+
+        marker = tokens.position()
+        try:
+            arr = Read._read_float_block_fast(tokens, n_values)
+        except ValueError:
+            arr = None
+        if arr is not None:
+            return arr
+
+        tokens.seek(marker)
+        return Read._read_float_block_slow(tokens, n_values)
+
+    @staticmethod
+    def _read_float_block_fast(
+        tokens: _LineBuffer, n_values: int
+    ) -> npt.NDArray | None:
+        """Vectorized fast path for :meth:`_read_float_block`.
+
+        Reads raw (unprocessed) lines in a handful of growing bulk grabs (sized from a
+        one-line width probe, so a multi-million-value block costs a small constant
+        number of Python-level calls). Passing ``sep`` here is the (fully supported)
+        text-parsing mode of that function, not its deprecated binary-decoding mode.
+
+        Returns ``None`` (never a short array) if a block boundary is hit before
+        *n_values* values are collected, so the caller can unambiguously fall back to
+        the slow, boundary-aware parser. A ``ValueError`` from ``numpy.fromstring`` is
+        allowed to propagate to the caller for the same reason.
+
+        Example:
+            >>> arr = Read._read_float_block_fast(tokens, 100)
+
+        """
+        pieces: list[npt.NDArray] = []
+        have = 0
+        per_line: int | None = None
+        for _ in range(_MAX_FAST_BLOCK_ITERATIONS):
+            remaining = n_values - have
+            if remaining <= 0:
+                break
+            # First grab is a single-line probe to measure the block's (typically
+            # constant) values-per-line width
+            n_lines = 1 if per_line is None else -(-remaining // per_line)
+            batch = tokens.take_raw(n_lines)
+            if not batch:
+                return None  # ran out of input before reaching n_values
+            piece = np.fromstring("".join(batch), dtype=np.float64, sep=" ")
+            if per_line is None:
+                per_line = max(piece.size, 1)
+            pieces.append(piece)
+            have += piece.size
+        else:
+            return None  # didn't converge; let the slow path sort it out
+        arr = pieces[0] if len(pieces) == 1 else np.concatenate(pieces)
+        return arr[:n_values] if arr.size >= n_values else None
+
+    @staticmethod
+    def _read_float_block_slow(tokens: _LineBuffer, n_values: int) -> npt.NDArray:
+        """Tolerant, token-by-token fallback for :meth:`_read_float_block`.
+
+        Reads one stripped line at a time, converting tokens one at a time and silently
+        skipping any that aren't valid floats, stopping at a block boundary (see
+        :func:`_is_float_block_boundary`) even if *n_values* hasn't been reached
+        yet. Slow by design, but guarantees a result either way.
+
+        Example:
+            >>> arr = Read._read_float_block_slow(tokens, 100)
+
+        """
         values: list[float] = []
         while len(values) < n_values and tokens.has_more():
             nxt = tokens.peek_stripped()
-            upper = nxt.lstrip().upper()
-            if (
-                upper.split("=")[0].split()[0] == "ZONE"
-                or upper.startswith("DATASETAUXDATA")
-                or upper.startswith("VARAUXDATA")
-                or (upper.startswith("TITLE") and "=" in upper)
-                or (upper.startswith("VARIABLES") and "=" in upper)
-            ):
+            if _is_float_block_boundary(nxt):
                 break
             line = tokens.next_stripped()
             for tok in line.split():
@@ -1547,6 +1729,10 @@ class Read:
         to that variable's actual declared dtype (from ``DT=``, or the spec's documented
         SINGLE default) right here, where each variable's array is finalized.
 
+        Reading one variable at a time (rather than all of them in a single combined
+        call) is deliberate: :meth:`_read_float_block`'s vectorized fast path already
+        costs only a handful of C-level calls per block regardless of size.
+
         Note:
             Passive and shared variables contribute a ``None`` placeholder to the
             returned list. The caller resolves shared variables against the zones parsed
@@ -1649,14 +1835,70 @@ class Read:
     def _read_int_block(tokens: _LineBuffer, n_values: int) -> npt.NDArray:
         """Read exactly *n_values* integers from *tokens* into an int64 array.
 
+        Used for connectivity (node-map) data, which can run to tens of millions of
+        entries for large volume meshes. Follows the same vectorized-fast-path /
+        tolerant-slow-path split as :meth:`_read_float_block`; see that method's
+        docstring for the rationale.
+
         Examples:
             >>> arr = Read._read_int_block(tokens, 24)
         """
+        if n_values <= 0:
+            return np.empty(0, dtype=np.int64)
+
+        marker = tokens.position()
+        try:
+            arr = Read._read_int_block_fast(tokens, n_values)
+        except ValueError:
+            arr = None
+        if arr is not None:
+            return arr
+
+        tokens.seek(marker)
+        return Read._read_int_block_slow(tokens, n_values)
+
+    @staticmethod
+    def _read_int_block_fast(tokens: _LineBuffer, n_values: int) -> npt.NDArray | None:
+        """Vectorized fast path for :meth:`_read_int_block`.
+
+        See :meth:`_read_float_block_fast`, which this mirrors exactly except for the
+        target dtype.
+
+        Example:
+            >>> arr = Read._read_int_block_fast(tokens, 24)
+        """
+        pieces: list[npt.NDArray] = []
+        have = 0
+        per_line: int | None = None
+        for _ in range(_MAX_FAST_BLOCK_ITERATIONS):
+            remaining = n_values - have
+            if remaining <= 0:
+                break
+            n_lines = 1 if per_line is None else -(-remaining // per_line)
+            batch = tokens.take_raw(n_lines)
+            if not batch:
+                return None
+            piece = np.fromstring("".join(batch), dtype=np.int64, sep=" ")
+            if per_line is None:
+                per_line = max(piece.size, 1)
+            pieces.append(piece)
+            have += piece.size
+        else:
+            return None
+        arr = pieces[0] if len(pieces) == 1 else np.concatenate(pieces)
+        return arr[:n_values] if arr.size >= n_values else None
+
+    @staticmethod
+    def _read_int_block_slow(tokens: _LineBuffer, n_values: int) -> npt.NDArray:
+        """Tolerant, token-by-token fallback for :meth:`_read_int_block`.
+
+        Example:
+            >>> arr = Read._read_int_block_slow(tokens, 24)
+        """
         values: list[int] = []
         while len(values) < n_values and tokens.has_more():
             nxt = tokens.peek_stripped()
-            upper = nxt.lstrip().upper()
-            if upper.startswith("ZONE") or upper.startswith("DATASETAUXDATA"):
+            if _is_int_block_boundary(nxt):
                 break
             line = tokens.next_stripped()
             for tok in line.split():

tecio/plt/_read.py

@@ -552,7 +552,7 @@ class ReadVariable:
 
         # Byte-swap if needed so the result is always native-endian
         if data.dtype.byteorder not in ("=", "|", np.dtype(dt).str[0]):
-            data = data.byteswap().newbyteorder()
+            data = data.byteswap().view(data.dtype.newbyteorder())
 
         # Reshape for full reads of ordered zones, using the owning zone's dimensions
         # and value location (they describe the on-disk layout including cell-centered