cffview 0.4.2__tar.gz → 0.4.4__tar.gz

{cffview-0.4.2/src/cffview.egg-info → cffview-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cffview
-Version: 0.4.2
+Version: 0.4.4
 Summary: A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without opening Fluent
 Author-email: preamer <1524477126@qq.com>
 License-Expression: BSD-3-Clause

{cffview-0.4.2 → cffview-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cffview"
-version = "0.4.2"
+version = "0.4.4"
 description = "A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without opening Fluent"
 readme = "README.md"
 requires-python = ">=3.10"

{cffview-0.4.2 → cffview-0.4.4}/src/cffview/boundary.py

@@ -115,31 +115,10 @@ class BoundaryFactory:
         boundary_cls = cls._REGISTRY.get(type_, NotImplementedBoundary)
         return boundary_cls(name, id_)
 
-    @staticmethod
-    def match_property(property_list: list[str | list[str]]) -> str | dict[str, str]:
-        match property_list:
-            case [_]:
-                return ''
-            case [_, expr] | [_, '.', expr] if isinstance(expr, str):
-                return expr
-            case [_, x, y, z] if all(isinstance(i, str) for i in (x, y, z)):
-                return f'{x} {y} {z}'
-            case [_, [sel, '.', expr], *_]:
-                return f'{sel}/{expr}'
-            case [_, ['profile', sel, expr], *_]:
-                return f'profile/{sel}/{expr}'
-            case ['source-terms', *source_terms_list]:
-                for source_term in (st for st in source_terms_list if len(st) == 2):
-                    eq_name, source_property_list = source_term
-                    source_property = source_property_list[0]
-                    if source_property[1] == '.':
-                        return {eq_name: f'{source_property[0]}/{source_property[2]}'}
-                    elif source_property[0] == 'profile' and source_property[1]:
-                        return {eq_name: f'profile/{source_property[1]}/{source_property[2]}'}
-
 
 # ------------------------------------------------- shared to_dict helpers
 
+
 TURBULENCE_KEYS = (
     'ke_spec', 'turb_intensity', 'turb_length_scale',
     'turb_hydraulic_diam', 'turb_viscosity_ratio',

{cffview-0.4.2 → cffview-0.4.4}/src/cffview/main.py

@@ -243,7 +243,7 @@ def plot(file_path: str, out: bool = False, xy: bool = False, dat: bool = False)
             raise ValueError("Please specify --out, --xy or --dat")
 
 
-def plot_data(file_path: str):
+def plot_data(file_path: str) -> None:
     """Visualize Fluent .cas.h5 + .dat.h5 solution data with interactive cross-sections.
 
     Uses PyVista's built-in VTK FLUENTCFF Reader to load both mesh and solution data

{cffview-0.4.2 → cffview-0.4.4}/src/cffview/plotter.py

@@ -8,7 +8,7 @@ variable switching, opacity and clip-plane widgets.
 import sys
 from functools import wraps
 
-from pyvista import _vtk, Plotter, MultiBlock, PolyData, UnstructuredGrid, DataSetMapper
+from pyvista import _vtk, Actor, Plotter, MultiBlock, PolyData, UnstructuredGrid, DataSetMapper
 
 from .utils import print_colored_dict
 
@@ -32,7 +32,7 @@ KEYBOARD_SHORTCUTS = {
 
 
 class BasePlotter:
-    def __init__(self, mesh: MultiBlock | PolyData):
+    def __init__(self, mesh: MultiBlock | PolyData) -> None:
         self.mesh = mesh.combine() if isinstance(mesh, MultiBlock) else mesh
 
         # Monkey patch to fix clip plane error
@@ -55,7 +55,7 @@ class BasePlotter:
         self.keyboard_shortcuts = KEYBOARD_SHORTCUTS
 
     @wraps(Plotter.show)
-    def show(self, *args, **kwargs):
+    def show(self, *args, **kwargs) -> None:
         print_colored_dict(self.keyboard_shortcuts)
         self.pl.show(*args, **kwargs)
 
@@ -63,7 +63,7 @@ class BasePlotter:
             self,
             checkbox_params: dict = None,
             text_params: dict = None,
-    ):
+    ) -> _vtk.vtkButtonWidget:
         checkbox_params = checkbox_params or {}
         text_params = text_params or {}
 
@@ -73,17 +73,17 @@ class BasePlotter:
                 checkbox_params['position'][1] + 10,
             )
 
-        check_box_widget = self.pl.add_checkbox_button_widget(**checkbox_params)
+        check_box_widget: _vtk.vtkButtonWidget = self.pl.add_checkbox_button_widget(**checkbox_params)
         check_box_widget.callback = checkbox_params['callback']
         self.pl.add_text(**text_params)
 
         return check_box_widget
 
-    def _add_grid_cb(self):
-        def toggle_grid(state: bool):
+    def _add_grid_cb(self) -> _vtk.vtkButtonWidget:
+        def toggle_grid(state: bool) -> None:
             self.pl.show_grid(font_size=10, fmt='%.2f') if state else self.pl.remove_bounds_axes()
 
-        grid_cb = self._add_checkbox_and_text(
+        grid_cb: _vtk.vtkButtonWidget = self._add_checkbox_and_text(
             checkbox_params=dict(
                 callback=toggle_grid,
                 value=False,
@@ -98,13 +98,13 @@ class BasePlotter:
         return grid_cb
 
     def _add_keyboard_shortcuts(self, key_widget_dict: dict[str, tuple[_vtk.vtkButtonWidget | _vtk.vtkSliderWidget, str]]):
-        def reverse(checkbox_button_widget: _vtk.vtkButtonWidget):
+        def reverse(checkbox_button_widget: _vtk.vtkButtonWidget) -> None:
             rep = checkbox_button_widget.button_representation
             new_state = not rep.state
             rep.state = new_state
             checkbox_button_widget.callback(new_state)
 
-        def set_value(slider_widget: _vtk.vtkSliderWidget, new_value: int):
+        def set_value(slider_widget: _vtk.vtkSliderWidget, new_value: int) -> None:
             slider_widget.slider_representation.value = new_value
             slider_widget.callback(new_value)
 
@@ -117,7 +117,7 @@ class BasePlotter:
 
 
 class MeshPlotter(BasePlotter):
-    def __init__(self, mesh, dimension: int = None):
+    def __init__(self, mesh, dimension: int = None) -> None:
         super().__init__(mesh)
         self.dimension = dimension
         self.mesh_actor = self._add_mesh()
@@ -132,7 +132,7 @@ class MeshPlotter(BasePlotter):
             }
         )
 
-    def _add_mesh(self):
+    def _add_mesh(self) -> Actor:
         mesh_actor = self.pl.add_mesh(
             self.mesh,
             show_edges=True,
@@ -140,8 +140,8 @@ class MeshPlotter(BasePlotter):
         )
         return mesh_actor
 
-    def _add_opcatity_slider(self):
-        opacity_slider_widget = self.pl.add_slider_widget(
+    def _add_opcatity_slider(self) -> _vtk.vtkSliderWidget:
+        opacity_slider_widget: _vtk.vtkSliderWidget = self.pl.add_slider_widget(
             lambda value: setattr(self.mesh_actor.prop, 'opacity', value),
             rng=(0.1, 1.0),
             value=1.0,
@@ -155,14 +155,14 @@ class MeshPlotter(BasePlotter):
         )
         return opacity_slider_widget
 
-    def _add_mesh_clip_plane(self):
+    def _add_mesh_clip_plane(self) -> None:
         self.mesh_clip_plane_actor = self.pl.add_mesh_clip_plane(self.mesh, show_edges=True)
         self.mesh_clip_plane_actor.visibility = False
         self.clip_plane = self.pl.widgets.plane_widgets[-1]
         self.clip_plane.Off()
 
-    def _add_clip_plane_cb(self):
-        def toggle_clip_plane(state):
+    def _add_clip_plane_cb(self) -> _vtk.vtkButtonWidget:
+        def toggle_clip_plane(state) -> None:
             if state:
                 self.mesh_actor.visibility = False
                 self.opacity_slider_widget.Off()
@@ -190,7 +190,7 @@ class MeshPlotter(BasePlotter):
 
 
 class DataPlotter(BasePlotter):
-    def __init__(self, mesh: MultiBlock | PolyData, var_names: tuple[str]):
+    def __init__(self, mesh: MultiBlock | PolyData, var_names: tuple[str]) -> None:
         super().__init__(mesh)
         self.var_names = var_names
 
@@ -254,11 +254,11 @@ class DataPlotter(BasePlotter):
         self.scalar_bar.title = name
         self.pl.render()
 
-    def _add_scalar_slider_widget(self):
-        def change_scalar(value: float):
+    def _add_scalar_slider_widget(self) -> _vtk.vtkSliderWidget:
+        def change_scalar(value: float) -> None:
             self._set_scalars(self.var_names[int(value)])
 
-        scalar_slider = self.pl.add_slider_widget(
+        scalar_slider: _vtk.vtkSliderWidget = self.pl.add_slider_widget(
             change_scalar,
             rng=(0, len(self.var_names) - 1),
             value=0,
@@ -274,8 +274,8 @@ class DataPlotter(BasePlotter):
         scalar_slider.callback = change_scalar
         return scalar_slider
 
-    def _add_clip_plane_cb(self):
-        def toggle_clip_plane(state):
+    def _add_clip_plane_cb(self) -> _vtk.vtkButtonWidget:
+        def toggle_clip_plane(state) -> None:
             if state:
                 self.mesh_actor.visibility = False
                 self.mesh_clip_plane_actor.visibility = True

{cffview-0.4.2 → cffview-0.4.4}/src/cffview/reader.py

@@ -15,6 +15,7 @@ import sexpdata
 
 NestedStrList: TypeAlias = list[Union[str, 'NestedStrList']]
 CaseTexts = namedtuple('CaseTexts', ['general', 'boundary', 'cortex'])
+ReaderFunc: TypeAlias = Callable[[CaseTexts], dict[str, Any]]
 
 # from Ansys Fluent sg.h
 DISCRETIZATION_SCHEME = {
@@ -165,6 +166,30 @@ def _get_reference_values(general: str) -> dict[str, str]:
     }
 
 
+@lru_cache(maxsize=None)
+def _get_flow_scheme(general: str) -> str:
+    """Return the pressure-velocity coupling scheme name (e.g. ``SIMPLE``)."""
+    scheme = re.search(r'\(flow/scheme\s+(\d+)\)', general).group(1)
+    return DISCRETIZATION_SCHEME.get(scheme, scheme)
+
+
+@lru_cache(maxsize=None)
+def _get_pseudo_time_method(general: str, flow_scheme: str) -> str:
+    """Return the pseudo time method state: ``Off``, ``Global Time Step`` or ``Local Time Step``.
+
+    Disabled when ``user-defined-settings?`` is ``#f``; for the Coupled
+    scheme a global pseudo time step is used, otherwise a local one.
+    """
+    if flow_scheme == 'Coupled':
+        key = 'pseudo-time-method/coupled-pbns/user-defined-settings?'
+    else:
+        key = 'pseudo-time-method/segregated-pbns/user-defined-settings?'
+    enabled = re.search(rf'\({re.escape(key)}\s+([^)]+)\)', general).group(1)
+    if enabled == '#f':
+        return 'Off'
+    return 'Global Time Step' if flow_scheme == 'Coupled' else 'Local Time Step'
+
+
 @singledispatch
 def _sel_expr(arg, *args) -> str:
     """Unsupported first-argument type for :func:`_sel_expr`."""
@@ -196,12 +221,12 @@ def _(lst: list[str], return_expr: bool = False) -> str:
 # ------------------------------------------------------------- dispatcher
 
 
-READERS: dict[str, Callable[[CaseTexts], dict[str, Any]]] = {}
+READERS: dict[str, ReaderFunc] = {}
 
 
-def register_reader(name: str):
+def register_reader(name: str) -> Callable[[ReaderFunc], ReaderFunc]:
     """Register a reader function under a flag name."""
-    def decorator(func: Callable[[CaseTexts], dict[str, Any]]) -> Callable[[CaseTexts], dict[str, Any]]:
+    def decorator(func: ReaderFunc) -> ReaderFunc:
         READERS[name] = func
         return func
     return decorator
@@ -215,6 +240,7 @@ def _read_solver(texts: CaseTexts) -> dict[str, Any]:
     general = texts.general
     kvs = _parse_case_config(general)
     dimension = '3d' if kvs['rp-3d?'] == '#t' else '2d'
+    flow_scheme = _get_flow_scheme(general)
 
     solver: dict[str, Any] = {
         'type': 'pbns' if kvs['rp-seg?'] == '#t' else 'dbns',
@@ -223,6 +249,8 @@ def _read_solver(texts: CaseTexts) -> dict[str, Any]:
         'precision': 'double' if kvs['rp-double?'] == '#t' else 'single',
         'axi': 'true' if kvs['rp-axi?'] == '#t' else 'false',
         'init': 'hybrid' if kvs['hyb-init?'] == '#t' else 'standard',
+        'flow-scheme': flow_scheme,
+        'pseudo-time-method': _get_pseudo_time_method(general, flow_scheme),
         'turb': _get_turb_model(general),
         'energy': 'true' if kvs['rf-energy?'] == '#t' else 'false',
         'radiation': _get_radiation_model(general),
@@ -250,29 +278,33 @@ def _read_materials(texts: CaseTexts) -> dict[str, Any]:
         data[name] = {'type': material[1]}
         for property_ in material[2:]:
             property_name = property_[0]
-            if property_[1] == '.':
-                data[name][property_name] = property_[2]
-            elif isinstance(property_value_list := property_[1], list):
-                if property_value_list[1] == '.':
-                    data[name][property_name] = f'{property_value_list[0]}/{property_value_list[2]}'
-                elif property_value_list[1] == 'piecewise-linear':
-                    value = [f'{p[0]}, {p[2]}' for p in property_value_list[2:]]
-                    data[name][property_name] = {f'{property_value_list[0]}/{property_value_list[1]}': value}
-                elif property_value_list[1] in ['piecewise-polynomial', 'nasa-9-piecewise-polynomial']:
-                    value = [str(p).strip('[]') for p in property_value_list[2:]]
-                    data[name][property_name] = {f'{property_value_list[0]}/{property_value_list[1]}': value}
-                elif property_value_list[0] == 'orthotropic':
+            match property_[1:]:
+                case ['.', value]:
+                    data[name][property_name] = value
+                case [[sel, '.', expr], *_]:
+                    data[name][property_name] = f'{sel}/{expr}'
+                case [['polynomial', 'piecewise-linear', *values_list], *_]:
+                    data[name][property_name] = {
+                        f'polynomial/piecewise-linear': [f'{v[0]}, {v[2]}' for v in values_list]
+                    }
+                case [['polynomial', polynomial_type, *values_list], *_] if polynomial_type in ('piecewise-polynomial', 'nasa-9-piecewise-polynomial'):
+                    data[name][property_name] = {
+                        f'polynomial/{polynomial_type}': [str(v).strip('[]') for v in values_list]
+                    }
+                case [['polynomial', *values_list], *_]:
+                    data[name][property_name] = {f'polynomial': [str(v).strip('[]') for v in values_list]}
+                case [['orthotropic', *orth_properties], *_]:
                     value = {}
-                    for p in property_value_list[1:]:
-                        orth_property_name = p[0]
-                        if orth_property_name in ['direction-0', 'direction-1', 'direction-2']:
-                            value[orth_property_name] = [int(i) for i in p[1:]]
-                        elif orth_property_name in ['k0', 'k1', 'k2']:
-                            value[orth_property_name] = _sel_expr(p[1])
-                    data[name][property_name] = {property_value_list[0]: value}
-                else:
-                    value = ' '.join(str(p) for p in property_value_list[1:])
-                    data[name][property_name] = f'{property_value_list[0]}/{value}'
+                    for orth_property in orth_properties:
+                        orth_property_name = orth_property[0]
+                        if orth_property_name in ('direction-0', 'direction-1', 'direction-2'):
+                            value[orth_property_name] = str([int(i) for i in orth_property[1:]]).strip('[]')
+                        elif orth_property_name in ('k0', 'k1', 'k2'):
+                            value[orth_property_name] = _sel_expr(orth_property[1])
+                    data[name][property_name] = value
+                case _:
+                    value = ' '.join(str(p) for p in property_[1:])
+                    data[name][property_name] = f'{property_[0]}/{value}'
     return {'materials': data}
 
 
@@ -293,7 +325,27 @@ def _read_boundary(texts: CaseTexts) -> dict[str, Any]:
         for property_list in boundary_info[2]:
             property_name = property_list[0].replace('-', '_').replace('?', '').replace('/', '_')
             if hasattr(new_boundary, property_name):
-                setattr(new_boundary, property_name, BoundaryFactory.match_property(property_list))
+                match property_list:
+                    case [_, expr] | [_, '.', expr] if isinstance(expr, str):
+                        value = expr
+                    case [_, x, y, z] if all(isinstance(i, str) for i in (x, y, z)):
+                        value = f'{x} {y} {z}'
+                    case [_, [sel, '.', expr], *_]:
+                        value = f'{sel}/{expr}'
+                    case [_, ['profile', sel, expr], *_]:
+                        value = f'profile/{sel}/{expr}'
+                    case ['source-terms', *source_terms_list]:
+                        value = {}
+                        for source_term in (st for st in source_terms_list if len(st) == 2):
+                            eq_name, source_property_list = source_term
+                            source_property = source_property_list[0]
+                            if source_property[1] == '.':
+                                value[eq_name] = f'{source_property[0]}/{source_property[2]}'
+                            elif source_property[0] == 'profile' and source_property[1]:
+                                value[eq_name] = f'profile/{source_property[1]}/{source_property[2]}'
+                    case _:
+                        value = ''
+                setattr(new_boundary, property_name, value)
 
         b_list.append(
             new_boundary.to_dict(_get_turb_model(texts.general), _get_radiation_model(texts.general))
@@ -316,10 +368,13 @@ def _read_interfaces(texts: CaseTexts) -> dict[str, Any]:
     data: dict[str, Any] = {}
     for interface in interfaces_list:
         name = interface[0]
-        data[name] = {
-            property_[0]: property_[2] if len(property_) == 3 else property_[1]
-            for property_ in filter(lambda x: len(x) > 1, interface[1:])
-        }
+        data[name] = {}
+        for interface_property in interface[1:]:
+            match interface_property:
+                case [property_name, '.', value] | [property_name, value]:
+                    data[name][property_name] = value
+                case _:
+                    continue
     return {'interfaces': data}
 
 
@@ -395,6 +450,13 @@ def _read_disc(texts: CaseTexts) -> dict[str, Any]:
     }
 
     data: dict[str, Any] = {'disc-scheme': {}, 'relax-factor': {}}
+    cell_lsq = re.search(r'\(recon/cell-lsq\?\s+([^)]+)\)', general).group(1)
+    node_lsq = re.search(r'\(recon/node-lsq\?\s+([^)]+)\)', general).group(1)
+    data['disc-scheme']['gradient'] = (
+        'Least Squares Cell-Based' if cell_lsq == '#t'
+        else 'Green-Gauss Node-Based' if node_lsq == '#t'
+        else 'Green-Gauss Cell-Based'
+    )
     for eq in ['flow', 'pressure', 'mom', 'temperature', 'k', 'omega', 'epsilon']:
         data['disc-scheme'][eq] = disc_scheme.get(eq)
 
@@ -410,13 +472,27 @@ def _read_disc(texts: CaseTexts) -> dict[str, Any]:
                 general
             ).group(1)
     else:
+        pseudo_time_method = _get_pseudo_time_method(general, data['disc-scheme']['flow'])
+        relax_prefix = '' if pseudo_time_method == 'Off' else 'dual-ts-implicit-'
         relax_factor = {
             ur[0]: ur[1]
-            for ur in re.findall(r'\((.*)/relax\s+([\d.]+)\)', general)
+            for ur in re.findall(rf'\((.*)/{relax_prefix}relax\s+([\d.]+)\)', general)
         }
         for eq in ['pressure', 'mom', 'temperature', 'k', 'omega', 'epsilon', 'turb-viscosity', 'density', 'body-force']:
             data['relax-factor'][eq] = relax_factor.get(eq, '')
 
+    turb_model = _get_turb_model(general)
+    if turb_model == 'lam':
+        for eq in ['k', 'omega', 'epsilon', 'turb-viscosity']:
+            data['disc-scheme'].pop(eq, None)
+            data['relax-factor'].pop(eq, None)
+    elif turb_model == 'kw':
+        data['disc-scheme'].pop('epsilon', None)
+        data['relax-factor'].pop('epsilon', None)
+    elif turb_model == 'ke':
+        data['disc-scheme'].pop('omega', None)
+        data['relax-factor'].pop('omega', None)
+
     return data
 
 
@@ -435,34 +511,26 @@ def _read_report_definitions(texts: CaseTexts) -> dict[str, Any]:
         report_def = rd[1]
         type_ = report_def[1]
         data[name] = {'type': type_}
-        property_dict = {
-            property_[0]: property_[2]
-            for property_ in report_def[2:]
-            if len(property_) == 3 and property_[1] == '.'
-        }
-        data[name].update(property_dict)
-        if 'volume' in type_:
-            data[name]['zone-list'] = [zone for zone in report_def[4][1:]]
-            data[name]['zone-names'] = [zone for zone in report_def[6][1:]]
-        elif 'surface' in type_:
-            data[name]['surface-ids'] = [surface for surface in report_def[4][1:]]
-            data[name]['surface-names'] = [surface for surface in report_def[5][1:]]
-        elif 'flux' in type_:
-            data[name]['zone-ids'] = [zone for zone in report_def[2][1:]]
-            data[name]['zone-names'] = [zone for zone in report_def[3][1:]]
+        for report_property in report_def[2:]:
+            match report_property:
+                case [prop_name, '.', value]:
+                    data[name][prop_name] = value
+                case [prop_name, *values] if prop_name not in ('old-props', 'locations'):
+                    data[name][prop_name] = values
+                case _:
+                    continue
 
     avg_over_state = re.search(r'(\(monitor/average-over-state.*)', general, re.M).group(1)
     avg_over_state_list = stringify_nested_list(sexpdata.loads(avg_over_state, true=None)[1])
     for rd in avg_over_state_list:
         name = rd[0]
-        ids = [id_.split('.')[0] for id_ in rd[1]]
-        iter_range = rd[2][:2]
-        data[name]['iter-range'] = ' -> '.join(iter_range)
+        data[name]['iter-range'] = rd[2][0] + ' -> ' + rd[2][1]
 
         if data[name].get('per-zone?') == '#f' or data[name].get('per-surface?') == '#f':
             value = rd[2][2]
             data[name]['average-over-state'] = value
         else:
+            ids = [id_.split('.')[0] for id_ in rd[1]]
             values = sum(rd[2][2:], [])
             right_order_ids = data[name].get('zone-list') or data[name].get('surface-ids') or data[name].get('zone-ids')
             sorted_values = [0] * len(values)
@@ -484,13 +552,16 @@ def _read_plotsets(texts: CaseTexts) -> dict[str, Any]:
 
     data: dict[str, Any] = {}
     for plotset in plotsets_list:
-        plotset_dict = {
-            property_[0]: property_[2]
-            for property_ in plotset
-            if property_[0] not in ['old-props', 'report-defs']
-        }
-        plotset_dict['report-defs'] = plotset[6][1:]
-        data[plotset_dict['name']] = plotset_dict
+        name = plotset[0][2]
+        data[name] = {}
+        for plotset_property in plotset[1:]:
+            match plotset_property:
+                case [prop_name, '.', value]:
+                    data[name][prop_name] = value
+                case [prop_name, *values] if prop_name not in ('old-props'):
+                    data[name][prop_name] = values
+                case _:
+                    continue
     return {'plotsets': data}
 
 
@@ -502,13 +573,16 @@ def _read_monitorsets(texts: CaseTexts) -> dict[str, Any]:
 
     data: dict[str, Any] = {}
     for monitorset in monitorsets_list:
-        monitorset_dict = {
-            property_[0]: property_[2]
-            for property_ in monitorset
-            if property_[0] not in ['old-props', 'report-defs']
-        }
-        monitorset_dict['report-defs'] = monitorset[-4][1:]
-        data[monitorset_dict['name']] = monitorset_dict
+        name = monitorset[0][2]
+        data[name] = {}
+        for monitorset_property in monitorset[1:]:
+            match monitorset_property:
+                case [prop_name, '.', value]:
+                    data[name][prop_name] = value
+                case [prop_name, *values] if prop_name not in ('old-props'):
+                    data[name][prop_name] = values
+                case _:
+                    continue
     return {'monitorsets': data}
 
 
@@ -596,31 +670,29 @@ def _read_surfaces(texts: CaseTexts) -> dict[str, Any]:
     data: dict[str, Any] = {}
     for surface_def in surface_def_list:
         surface = surface_def[2]
-        surface_type = surface[0]
-        match surface_type:
-            case 'line-surface':
-                virtual_id = surface[1]
+        match surface:
+            case ['line-surface', virtual_id, start, end]:
                 data[virtual_id_name_map[virtual_id]] = {
-                    'type': surface_type,
-                    'start': surface[2],
-                    'end': surface[3],
+                    'type': 'line-surface',
+                    'start': start,
+                    'end': end,
                 }
-            case 'plane-surface':
-                virtual_id = surface[1]
+            case ['plane-surface', virtual_id, point1, point2, point3, bounded, [ref_plane, direction_vector, ref_point]]:
                 data[virtual_id_name_map[virtual_id]] = {
-                    'type': surface_type,
-                    'point 1': surface[2],
-                    'point 2': surface[3],
-                    'point 3': surface[4],
-                    'bounded': surface[5],
+                    'type': 'plane-surface',
+                    'point 1': point1,
+                    'point 2': point2,
+                    'point 3': point3,
+                    'bounded': bounded,
                     'method': {
-                        'type': surface[6][0],
-                        'direction vector': surface[6][1],
-                        'reference point': surface[6][2],
-                    },
+                        'reference plane': ref_plane,
+                        'direction vector': direction_vector,
+                        'reference point': ref_point,
+                    }
                 }
             case _:
                 continue
+
     return {'surfaces': data}
 
 
@@ -635,25 +707,19 @@ def _read_contours(texts: CaseTexts) -> dict[str, Any]:
 
     data: dict[str, Any] = {}
     for contour in contours_list:
-        contour_dict = {
-            property_[0]: property_[2]
-            for property_ in contour
-            if property_[0] not in [
-                'locations', 'location-ids', 'options',
-                'range-options', 'range-option', 'surfaces-list',
-                'color-map', 'colorings', 'annotations-list',
-            ]
-        }
-        contour_dict['surface-list'] = contour[2][1]
-        contour_dict['range-options'] = {
-            range_option[0]: range_option[2]
-            for range_option in contour[6][1:]
-        }
-        contour_dict['color-map'] = {
-            color_map[0]: color_map[2]
-            for color_map in contour[-7][1:]
-        }
-        data[contour_dict['name']] = contour_dict
+        name = contour[0][2]
+        data[name] = {}
+        for contour_property in contour[1:]:
+            match contour_property:
+                case [property_name, '.', value]:
+                    data[name][property_name] = value
+                case ['surfaces-list', *surfaces_list]:
+                    data[name]['surfaces-list'] = surfaces_list
+                case [property_name, *values] if property_name in ('range-options', 'color-map'):
+                    data[name][property_name] = {value[0]: value[2] for value in values}
+                case _:
+                    continue
+
     return {'contours': data}
 
 
@@ -665,33 +731,19 @@ def _read_vectors(texts: CaseTexts) -> dict[str, Any]:
 
     data: dict[str, Any] = {}
     for vector in vectors_list:
-        vector_dict = {
-            property_[0]: property_[2]
-            for property_ in vector
-            if property_[0] not in [
-                'locations', 'location-ids', 'options', 'scale',
-                'range-options', 'range-option', 'surfaces-list',
-                'color-map', 'vector-opt', 'annotations-list',
-            ]
-        }
-        vector_dict['surface-list'] = vector[3][1]
-        vector_dict['range-options'] = {
-            range_option[0]: range_option[2]
-            for range_option in vector[7][1:]
-        }
-        vector_dict['scale'] = {
-            scale[0]: scale[2]
-            for scale in vector[9][1:]
-        }
-        vector_dict['vector-opt'] = {
-            vector_opt[0]: vector_opt[2]
-            for vector_opt in vector[-6][1:]
-        }
-        vector_dict['color-map'] = {
-            color_map[0]: color_map[2]
-            for color_map in vector[-5][1:]
-        }
-        data[vector_dict['name']] = vector_dict
+        name = vector[0][2]
+        data[name] = {}
+        for vector_property in vector[1:]:
+            match vector_property:
+                case [property_name, '.', value]:
+                    data[name][property_name] = value
+                case ['surfaces-list', *surfaces_list]:
+                    data[name]['surfaces-list'] = surfaces_list
+                case [property_name, *values] if property_name in ('range-options', 'scale', 'vector-opt', 'color-map'):
+                    data[name][property_name] = {value[0]: value[2] for value in values}
+                case _:
+                    continue
+
     return {'vectors': data}
 
 
@@ -703,17 +755,19 @@ def _read_xy_plot(texts: CaseTexts) -> dict[str, Any]:
 
     data: dict[str, Any] = {}
     for xy_plot in xy_plots_list:
-        xy_plot_dict = {
-            property_[0]: property_[2]
-            for property_ in xy_plot
-            if property_[0] not in [
-                'options', 'x-axis-data', 'y-axis-data',
-                'surfaces-list', 'location-ids', 'locations',
-                'option', 'plot-direction', 'axes',
-            ]
-        }
-        xy_plot_dict['surfaces-list'] = xy_plot[7][1]
-        data[xy_plot_dict['name']] = xy_plot_dict
+        name = xy_plot[0][2]
+        data[name] = {}
+        for xy_plot_property in xy_plot[1:]:
+            match xy_plot_property:
+                case [property_name, '.', value]:
+                    data[name][property_name] = value
+                case ['surfaces-list', *surfaces_list]:
+                    data[name]['surfaces-list'] = surfaces_list
+                case [property_name, *values] if property_name == 'options':
+                    data[name][property_name] = {value[0]: value[2] for value in values}
+                case _:
+                    continue
+
     return {'xy-plot': data}
 
 

{cffview-0.4.2 → cffview-0.4.4/src/cffview.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cffview
-Version: 0.4.2
+Version: 0.4.4
 Summary: A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without opening Fluent
 Author-email: preamer <1524477126@qq.com>
 License-Expression: BSD-3-Clause