ansys-fluent-core 0.27.dev1__py3-none-any.whl → 0.28.dev0__py3-none-any.whl

ansys/fluent/tests/conftest.py

@@ -1,20 +1,21 @@
 from contextlib import nullcontext
 import functools
+import inspect
 import operator
 import os
+from pathlib import Path
+import shutil
+import sys
 
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version
 import pytest
 
 import ansys.fluent.core as pyfluent
-from ansys.fluent.core import codegen
 from ansys.fluent.core.examples.downloads import download_file
 from ansys.fluent.core.utils.file_transfer_service import RemoteFileTransferStrategy
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
-_fluent_release_version = FluentVersion.current_release().value
-
 
 def pytest_addoption(parser):
     parser.addoption(
@@ -29,6 +30,12 @@ def pytest_addoption(parser):
     parser.addoption(
         "--solvermode", action="store_true", default=False, help="run solvermode tests"
     )
+    parser.addoption(
+        "--write-fluent-journals",
+        action="store_true",
+        default=False,
+        help="Write Fluent journals for unittests",
+    )
 
 
 def pytest_runtest_setup(item):
@@ -48,6 +55,7 @@ def pytest_runtest_setup(item):
         pytest.skip()
 
     version_specs = []
+    fluent_release_version = FluentVersion.current_release().value
     for mark in item.iter_markers(name="fluent_version"):
         spec = mark.args[0]
         # if a test is marked as fluent_version("latest")
@@ -55,9 +63,9 @@ def pytest_runtest_setup(item):
         # run with release Fluent versions in PRs
         if spec == "latest":
             spec = (
-                f">={_fluent_release_version}"
+                f">={fluent_release_version}"
                 if is_nightly or is_solvermode_option
-                else f"=={_fluent_release_version}"
+                else f"=={fluent_release_version}"
             )
         version_specs.append(SpecifierSet(spec))
     if version_specs:
@@ -67,14 +75,83 @@ def pytest_runtest_setup(item):
             pytest.skip()
 
 
+def pytest_collection_finish(session):
+    if session.config.getoption("--write-fluent-journals"):
+        import_path = Path(__file__).parent
+        sys.path.append(str(import_path))
+        import fluent_fixtures
+
+        launcher_args_by_fixture = {}
+        for k, v in fluent_fixtures.__dict__.items():
+            if hasattr(v, "fluent_launcher_args"):
+                launcher_args_by_fixture[k] = v.fluent_launcher_args
+        fluent_test_root = import_path / "fluent"
+        shutil.rmtree(fluent_test_root, ignore_errors=True)
+        for item in session.items:
+            skip = False
+            for mark in item.iter_markers(name="skip"):
+                skip = True
+            for mark in item.iter_markers(name="fluent_version"):
+                spec = mark.args[0]
+                # TODO: Support older versions
+                if not (
+                    spec == "latest"
+                    or Version(FluentVersion.current_dev().value) in SpecifierSet(spec)
+                ):
+                    skip = True
+            if skip:
+                continue
+            fluent_test_dir = fluent_test_root / item.module.__name__ / item.name
+            fluent_test_config = fluent_test_dir / "test.yaml"
+            fluent_test_file = fluent_test_dir / "test.py"
+            launcher_args = ""
+            parameters = inspect.signature(item.function).parameters
+            parameter_set = {p for p in parameters}
+            if not (parameter_set & set(launcher_args_by_fixture.keys())):
+                # Skipping as unittest doesn't use fluent fixture
+                continue
+            for param in parameters:
+                if param not in dir(fluent_fixtures):
+                    print(f"Skipping {item.nodeid} because of missing fixture {param}")
+                    skip = True
+                    break
+            if skip:
+                continue
+            for param in parameters:
+                if param in launcher_args_by_fixture:
+                    launcher_args = launcher_args_by_fixture[param]
+                    break
+            fluent_test_dir.mkdir(parents=True, exist_ok=True)
+            with open(fluent_test_config, "w") as f:
+                f.write(f"launcher_args: {launcher_args}\n")
+            with open(fluent_test_file, "w") as f:
+                f.write("import sys\n")
+                f.write('sys.path.append("/testing")\n')
+                f.write(
+                    f"from {item.module.__name__} import {item.name}  # noqa: E402\n"
+                )
+                f.write("from fluent_fixtures import (  # noqa: E402\n")
+                for param in parameters:
+                    f.write(f"    {param},\n")
+                f.write(")\n")
+                f.write("\n")
+                f.write(f"{item.name}(")
+                f.write(", ".join([f"{p}(globals())" for p in parameters]))
+                f.write(")\n")
+                f.write("exit()\n")
+            print(f"Written {fluent_test_file}")
+        session.items = []
+        session.testscollected = 0
+
+
 @pytest.fixture(autouse=True)
 def run_before_each_test(
     monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest
 ) -> None:
     monkeypatch.setenv("PYFLUENT_TEST_NAME", request.node.name)
+    monkeypatch.setenv("PYFLUENT_CODEGEN_SKIP_BUILTIN_SETTINGS", "1")
     pyfluent.CONTAINER_MOUNT_SOURCE = pyfluent.EXAMPLES_PATH
     pyfluent.CONTAINER_MOUNT_TARGET = pyfluent.EXAMPLES_PATH
-    codegen.CODEGEN_GENERATE_BUILTIN_SETTINGS = False
 
 
 class Helpers:
@@ -145,8 +222,8 @@ def exhaust_system_geometry_filename():
 
 def create_session(**kwargs):
     if pyfluent.USE_FILE_TRANSFER_SERVICE:
-        container_dict = {"mount_source": file_transfer_service.MOUNT_SOURCE}
         file_transfer_service = RemoteFileTransferStrategy()
+        container_dict = {"mount_source": file_transfer_service.MOUNT_SOURCE}
         return pyfluent.launch_fluent(
             container_dict=container_dict,
             file_transfer_service=file_transfer_service,
@@ -301,3 +378,8 @@ def periodic_rot_settings_session(new_solver_session):
         lightweight_setup=True,
     )
     return solver
+
+
+@pytest.fixture
+def disable_datamodel_cache(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr(pyfluent, "DATAMODEL_USE_STATE_CACHE", False)

ansys/fluent/tests/fluent/test_version/test.py

@@ -0,0 +1,2 @@
+assert ansys.fluent.core.__version__ == "0.28.dev0"  # noqa: F821
+exit()

ansys/fluent/tests/fluent_fixtures.py

@@ -0,0 +1,195 @@
+from typing import Callable
+
+import pytest
+
+import ansys.fluent.core as pyfluent
+from ansys.fluent.core.data_model_cache import DataModelCache
+from ansys.fluent.core.examples import download_file
+
+
+def fluent_launcher_args(args: str):
+    def fluent_launcher_args_inner(f: Callable):
+        def wrapper(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        wrapper.fluent_launcher_args = args
+        return wrapper
+
+    return fluent_launcher_args_inner
+
+
+def mixing_elbow_geometry_filename(globals):
+    return download_file(
+        file_name="mixing_elbow.pmdb", directory="pyfluent/mixing_elbow"
+    )
+
+
+def exhaust_system_geometry_filename(globals):
+    return download_file(
+        file_name="exhaust_system.fmd", directory="pyfluent/exhaust_system"
+    )
+
+
+@fluent_launcher_args("3ddp -meshing")
+def new_meshing_session(globals):
+    meshing = globals["meshing"]
+    return meshing
+
+
+@fluent_launcher_args("3ddp -meshing")
+def new_pure_meshing_session(globals):
+    return new_meshing_session(globals)
+
+
+@fluent_launcher_args("3ddp -meshing")
+def watertight_workflow_session(globals):
+    meshing = new_meshing_session(globals)
+    meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
+    return meshing
+
+
+@fluent_launcher_args("3ddp -meshing")
+def fault_tolerant_workflow_session(globals):
+    meshing = new_meshing_session(globals)
+    meshing.workflow.InitializeWorkflow(WorkflowType="Fault-tolerant Meshing")
+    return meshing
+
+
+@fluent_launcher_args("3ddp -meshing")
+def mixing_elbow_watertight_pure_meshing_session(globals):
+    meshing = new_pure_meshing_session(globals)
+    geometry_filename = mixing_elbow_geometry_filename(globals)
+    meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
+    meshing.workflow.TaskObject["Import Geometry"].Arguments = dict(
+        FileName=geometry_filename, LengthUnit="in"
+    )
+    return meshing
+
+
+@fluent_launcher_args("3ddp")
+def new_solver_session(globals):
+    solver = globals["solver"]
+    return solver
+
+
+@fluent_launcher_args("3d")
+def new_solver_session_sp(globals):
+    return new_solver_session(globals)
+
+
+@fluent_launcher_args("2ddp")
+def new_solver_session_2d(globals):
+    return new_solver_session(globals)
+
+
+@fluent_launcher_args("3ddp")
+def static_mixer_settings_session(globals):
+    solver = new_solver_session(globals)
+    case_name = download_file("Static_Mixer_main.cas.h5", "pyfluent/static_mixer")
+    solver.file.read(
+        file_type="case",
+        file_name=case_name,
+        lightweight_setup=True,
+    )
+    return solver
+
+
+@fluent_launcher_args("3ddp")
+def static_mixer_case_session(globals):
+    solver = new_solver_session(globals)
+    case_name = download_file("Static_Mixer_main.cas.h5", "pyfluent/static_mixer")
+    solver.file.read(file_type="case", file_name=case_name)
+    return solver
+
+
+@fluent_launcher_args("3ddp")
+def mixing_elbow_settings_session(globals):
+    solver = new_solver_session(globals)
+    case_name = download_file("mixing_elbow.cas.h5", "pyfluent/mixing_elbow")
+    solver.settings.file.read(
+        file_type="case",
+        file_name=case_name,
+        lightweight_setup=True,
+    )
+    return solver
+
+
+@fluent_launcher_args("3ddp")
+def mixing_elbow_case_data_session(globals):
+    solver = new_solver_session(globals)
+    case_name = download_file("mixing_elbow.cas.h5", "pyfluent/mixing_elbow")
+    download_file("mixing_elbow.dat.h5", "pyfluent/mixing_elbow")
+    solver.settings.file.read(file_type="case-data", file_name=case_name)
+    return solver
+
+
+@fluent_launcher_args("3ddp")
+def mixing_elbow_param_case_data_session(globals):
+    solver = new_solver_session(globals)
+    case_name = download_file("elbow_param.cas.h5", "pyfluent/mixing_elbow")
+    download_file("elbow_param.dat.h5", "pyfluent/mixing_elbow")
+    solver.settings.file.read(file_type="case-data", file_name=case_name)
+    return solver
+
+
+@fluent_launcher_args("2ddp")
+def disk_settings_session(globals):
+    solver = new_solver_session_2d(globals)
+    case_name = download_file("disk.cas.h5", "pyfluent/rotating_disk")
+    solver.file.read(
+        file_type="case",
+        file_name=case_name,
+        lightweight_setup=True,
+    )
+    return solver
+
+
+@fluent_launcher_args("2ddp")
+def disk_case_session(globals):
+    solver = new_solver_session_2d(globals)
+    case_name = download_file("disk.cas.h5", "pyfluent/rotating_disk")
+    solver.file.read(file_type="case", file_name=case_name)
+    return solver
+
+
+@fluent_launcher_args("3ddp")
+def periodic_rot_settings_session(globals):
+    solver = new_solver_session(globals)
+    case_name = download_file(
+        "periodic_rot.cas.h5",
+        "pyfluent/periodic_rot",
+    )
+    solver.file.read(
+        file_type="case",
+        file_name=case_name,
+        lightweight_setup=True,
+    )
+    return solver
+
+
+monkeypatch = pytest.MonkeyPatch()
+
+
+def disable_datamodel_cache(globals):
+    monkeypatch.setattr(pyfluent, "DATAMODEL_USE_STATE_CACHE", False)
+
+
+def display_names_as_keys_in_cache(globals):
+    DataModelCache.use_display_name = True
+
+
+def new_meshing_session2(globals):
+    session = pyfluent.launch_fluent(mode=pyfluent.LaunchMode.MESHING)
+    return session
+
+
+def new_solver_session2(globals):
+    session = pyfluent.launch_fluent()
+    return session
+
+
+def static_mixer_case_session2(globals):
+    session = new_solver_session2(globals)
+    case_name = download_file("Static_Mixer_main.cas.h5", "pyfluent/static_mixer")
+    session.file.read(file_type="case", file_name=case_name)
+    return session

ansys/fluent/tests/integration/test_optislang/test_optislang_integration.py

@@ -84,7 +84,7 @@ def test_simple_solve(mixing_elbow_param_case_data_session):
     else:
         print("Solution is converged")
 
-    assert convergence == True, "Solution failed to converge"
+    assert convergence, "Solution failed to converge"
 
     # Step 5: Read the data again from the case and data file
     solver_session.settings.file.read_case_data(file_name=case_path)
@@ -148,8 +148,8 @@ def test_generate_read_mesh(mixing_elbow_geometry_filename):
     h5_path = str(Path(temporary_resource_path) / "default_mesh.msh.h5")
     meshing.tui.file.write_mesh(gz_path)
     meshing.tui.file.write_mesh(h5_path)
-    assert (Path(temporary_resource_path) / "default_mesh.msh.gz").exists() == True
-    assert (Path(temporary_resource_path) / "default_mesh.msh.h5").exists() == True
+    assert (Path(temporary_resource_path) / "default_mesh.msh.gz").exists()
+    assert (Path(temporary_resource_path) / "default_mesh.msh.h5").exists()
 
     # Step 3: use created mesh file - .msh.gz/.msh.h5
     meshing.tui.file.read_mesh(gz_path, "ok")
@@ -163,8 +163,8 @@ def test_generate_read_mesh(mixing_elbow_geometry_filename):
     write_case = solver.settings.file.write_case
     write_case(file_name=gz_path)
     write_case(file_name=h5_path)
-    assert (Path(temporary_resource_path) / "default_case.cas.gz").exists() == True
-    assert (Path(temporary_resource_path) / "default_case.cas.h5").exists() == True
+    assert (Path(temporary_resource_path) / "default_case.cas.gz").exists()
+    assert (Path(temporary_resource_path) / "default_case.cas.h5").exists()
     solver.exit()
     shutil.rmtree(temporary_resource_path, ignore_errors=True)
 
@@ -254,9 +254,9 @@ def test_parametric_project(mixing_elbow_param_case_data_session, new_solver_ses
     assert base_outputs == {"outlet_temp-op": pytest_approx(322.336008)}
     if session2.get_fluent_version() < FluentVersion.v251:
         pstudy.design_points.create_1()
+        dp = pstudy.design_points["DP1"]
     else:
-        pstudy.design_points.create()
-    dp = pstudy.design_points["DP1"]
+        dp = pstudy.design_points.create()
     dp.input_parameters["inlet2_temp"] = 600.0
     pstudy.design_points.update_selected(design_points=["DP1"])
     fluent_output_table = dp.output_parameters()

ansys/fluent/tests/parametric/test_parametric_workflow.py

@@ -105,10 +105,10 @@ def test_parametric_workflow():
     dp_names = set([*study1.design_points.keys()])
     if solver_session.get_fluent_version() < FluentVersion.v251:
         study1.design_points.create_1()
+        dp1_name = set([*study1.design_points.keys()]).difference(dp_names).pop()
+        dp1 = study1.design_points[dp1_name]
     else:
-        study1.design_points.create()
-    dp1_name = set([*study1.design_points.keys()]).difference(dp_names).pop()
-    dp1 = study1.design_points[dp1_name]
+        dp1 = study1.design_points.create()
     dp1.input_parameters["inlet1_temp"] = 500
     dp1.input_parameters["inlet1_vel"] = 1
     dp1.input_parameters["inlet2_vel"] = 1
@@ -145,7 +145,7 @@ def test_parametric_workflow():
     solver_session.parametric_studies.export_design_table(filepath=write_design_table)
     assert design_point_table.exists()
 
-    study1.design_points.delete_design_points(design_points=[dp1_name])
+    study1.design_points.delete_design_points(design_points=[dp1.obj_name])
     assert len(study1.design_points) == 2
     study_names = set([*solver_session.parametric_studies.keys()])
     solver_session.parametric_studies.duplicate()
@@ -255,6 +255,15 @@ def test_parameters_list_function(static_mixer_settings_session):
     create_output_param("report-definition", "outlet-temp-avg")
     create_output_param("report-definition", "outlet-vel-avg")
 
+    # Create a unitless output parameter
+    unitless_quantity = solver.settings.solution.report_definitions.surface.create(
+        "temp-outlet-uniformity"
+    )
+    unitless_quantity.report_type = "surface-masswtui"
+    unitless_quantity.field = "temperature"
+    unitless_quantity.surface_names = ["outlet"]
+    unitless_quantity.output_parameter = True
+
     input_parameters_list = solver.parameters.input_parameters.list()
     output_parameters_list = solver.parameters.output_parameters.list()
     assert input_parameters_list == {
@@ -266,4 +275,5 @@ def test_parameters_list_function(static_mixer_settings_session):
     assert output_parameters_list == {
         "outlet-temp-avg-op": [0.0, "K"],
         "outlet-vel-avg-op": [0.0, "m/s"],
+        "temp-outlet-uniformity-op": [0.0, ""],
     }

ansys/fluent/tests/test_builtin_settings.py

@@ -1,3 +1,6 @@
+from pathlib import Path
+import tempfile
+
 import pytest
 
 try:
@@ -19,6 +22,8 @@ try:
         CumulativePlots,
         CustomFieldFunctions,
         CustomVectors,
+        DesignPoint,
+        DesignPoints,
         DiscretePhase,
         DiscretePhaseHistogram,
         DynamicMesh,
@@ -56,6 +61,8 @@ try:
         NamedExpressions,
         Optics,
         OutputParameters,
+        ParametricStudies,
+        ParametricStudy,
         ParticleTracks,
         PartitionSurfaces,
         Pathlines,
@@ -112,6 +119,7 @@ try:
     )
 except ImportError:
     pass  # for no-codegen testing workflow
+import ansys.fluent.core as pyfluent
 from ansys.fluent.core.examples import download_file
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
@@ -630,6 +638,26 @@ def test_builtin_settings(mixing_elbow_case_data_session):
     else:
         with pytest.raises(RuntimeError):
             CustomVectors(settings_source=solver)
+    tmp_save_path = tempfile.mkdtemp(dir=pyfluent.EXAMPLES_PATH)
+    project_file = Path(tmp_save_path) / "mixing_elbow_param.flprj"
+    solver.settings.parametric_studies.initialize(project_filename=str(project_file))
+    assert ParametricStudies(settings_source=solver) == solver.parametric_studies
+    assert (
+        ParametricStudy(settings_source=solver, name="mixing_elbow-Solve")
+        == solver.parametric_studies["mixing_elbow-Solve"]
+    )
+    assert (
+        DesignPoints(settings_source=solver, parametric_studies="mixing_elbow-Solve")
+        == solver.parametric_studies["mixing_elbow-Solve"].design_points
+    )
+    assert (
+        DesignPoint(
+            settings_source=solver,
+            parametric_studies="mixing_elbow-Solve",
+            name="Base DP",
+        )
+        == solver.parametric_studies["mixing_elbow-Solve"].design_points["Base DP"]
+    )
 
 
 @pytest.mark.codegen_required

ansys/fluent/tests/test_cad_to_post_ftm.py

@@ -32,9 +32,7 @@ def test_exhaust_system(
     meshing_session = fault_tolerant_workflow_session
     workflow = meshing_session.workflow
 
-    assign_task_args = partial(
-        assign_task_arguments, workflow=workflow, check_state=True
-    )
+    _ = partial(assign_task_arguments, workflow=workflow, check_state=True)
 
     execute_task_with_pre_and_postconditions = partial(
         execute_task_with_pre_and_postcondition_checks, workflow=workflow

ansys/fluent/tests/test_cad_to_post_wtm.py

@@ -17,7 +17,7 @@ This test queries the following using PyTest:
 from functools import partial
 
 import pytest
-from util.meshing_workflow import (  # noqa: F401
+from util.meshing_workflow import (
     assign_task_arguments,
     execute_task_with_pre_and_postcondition_checks,
 )

ansys/fluent/tests/test_casereader.py

@@ -286,7 +286,7 @@ def test_lispy_for_multiline_string():
 
 
 def test_lispy_for_quotes():
-    lispy.parse(
+    assert lispy.parse(
         '(define x "\n(format \\"\n-------------------------\nRunning Original Settings\n------------------------\n\\")")'
     ) == [
         "define",

ansys/fluent/tests/test_codegen.py

@@ -1,3 +1,4 @@
+import ast
 import importlib
 from pathlib import Path
 import pickle
@@ -330,8 +331,8 @@ def test_codegen_with_datamodel_static_info(monkeypatch, rules):
         f"datamodel_{version}",
     }
     datamodel_paths = list((codegen_outdir / f"datamodel_{version}").iterdir())
-    assert len(datamodel_paths) == 1
-    assert set(p.name for p in datamodel_paths) == {f"{rules}.py"}
+    assert len(datamodel_paths) == 1 or 2
+    assert set(p.name for p in datamodel_paths) == {f"{rules}.py"} or {f"{rules}.pyi"}
     with open(codegen_outdir / f"datamodel_{version}" / f"{rules}.py", "r") as f:
         assert f.read().strip() == _expected_datamodel_api_output
     api_tree_file = get_api_tree_file_name(version)
@@ -812,8 +813,8 @@ def test_codegen_old_with_settings_static_info(monkeypatch):
         "Q1": "Query",
     }
     api_tree_expected = {}
-    api_tree_expected[f"<meshing_session>"] = {}
-    api_tree_expected[f"<solver_session>"] = settings_tree
+    api_tree_expected["<meshing_session>"] = {}
+    api_tree_expected["<solver_session>"] = settings_tree
     assert api_tree == api_tree_expected
     shutil.rmtree(str(codegen_outdir))
 
@@ -1077,7 +1078,116 @@ def test_codegen_with_settings_static_info(monkeypatch):
         "Q1": "Query",
     }
     api_tree_expected = {}
-    api_tree_expected[f"<meshing_session>"] = {}
-    api_tree_expected[f"<solver_session>"] = settings_tree
+    api_tree_expected["<meshing_session>"] = {}
+    api_tree_expected["<solver_session>"] = settings_tree
     assert api_tree == api_tree_expected
     shutil.rmtree(str(codegen_outdir))
+
+
+_settings_static_info_duplicate_parameters = {
+    "children": (
+        _get_group_settings_static_info(
+            "G1",
+            (
+                (
+                    _get_group_settings_static_info(
+                        "G2",
+                        _get_parameter_settings_static_info("P1", "string"),
+                        {},
+                        {},
+                    )
+                )
+                | _get_parameter_settings_static_info("P1", "string")
+            ),
+            {},
+            {},
+        )
+    ),
+    "commands": {},
+    "queries": {},
+    "type": "group",
+}
+
+_settings_static_info_different_parameters_with_same_name = {
+    "children": (
+        _get_group_settings_static_info(
+            "G1",
+            (
+                (
+                    _get_group_settings_static_info(
+                        "G2",
+                        _get_parameter_settings_static_info("P1", "real"),
+                        {},
+                        {},
+                    )
+                )
+                | _get_parameter_settings_static_info("P1", "string")
+            ),
+            {},
+            {},
+        )
+    ),
+    "commands": {},
+    "queries": {},
+    "type": "group",
+}
+
+
+_settings_static_info_combined_case = {
+    "children": (
+        _get_group_settings_static_info(
+            "G1",
+            (
+                (
+                    _get_group_settings_static_info(
+                        "G2",
+                        (
+                            _get_parameter_settings_static_info("P1", "real")
+                            | _get_parameter_settings_static_info("P2", "string")
+                        ),
+                        {},
+                        {},
+                    )
+                )
+                | _get_parameter_settings_static_info("P1", "string")
+                | _get_parameter_settings_static_info("P2", "string")
+            ),
+            {},
+            {},
+        )
+    ),
+    "commands": {},
+    "queries": {},
+    "type": "group",
+}
+
+
+@pytest.mark.parametrize(
+    "settings_static_info,class_names",
+    [
+        (_settings_static_info_duplicate_parameters, ["P1", "G2", "G1", "root"]),
+        (
+            _settings_static_info_different_parameters_with_same_name,
+            ["P1_1", "G2", "P1", "G1", "root"],
+        ),
+        (_settings_static_info_combined_case, ["P1_1", "P2", "G2", "P1", "G1", "root"]),
+    ],
+)
+def test_codegen_with_settings_static_info_edge_cases(
+    monkeypatch, settings_static_info, class_names
+):
+
+    codegen_outdir = Path(tempfile.mkdtemp())
+    monkeypatch.setattr(pyfluent, "CODEGEN_OUTDIR", codegen_outdir)
+    version = "251"
+    static_infos = {}
+    static_infos[StaticInfoType.SETTINGS] = settings_static_info
+    allapigen.generate(version, static_infos)
+    with open(codegen_outdir / "solver" / f"settings_{version}.py", "r") as f:
+        module_def = ast.parse(f.read())
+        class_names_from_file = [
+            x.name for x in module_def.body if isinstance(x, ast.ClassDef)
+        ]
+        # The order of classes is important.
+        assert class_names_from_file == class_names
+    shutil.rmtree(str(codegen_outdir))

ansys/fluent/tests/test_data_model_cache.py

@@ -429,6 +429,6 @@ def test_cache_per_session():
     ):
         assert m1.meshing.GlobalSettings.EnableComplexMeshing()
         assert m2.meshing.GlobalSettings.EnableComplexMeshing()
-        w1 = m1.watertight()
+        _ = m1.watertight()
         assert not m1.meshing.GlobalSettings.EnableComplexMeshing()
         assert m2.meshing.GlobalSettings.EnableComplexMeshing()