cffview 0.5.2__tar.gz → 0.5.3__tar.gz

{cffview-0.5.2/src/cffview.egg-info → cffview-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cffview
-Version: 0.5.2
+Version: 0.5.3
 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
@@ -65,12 +65,12 @@ cffview <file> [options]
 | Option | Description |
 |---|---|
 | `--version` | Print the Fluent version of file |
-| `--extract` | Dump raw Scheme settings to `general.scm` and `boundary.scm` |
+| `--extract` | Dump raw Scheme settings to `general.scm` / `boundary.scm` / `cortex.scm` |
 | `--plotmesh` | Visualise the mesh interactively with PyVista |
 | `--plotdata` | Visualise the data interactively with PyVista (may not work, depending on `vtkFLUENTCFFReader`) |
 | `--solver` | Solver type, time, dimension, precision, turbulence model, energy, radiation, gravity, ... |
-| `--mat`, `--materials` | Material properties |
-| `--bd`, `--boundary` | Boundary condition settings |
+| `--mat [TYPE ...]`, `--materials` | Material properties grouped by material type (`fluid` / `solid`); filters match a material type or a material name (e.g. `--mat fluid`, `--mat air`) |
+| `--bd [TYPE ...]`, `--boundary` | Boundary condition settings; filters match a boundary type (`vi` for `velocity-inlet`, whole word for single-word types) or a zone name (e.g. `--bd vi wall po`, `--bd shadow`) |
 | `--interfaces` | Mesh interfaces settings |
 | `--ne`, `--named-expressions` | Named expressions |
 | `--cff`, `--custom-field-functions` | Custom field functions |

{cffview-0.5.2 → cffview-0.5.3}/README.md

@@ -43,12 +43,12 @@ cffview <file> [options]
 | Option | Description |
 |---|---|
 | `--version` | Print the Fluent version of file |
-| `--extract` | Dump raw Scheme settings to `general.scm` and `boundary.scm` |
+| `--extract` | Dump raw Scheme settings to `general.scm` / `boundary.scm` / `cortex.scm` |
 | `--plotmesh` | Visualise the mesh interactively with PyVista |
 | `--plotdata` | Visualise the data interactively with PyVista (may not work, depending on `vtkFLUENTCFFReader`) |
 | `--solver` | Solver type, time, dimension, precision, turbulence model, energy, radiation, gravity, ... |
-| `--mat`, `--materials` | Material properties |
-| `--bd`, `--boundary` | Boundary condition settings |
+| `--mat [TYPE ...]`, `--materials` | Material properties grouped by material type (`fluid` / `solid`); filters match a material type or a material name (e.g. `--mat fluid`, `--mat air`) |
+| `--bd [TYPE ...]`, `--boundary` | Boundary condition settings; filters match a boundary type (`vi` for `velocity-inlet`, whole word for single-word types) or a zone name (e.g. `--bd vi wall po`, `--bd shadow`) |
 | `--interfaces` | Mesh interfaces settings |
 | `--ne`, `--named-expressions` | Named expressions |
 | `--cff`, `--custom-field-functions` | Custom field functions |

{cffview-0.5.2 → cffview-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cffview"
-version = "0.5.2"
+version = "0.5.3"
 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.12"
@@ -22,7 +22,7 @@ classifiers = [
 dependencies = ["h5py>=3.16.0", "pyvista>=0.48.4", "sexpdata>=1.0.2"]
 
 [project.scripts]
-cffview = "cffview.main:main"
+cffview = "cffview.cli:main"
 
 [project.urls]
 Repository = "https://github.com/preamer/cffview"
@@ -31,5 +31,5 @@ Repository = "https://github.com/preamer/cffview"
 where = ["src"]
 
 [tool.autopep8]
-max_line_length = 120
+max_line_length = 110
 ignore = "E401"

{cffview-0.5.2 → cffview-0.5.3}/src/cffview/boundary.py

@@ -150,6 +150,55 @@ class BoundaryFactory:
         boundary_cls = cls._REGISTRY.get(type_, NotImplementedBoundary)
         return boundary_cls(name, id_)
 
+    @staticmethod
+    def abbr(type_name: str) -> str:
+        """Shorthand for a boundary type name (used to filter ``--bd`` output).
+
+        Single-word types keep the whole word (``wall``); hyphenated types use
+        the initials of each part (``velocity-inlet`` -> ``vi``).
+        """
+        parts = type_name.split('-')
+        return type_name if len(parts) == 1 else ''.join(part[0] for part in parts)
+
+    @classmethod
+    def matches(cls, value: str, keywords: list[str], aliases: tuple[str, ...] = ()) -> bool:
+        """Whether ``value`` or one of its ``aliases`` matches a filter keyword.
+
+        A keyword matches when it is a case-insensitive substring of the value
+        or of any alias (an exact match is just a special case). Boundary types
+        pass their :meth:`abbr` shorthand as an alias, so ``vi`` matches
+        ``velocity-inlet`` while a zone name is matched by substring alone.
+        """
+        haystacks = (value, *aliases)
+        return any(
+            keyword.lower() in haystack.lower()
+            for keyword in keywords
+            for haystack in haystacks
+        )
+
+    @classmethod
+    def filter_boundaries(
+        cls,
+        boundaries: dict[str, list[dict]],
+        keywords: list[str],
+    ) -> dict[str, list[dict]]:
+        """Filter boundary output by type name/shorthand or by zone name.
+
+        A keyword matching the boundary type (full name or :meth:`abbr`
+        shorthand) keeps every zone of that type; otherwise only the zones
+        whose ``name`` contains the keyword are kept. Types without any match
+        are dropped.
+        """
+        filtered: dict[str, list[dict]] = {}
+        for type_name, zones in boundaries.items():
+            if cls.matches(type_name, keywords, aliases=(cls.abbr(type_name),)):
+                filtered[type_name] = zones
+                continue
+            matched = [zone for zone in zones if cls.matches(zone.get('name', ''), keywords)]
+            if matched:
+                filtered[type_name] = matched
+        return filtered
+
 
 class ToDictMixin:
     def _map_consts(self, data: dict[str, str]) -> None:
@@ -289,6 +338,10 @@ class ToDictMixin:
 
         if data.get('planar_conduction') == '#f':
             data.pop('shell_conduction', None)
+        else:
+            data.pop('d', None)
+            data.pop('q_dot', None)
+            data.pop('material', None)
 
     def _filter_methods(self) -> list[str]:
         """All ``_filter_*`` methods in class-definition order (base to subclass)."""

cffview-0.5.2/src/cffview/main.py → cffview-0.5.3/src/cffview/cli.py

@@ -11,27 +11,7 @@ the CLI together; the actual work lives in the feature modules.
 import glob
 import argparse
 
-
-def _expand_path(file_path: str) -> str:
-    """Resolve a glob pattern to the first matching file (or the path as-is).
-
-    Parameters
-    ----------
-    file_path : str
-        Path or glob pattern (e.g. ``*.cas.h5``).
-
-    Returns
-    -------
-    str
-        The first matching path when ``file_path`` is a pattern with
-        matches; otherwise ``file_path`` unchanged.
-    """
-    matches = sorted(glob.glob(file_path))
-    return matches[0] if matches else file_path
-
-
-def main() -> None:
-    BANNER = r"""
+BANNER = r"""
         ________      _
   _____/ __/ __/   __(_)__ _      __
  / ___/ /_/ /_| | / / / _ \ | /| / /
@@ -41,6 +21,8 @@ def main() -> None:
 A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without opening Fluent
 """
 
+
+def main() -> None:
     parser = argparse.ArgumentParser(
         prog='cffview',
         description=BANNER,
@@ -59,8 +41,6 @@ A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without ope
         (("--plotmesh",), "show mesh using pyvista"),
         (("--plotdata",), "plot data using pyvista"),
         (("--solver",), "show solver settings"),
-        (("--mat", "--materials"), "show materials settings"),
-        (("--bd", "--boundary"), "show boundary settings"),
         (("--interfaces",), "show mesh interfaces settings"),
         (("--mesh",), "show mesh settings"),
         (("--ne", "--named-expressions"), "show named-expressions settings"),
@@ -83,6 +63,26 @@ A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without ope
     ]
     for flags, help_text in ARGUMENTS:
         parser.add_argument(*flags, action="store_true", help=help_text)
+    parser.add_argument(
+        "--mat", "--materials",
+        nargs="*",
+        default=False,
+        metavar="TYPE",
+        help=(
+            "show materials settings, optionally filtered by material type "
+            "(e.g. --mat fluid solid; empty means no filtering)"
+        ),
+    )
+    parser.add_argument(
+        "--bd", "--boundary",
+        nargs="*",
+        default=False,
+        metavar="TYPE",
+        help=(
+            "show boundary settings, optionally filtered by boundary type "
+            "(e.g. --bd vi wall po; empty means no filtering)"
+        ),
+    )
     parser.add_argument(
         "--units",
         nargs="*",
@@ -108,8 +108,7 @@ A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without ope
 
     args = parser.parse_args()
 
-    args.file_path = _expand_path(args.file_path)
-
+    args.file_path = sorted(glob.glob(args.file_path))[0] if glob.glob(args.file_path) else args.file_path
     if not args.file_path.endswith((".cas.h5", ".msh.h5")) and args.plot is False:
         parser.error("Invalid arguments, please provide a .cas.h5 or .msh.h5 file or add --plot argument to plot file")
 
@@ -140,24 +139,45 @@ A Python CLI tool to view Ansys Fluent .cas.h5/.msh.h5/.dat.h5 files without ope
         else:
             from .utils import print_colored_dict
             from .reader import read_case, READERS
-            kwargs = {k: getattr(args, k) for k in READERS.keys()}
-            if args.units is not False:
-                kwargs['units'] = True
+            kwargs = {
+                k: getattr(args, k) if not isinstance(getattr(args, k), list) else True
+                for k in READERS.keys()
+            }
             output = read_case(args.file_path, **kwargs)
+            if isinstance(args.mat, list) and args.mat:
+                keywords = [k.lower() for k in args.mat]
+                filtered: dict = {}
+                for material_type, materials in output['materials'].items():
+                    if material_type.lower() in keywords:
+                        filtered[material_type] = materials
+                        continue
+                    matched = {
+                        name: properties
+                        for name, properties in materials.items()
+                        if any(keyword in name.lower() for keyword in keywords)
+                    }
+                    if matched:
+                        filtered[material_type] = matched
+                output['materials'] = filtered
+            if isinstance(args.bd, list) and args.bd:
+                from .boundary import BoundaryFactory
+                output['boundary'] = BoundaryFactory.filter_boundaries(output['boundary'], args.bd)
             if isinstance(args.units, list) and args.units:
-                keywords = [k.lower() for k in args.units]
-                output['units'] = {
-                    name: value
-                    for name, value in output['units'].items()
-                    if any(
-                        k in name.lower() or k in str(value[0]).lower()
-                        for k in keywords
-                    )
-                }
+                if isinstance(output['units'], dict):
+                    keywords = [k.lower() for k in args.units]
+                    output['units'] = {
+                        name: value
+                        for name, value in output['units'].items()
+                        if any(
+                            k in name.lower() or k in str(value[0]).lower()
+                            for k in keywords
+                        )
+                    }
             print_colored_dict(output)
 
             if args.save is not False:
                 import json
-                save_name = args.save if args.save else args.file_path
+                save_name = args.save or args.file_path
                 with open(f"{save_name}.json", "w", encoding="utf-8") as f:
                     json.dump(output, f, ensure_ascii=False, indent=4)
+                print(f"Saved to {save_name}.json")

{cffview-0.5.2 → cffview-0.5.3}/src/cffview/reader.py

@@ -7,15 +7,21 @@ requested readers and merges their results.
 """
 
 import re
-from collections import namedtuple
-from typing import Any, Callable, Literal
-from functools import lru_cache, singledispatch, partial
+from functools import lru_cache, singledispatch
+from typing import Any, Callable, Literal, NamedTuple
 
+import h5py
 import sexpdata
 
+
+class CaseTexts(NamedTuple):
+    general: str
+    boundary: str
+    cortex: str
+
+
 type NestedStrList = list[str | NestedStrList]
 type SubReader = Callable[[CaseTexts], dict[str, Any]]
-CaseTexts = namedtuple('CaseTexts', ['general', 'boundary', 'cortex'])
 
 # from Ansys Fluent sg.h
 DISCRETIZATION_SCHEME = {
@@ -74,10 +80,9 @@ type RadiationModel = Literal['rosseland', 'p1', 'dtrm', 's2s', 'disco']
 
 
 def stringify_nested_list(lst: list[Any]) -> NestedStrList:
-    from sexpdata import Quoted
     result = []
     for item in lst:
-        if isinstance(item, Quoted):
+        if isinstance(item, sexpdata.Quoted):
             item = item.x  # unwrap Quoted to its inner value
         result.append(stringify_nested_list(item) if isinstance(item, list) else str(item))
     return result
@@ -85,8 +90,6 @@ def stringify_nested_list(lst: list[Any]) -> NestedStrList:
 
 def _read_texts(file_path: str, *, need_boundary: bool = False) -> CaseTexts:
     """Decode the Scheme strings under ``/settings`` of a .cas.h5 file."""
-    import h5py
-
     with h5py.File(file_path) as f:
         settings: h5py.Group = f['/settings']
         general = settings['Rampant Variables'][0].decode()
@@ -219,17 +222,22 @@ def _(general: str, name: str) -> str:
 
 
 @_sel_expr.register(list)
-def _(lst: list[str], return_expr: bool = False) -> str:
+def _(lst: NestedStrList, return_expr: bool = False) -> str:
     """Get sel/expr pair in list like ['constant', '.', '1'], ['profile', '12'], ..."""
-    if len(lst) == 3 and lst[1] == '.':
-        return lst[2] if return_expr else f'{lst[0]}/{lst[2]}'
-    elif len(lst) == 2:
-        return lst[1] if return_expr else f'{lst[0]}/{lst[1]}'
-    elif len(lst) > 1:
-        rest = str(list(lst[1:])).strip('[]')
-        return rest if return_expr else f'{lst[0]}/{rest}'
-    else:
-        return lst[0]
+    match lst:
+        case [sel, '.', expr]:
+            return expr if return_expr else f'{sel}/{expr}'
+        case [sel, expr]:
+            return expr if return_expr else f'{sel}/{expr}'
+        case [p, [sel, '.', expr], *_]:
+            return expr if return_expr else f'{p}/{sel}/{expr}'
+        case [p, [sel, expr], *_]:
+            return expr if return_expr else f'{p}/{sel}/{expr}'
+        case [sel, *expr]:
+            rest = str(expr).strip('[]')
+            return rest if return_expr else f'{sel}/{rest}'
+        case _:
+            return lst[0]
 
 
 # ------------------------------------------------------------- dispatcher
@@ -289,23 +297,23 @@ def _read_materials(texts: CaseTexts) -> dict[Literal['materials'], Any]:
     materials = re.search(r'(\(materials.*)', general, re.M).group(1)
     materials_list = stringify_nested_list(sexpdata.loads(materials))
 
-    data: dict[str, Any] = {}
+    data: dict[str, dict[str, Any]] = {}
     for material in materials_list[1]:
-        name = material[0]
-        data[name] = {'type': material[1]}
+        name, material_type = material[:2]
+        properties: dict[str, Any] = {}
         for property_ in material[2:]:
             property_name = property_[0]
             match property_[1:]:
                 case ['.', value]:
-                    data[name][property_name] = value
+                    properties[property_name] = value
                 case [[sel, '.', expr], *_]:
-                    data[name][property_name] = f'{sel}/{expr}'
+                    properties[property_name] = f'{sel}/{expr}'
                 case [['polynomial', 'piecewise-linear', *values_list], *_]:
-                    data[name][property_name] = {
+                    properties[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] = {
+                    properties[property_name] = {
                         f'polynomial/{polynomial_type}': [str(v).strip('[]') for v in values_list]
                     }
                 case [['orthotropic', *orth_properties], *_]:
@@ -316,12 +324,13 @@ def _read_materials(texts: CaseTexts) -> dict[Literal['materials'], Any]:
                             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
+                    properties[property_name] = value
                 case [[sel, *values_list], *_]:
-                    data[name][property_name] = {sel: [str(v).strip('[]') for v in values_list]}
+                    properties[property_name] = {sel: [str(v).strip('[]') for v in values_list]}
                 case _:
                     value = ' '.join(str(p) for p in property_[1:])
-                    data[name][property_name] = f'{property_[0]}/{value}'
+                    properties[property_name] = f'{property_[0]}/{value}'
+        data.setdefault(material_type, {})[name] = properties
 
     return {'materials': data}
 
@@ -332,32 +341,9 @@ def _read_materials(texts: CaseTexts) -> dict[Literal['materials'], Any]:
 @register_reader('bd')
 def _read_boundary(texts: CaseTexts) -> dict[Literal['boundary'], Any]:
     from .boundary import BoundaryFactory
+    data: dict[str, Any] = {}
     boundaries = stringify_nested_list(sexpdata.parse(texts.boundary, true=None))
 
-    def format_component(comp) -> str:
-        """Format one component of a multi-value boundary property.
-
-        Handles plain values (``'2'``), single selectors (``['constant', '.', v]``,
-        ``['profile', sel, expr]``) and nested selector pairs such as
-        ``[['profile', sel, expr], ['constant', '.', v]]`` (prefers the profile,
-        falls back to the constant).
-        """
-        if isinstance(comp, str):
-            return comp
-        if isinstance(comp, list):
-            if len(comp) == 3:
-                if comp[0] == 'constant' and comp[1] == '.':
-                    return f'constant/{comp[2]}'
-                if comp[0] == 'profile' and comp[1]:
-                    return f'profile/{comp[1]}/{comp[2]}'
-            if comp and all(isinstance(item, list) for item in comp):
-                for item in comp:
-                    formatted = format_component(item)
-                    if formatted:
-                        return formatted
-        return str(comp)
-
-    data: dict[str, Any] = {}
     for boundary_info in boundaries:
         id_, type_, name, _ = [_ for _ in boundary_info[1]]
         new_boundary = BoundaryFactory.create(name, id_, type_)
@@ -375,11 +361,6 @@ def _read_boundary(texts: CaseTexts) -> dict[Literal['boundary'], Any]:
                         value = f'{sel}/{expr}'
                     case [_, ['profile', sel, expr], *_]:
                         value = f'profile/{sel}/{expr}'
-                    case [_, *components] if any(
-                        isinstance(c, list) and c and isinstance(c[0], list)
-                        for c in components
-                    ):
-                        value = ' '.join(format_component(c) for c in components)
                     case ['source-terms', *source_terms_list]:
                         value = {}
                         for source_term in (st for st in source_terms_list if len(st) == 2):
@@ -389,8 +370,12 @@ def _read_boundary(texts: CaseTexts) -> dict[Literal['boundary'], Any]:
                                 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 ['shell-conduction', *shell_conduction_list]:
+                        value = {}
+                        for i, shell in enumerate(shell_conduction_list):
+                            value[f'shell-{i}'] = [_sel_expr(p, return_expr=False) for p in shell]
                     case _:
-                        value = ''
+                        value = str(property_list[1:])
                 setattr(new_boundary, property_name, value)
 
         b_list.append(
@@ -631,7 +616,9 @@ def _read_report_definitions(texts: CaseTexts) -> dict[Literal['report-definitio
         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')
+            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)
             for i, v in zip(ids, values):
                 sorted_values[right_order_ids.index(i)] = v
@@ -666,7 +653,11 @@ def _read_residuals(texts: CaseTexts) -> dict[Literal['residuals'], Any]:
         else 'none'
     )
 
-    residuals = 'residuals/settings-transient' if _get_solver_time(general) == 'transient' else 'residuals/settings'
+    residuals = (
+        'residuals/settings-transient'
+        if _get_solver_time(general) == 'transient'
+        else 'residuals/settings'
+    )
     res = re.search(rf'(\({residuals}\s+.*)', general, re.M).group(1)
     res = sexpdata.loads(res, true=None)[1]
     if str(res) != '#f':
@@ -773,7 +764,9 @@ def _read_cell_registers(texts: CaseTexts) -> dict[Literal['cell-registers'], An
                         for kv in kvs
                     })
                 case ['display-options', *options]:
-                    data[name]['display-options'] = {option[0]: option[2] for option in options if option[1] == '.'}
+                    data[name]['display-options'] = {
+                        option[0]: option[2] for option in options if option[1] == '.'
+                    }
 
     return {'cell-registers': data}
 
@@ -787,16 +780,20 @@ def _read_iter(texts: CaseTexts) -> dict[Literal['iter'], Any]:
     data: dict[str, Any] = {}
 
     if _get_solver_time(general) == 'steady':
-        pseudo_time_method = _get_pesudo_time_method(general)
-        if pseudo_time_method != 'Off':
-            data['time-step-method'] = 'Automatic' if re.search(
-                r'\(pseudo-auto-time-step\?\s+(#[tf])\)', general
-            ).group(1) == '#t' else 'User-Specified'
+        data['pseudo-time-method'] = _get_pesudo_time_method(general)
+        if data['pseudo-time-method'] != 'Off':
+            data['time-step-method'] = (
+                'Automatic'
+                if re.search(r'\(pseudo-auto-time-step\?\s+(#[tf])\)', general).group(1) == '#t'
+                else 'User-Specified'
+            )
             if data['time-step-method'] == 'User-Specified':
                 data['pseudo-time-step'] = _sel_expr(general, 'pseudo-time-step')
             else:
                 data['time-scale-factor'] = _sel_expr(general, 'pseudo-auto-time-step-scale-factor')
-                length_scale_method = re.search(r'\(pseudo/autotime-lscale-option\s+(\d+)\)', general).group(1)
+                length_scale_method = re.search(
+                    r'\(pseudo/autotime-lscale-option\s+(\d+)\)', general
+                ).group(1)
                 data['length-scale-method'] = (
                     'Aggressive' if length_scale_method == '0' else
                     'Conservative' if length_scale_method == '1' else
@@ -811,7 +808,9 @@ def _read_iter(texts: CaseTexts) -> dict[Literal['iter'], Any]:
         data['iterations'] = re.search(r'\(number-of-iterations\s+(\d+)\)', general).group(1)
         data['reporting-interval'] = re.search(r'\(iteration-chunk\s+(\d+)\)', general).group(1)
         data['update-interval'] = re.search(r'\(profile/update-interval\s+(\d+)\)', general).group(1)
-        data['save-steady-statistics'] = re.search(r'\(save-steady-statistics\?\s+(#[tf])\)', general).group(1)
+        data['save-steady-statistics'] = re.search(
+            r'\(save-steady-statistics\?\s+(#[tf])\)', general
+        ).group(1)
     else:
         data['physical-time-step'] = _sel_expr(general, 'physical-time-step')
         for key in ('time-step', 'max-iterations-per-step', 'flow-time', 'time/total-timesteps'):
@@ -954,7 +953,7 @@ def _read_graphics(texts: CaseTexts, graphics_type: str) -> dict[str, Any]:
 
 
 for g_type in ('mesh', 'contours', 'vectors', 'pathlines', 'xy_plot', 'scene'):
-    register_reader(g_type)(partial(_read_graphics, graphics_type=g_type))
+    register_reader(g_type)(lambda t, g_type=g_type: _read_graphics(t, g_type))
 
 
 # -------------------------------------------------------- input/output parameters
@@ -1005,7 +1004,7 @@ def read_case(file_path: str, **flags: bool) -> dict[str, Any]:
     dict[str, Any]
         A dictionary containing the case settings.
     """
-    if not any(flags.values()):  # no section requested -> read everything
+    if not any(flags.values()):  # all flags are False, read all sections
         flags = dict.fromkeys(READERS, True)
 
     texts = _read_texts(

{cffview-0.5.2 → cffview-0.5.3}/src/cffview/utils.py

@@ -119,7 +119,7 @@ DATA_KEYS = (
 )
 
 
-def print_colored_dict(data) -> None:
+def print_colored_dict(data: dict) -> None:
     """Print nested data in 4-space JSON format.
 
     Keys (including colon) : cycle through 6 hued colours per nesting level.

{cffview-0.5.2 → cffview-0.5.3/src/cffview.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cffview
-Version: 0.5.2
+Version: 0.5.3
 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
@@ -65,12 +65,12 @@ cffview <file> [options]
 | Option | Description |
 |---|---|
 | `--version` | Print the Fluent version of file |
-| `--extract` | Dump raw Scheme settings to `general.scm` and `boundary.scm` |
+| `--extract` | Dump raw Scheme settings to `general.scm` / `boundary.scm` / `cortex.scm` |
 | `--plotmesh` | Visualise the mesh interactively with PyVista |
 | `--plotdata` | Visualise the data interactively with PyVista (may not work, depending on `vtkFLUENTCFFReader`) |
 | `--solver` | Solver type, time, dimension, precision, turbulence model, energy, radiation, gravity, ... |
-| `--mat`, `--materials` | Material properties |
-| `--bd`, `--boundary` | Boundary condition settings |
+| `--mat [TYPE ...]`, `--materials` | Material properties grouped by material type (`fluid` / `solid`); filters match a material type or a material name (e.g. `--mat fluid`, `--mat air`) |
+| `--bd [TYPE ...]`, `--boundary` | Boundary condition settings; filters match a boundary type (`vi` for `velocity-inlet`, whole word for single-word types) or a zone name (e.g. `--bd vi wall po`, `--bd shadow`) |
 | `--interfaces` | Mesh interfaces settings |
 | `--ne`, `--named-expressions` | Named expressions |
 | `--cff`, `--custom-field-functions` | Custom field functions |

{cffview-0.5.2 → cffview-0.5.3}/src/cffview.egg-info/SOURCES.txt

@@ -2,8 +2,8 @@ LICENSE
 README.md
 pyproject.toml
 src/cffview/boundary.py
+src/cffview/cli.py
 src/cffview/extract.py
-src/cffview/main.py
 src/cffview/plot.py
 src/cffview/plotter.py
 src/cffview/reader.py

cffview-0.5.3/src/cffview.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cffview = cffview.cli:main

cffview-0.5.2/src/cffview.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-cffview = cffview.main:main