tecio-python 0.3.1__tar.gz → 0.3.3__tar.gz

{tecio_python-0.3.1/tecio_python.egg-info → tecio_python-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tecio-python
-Version: 0.3.1
+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/
@@ -82,6 +82,8 @@ export TECIO_LIB=/path/to/libtecio.dylib  # macOS
 
 ## Quick start
 
+Writing a file:
+
 ```python
 import tecio
 import numpy as np
@@ -90,7 +92,7 @@ x = np.linspace(0, 2 * np.pi, 100)
 y = np.sin(x)
 
 with tecio.open("sine.szplt", "w") as tec:
-    tec.write_ijk_zone(data=[x, y], variables=["x", "y"])
+    tec.write_ordered_zone(data=[x, y], variables=["x", "y"])
 ```
 
 Reading a file:
@@ -98,10 +100,10 @@ Reading a file:
 ```python
 with tecio.open("sine.szplt", "r") as tec:
     print(tec.variables)  # ['x', 'y']
-    x = tec.zone[0].variable[0].values
-    y = tec.zone[0].variable[1].values
+    x = tec.zones[0].variables[0].values
+    y = tec.zones[0].variables[1].values
     # or
-    x, y = tec.zone[0].get_array(["x", "y"])
+    x, y = tec.zones[0].get_array(["x", "y"])
 ```
 
 ## API
@@ -129,7 +131,7 @@ Supported formats:
 
 ## Contributing
 
-Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+Contributions are welcome (see [CONTRIBUTING.md](CONTRIBUTING.md) for details).
 
 ---
 

{tecio_python-0.3.1 → tecio_python-0.3.3}/README.md

@@ -38,6 +38,8 @@ export TECIO_LIB=/path/to/libtecio.dylib  # macOS
 
 ## Quick start
 
+Writing a file:
+
 ```python
 import tecio
 import numpy as np
@@ -46,7 +48,7 @@ x = np.linspace(0, 2 * np.pi, 100)
 y = np.sin(x)
 
 with tecio.open("sine.szplt", "w") as tec:
-    tec.write_ijk_zone(data=[x, y], variables=["x", "y"])
+    tec.write_ordered_zone(data=[x, y], variables=["x", "y"])
 ```
 
 Reading a file:
@@ -54,10 +56,10 @@ Reading a file:
 ```python
 with tecio.open("sine.szplt", "r") as tec:
     print(tec.variables)  # ['x', 'y']
-    x = tec.zone[0].variable[0].values
-    y = tec.zone[0].variable[1].values
+    x = tec.zones[0].variables[0].values
+    y = tec.zones[0].variables[1].values
     # or
-    x, y = tec.zone[0].get_array(["x", "y"])
+    x, y = tec.zones[0].get_array(["x", "y"])
 ```
 
 ## API
@@ -85,7 +87,7 @@ Supported formats:
 
 ## Contributing
 
-Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+Contributions are welcome (see [CONTRIBUTING.md](CONTRIBUTING.md) for details).
 
 ---
 

tecio_python-0.3.3/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.1/tecio → tecio_python-0.3.3}/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",
     }),
 }
 
@@ -449,7 +458,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
 
         self._zone_selection.RemoveAllArrays()
         self._zone_keys.clear()
-        for zone in reader.zone:
+        for zone in reader.zones:
             title = zone.title or f"Zone {zone.zone_index}"
             key = f"{zone.zone_index}: {title}"
             self._zone_keys[zone.zone_index] = key
@@ -677,7 +686,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
         static/always-present geometry, so they're excluded from the time axis and
         instead included at every requested time (see :meth:`RequestData`).
         """
-        times = {zone.solution_time for zone in reader.zone if zone.strand_id != 0}
+        times = {zone.solution_time for zone in reader.zones if zone.strand_id != 0}
         return sorted(times)
 
     @smproperty.doublevector(
@@ -760,7 +769,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
         self._add_variable_aux_field_data(output.GetFieldData(), reader)
 
         block_index = 0
-        for zone in reader.zone:
+        for zone in reader.zones:
             key = self._zone_keys.get(zone.zone_index)
             if key is not None and not self._zone_selection.ArrayIsEnabled(key):
                 continue
@@ -990,7 +999,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
         n_points = dataset.GetNumberOfPoints()
         n_cells = dataset.GetNumberOfCells()
 
-        for var in zone.variable:
+        for var in zone.variables:
             if not self._array_selection.ArrayIsEnabled(var.name):
                 continue
             values = var.values
@@ -1039,7 +1048,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
             if name is None:
                 flat_components.append(None)
                 continue
-            var = zone.variable[name]
+            var = zone.variables[name]
             values = var.values
             if values is None:  # passive, or absent in this specific zone
                 flat_components.append(None)

{tecio_python-0.3.1 → tecio_python-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tecio-python"
-version = "0.3.1"
+version = "0.3.3"
 description = "Python interface for reading and writing Tecplot data files"
 
 readme = "README.md"
@@ -69,6 +69,10 @@ mat = ["scipy"]
 include = ["tecio*"]
 exclude = ["archive*", "test*"]
 
+[tool.setuptools.data-files]
+"share/plugins/paraview" = ["plugins/paraview/*"]
+"share/plugins/matlab" = ["plugins/matlab/*"]
+
 [tool.ruff]
 line-length = 88
 target-version = "py310"
@@ -109,7 +113,7 @@ python-version = "3.11"
 output-format = "concise"
 
 [[tool.ty.overrides]]
-include = ["tecio/plugins/**"]
+include = ["plugins/**"]
 
 [tool.ty.overrides.rules]
 unresolved-import = "ignore"

{tecio_python-0.3.1 → tecio_python-0.3.3}/tecio/__init__.py

@@ -9,7 +9,7 @@ from importlib import metadata
 try:
     __version__ = metadata.version("tecio")
 except metadata.PackageNotFoundError:
-    __version__ = "0.3.1"
+    __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_python-0.3.1 → tecio_python-0.3.3}/tecio/_containers.py

@@ -1,35 +1,35 @@
 """Index- and name-based container types for Tecplot data collections.
 
-These containers are shared by the ``tecio`` readers: ``Read.zone`` returns a
-:class:`ZoneList` of ``ReadZone`` and ``ReadZone.variable`` returns a
+These containers are shared by the ``tecio`` readers: ``Read.zones`` returns a
+:class:`ZoneList` of ``ReadZone`` and ``ReadZone.variables`` returns a
 :class:`VariableList` of ``ReadVariable`` for every supported format (SZL, PLT, DAT).
-They depend only on small structural protocols (``.name`` for variables, ``.variable``
+They depend only on small structural protocols (``.name`` for variables, ``.variables``
 for zones) so they import nothing from either hierarchy and cannot introduce a circular
 dependency.
 
 Access model:
 
-    reader.zone                  # ZoneList
-    reader.zone[0]               # ReadZone            (element)
-    reader.zone[1:4]             # ZoneList            (sub-collection, same kind)
-    reader.zone[0].variable      # VariableList
-    reader.zone[0].variable["x"] # ReadVariable        (object: .values, .is_passive)
-    reader.zone[0].variable[2]   # ReadVariable        (0-based index)
+    reader.zones                  # ZoneList
+    reader.zones[0]               # ReadZone            (element)
+    reader.zones[1:4]             # ZoneList            (sub-collection, same kind)
+    reader.zones[0].variables      # VariableList
+    reader.zones[0].variables["x"] # ReadVariable        (object: .values, .is_passive)
+    reader.zones[0].variables[2]   # ReadVariable        (0-based index)
 
 Subscripting always returns an element or a sub-collection *of the same kind* (never a
 raw array). The underlying NumPy data is pulled with ``get_array`` on a single zone,
 which mirrors the pandas ``df[...]`` split: a scalar key returns one array, a list of
 names returns a tuple of arrays (for unpacking)::
 
-    p = reader.zone[0].get_array("p")  # ndarray | None
-    p = reader.zone[0].get_array(2)  # ndarray | None  (0-based index)
-    x, y, z = reader.zone[0].get_array(["x", "y", "z"])  # tuple, one per name
+    p = reader.zones[0].get_array("p")  # ndarray | None
+    p = reader.zones[0].get_array(2)  # ndarray | None  (0-based index)
+    x, y, z = reader.zones[0].get_array(["x", "y", "z"])  # tuple, one per name
 
 There is deliberately **no** cross-zone array accessor. To pull one variable across
 many zones (e.g. a transient sequence), iterate explicitly so the outer axis is owned by
 your code, and stack only when you know the result is rectangular::
 
-    seq = [z.get_array("p") for z in reader.zone]  # list[ndarray | None]
+    seq = [z.get_array("p") for z in reader.zones]  # list[ndarray | None]
     stack = np.stack(seq)  # only if shapes all match
 
 Name lookup is exact and case-sensitive throughout, so distinct variables such
@@ -78,7 +78,7 @@ class _HasVariableList(Protocol):
     """A zone element exposing a name/index-addressable variable container."""
 
     @property
-    def variable(self) -> VariableList[Any]: ...
+    def variables(self) -> VariableList[Any]: ...
 
 
 _VarT = TypeVar("_VarT", bound=_HasName)
@@ -137,7 +137,7 @@ def select_variable_arrays(
 class VariableList(Generic[_VarT]):
     """Read-only sequence of variables with positional *and* named access.
 
-    Drop-in for the ``list`` previously returned by ``ReadZone.variable``:
+    Drop-in for the ``list`` previously returned by ``ReadZone.variables``:
     iteration, ``len()``, and integer indexing are unchanged. A string key
     resolves a variable by its exact, case-sensitive name.
 
@@ -208,7 +208,7 @@ class VariableList(Generic[_VarT]):
         """Return the variable names in dataset order."""
         return [var.name for var in self._items]
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # pragma: no cover
         n = len(self._items)
         if n == 0:
             return "VariableList([])"
@@ -229,16 +229,16 @@ class VariableList(Generic[_VarT]):
 class ZoneList(Generic[_ZoneT]):
     """Read-only sequence of zones: positional access and slicing only.
 
-    Drop-in for the ``list`` previously returned by ``Read.zone``: iteration, ``len()``,
-    and integer indexing are unchanged. Slicing returns another :class:`ZoneList` (not a
-    plain ``list``) so navigation composes.
+    Drop-in for the ``list`` previously returned by ``Read.zones``: iteration,
+    ``len()``, and integer indexing are unchanged. Slicing returns another
+    :class:`ZoneList` (not a plain ``list``) so navigation composes.
 
     This container deliberately exposes **no** data-extraction method. Pulling one
     variable across many zones is an explicit loop over the zones, keeping the outer
     (zone) axis owned by the caller (see the module docs).
 
     Args:
-        zones: Ordered list of zone elements (each exposing ``.variable``).
+        zones: Ordered list of zone elements (each exposing ``.variables``).
     """
 
     __slots__ = ("_items",)
@@ -277,7 +277,7 @@ class ZoneList(Generic[_ZoneT]):
             return ZoneList(self._items[key])
         return self._items[key]
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # pragma: no cover
         n = len(self._items)
         if n == 0:
             return "ZoneList([])"