ansys-fluent-core 0.20.dev8__py3-none-any.whl → 0.20.dev9__py3-none-any.whl

ansys/fluent/core/streaming_services/datamodel_event_streaming.py

@@ -1,3 +1,5 @@
+"""Provides a module for datamodel event streaming."""
+
 import logging
 import os
 import threading

ansys/fluent/core/streaming_services/datamodel_streaming.py

@@ -1,3 +1,5 @@
+"""Provides a module for datamodel streaming."""
+
 from ansys.api.fluent.v0 import datamodel_se_pb2
 from ansys.fluent.core.streaming_services.streaming import StreamingService
 

ansys/fluent/core/streaming_services/events_streaming.py

@@ -85,9 +85,12 @@ class EventsManager(StreamingService):
         ----------
         event_name : str
             Event name to register the callback to.
-
         callback : Callable
             Callback to register.
+        args : Any
+            Arguments.
+        kwargs : Any
+            Keyword arguments.
 
         Returns
         -------

ansys/fluent/core/streaming_services/monitor_streaming.py

@@ -75,6 +75,10 @@ class MonitorsManager(StreamingService):
         ----------
         monitor_set_name : str
             Name of the monitor.
+        args : Any
+            Arguments.
+        kwargs : Any
+            Keyword arguments.
 
         Returns
         -------

ansys/fluent/core/streaming_services/streaming.py

@@ -1,3 +1,5 @@
+"""Provides a module for streaming services."""
+
 import itertools
 import logging
 import threading
@@ -36,6 +38,10 @@ class StreamingService:
         ----------
         callback : Callable
             Callback to register.
+        args : Any
+            Arguments.
+        kwargs : Any
+            Keyword arguments.
 
         Returns
         -------

ansys/fluent/core/streaming_services/transcript_streaming.py

@@ -1,3 +1,5 @@
+"""Provides a module for transcript streaming."""
+
 import os
 from pathlib import Path
 from typing import Optional

ansys/fluent/core/systemcoupling.py

@@ -10,6 +10,8 @@ from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 @dataclass
 class Variable:
+    """Provides variable data."""
+
     name: str
     display_name: str
     tensor_type: str
@@ -20,6 +22,8 @@ class Variable:
 
 @dataclass
 class Region:
+    """Provides region data."""
+
     name: str
     display_name: str
     topology: str
@@ -51,23 +55,29 @@ class SystemCoupling:
 
     @property
     def participant_type(self) -> str:
+        """Get participant type."""
         return "FLUENT"
 
     def get_variables(self) -> List[Variable]:
+        """Get variables."""
         return self.__get_syc_setup()["variables"]
 
     def get_regions(self) -> List[Region]:
+        """Get regions."""
         return self.__get_syc_setup()["regions"]
 
     def get_analysis_type(self) -> str:
+        """Get analysis type."""
         return self.__get_syc_setup()["analysis-type"]
 
     def connect(self, host: str, port: int, name: str) -> None:
+        """Connect parallelly."""
         self._solver.setup.models.system_coupling.connect_parallel(
             schost=host, scport=port, scname=name
         )
 
     def solve(self) -> None:
+        """Initialize and solve."""
         self._solver.setup.models.system_coupling.init_and_solve()
 
     def __get_syc_setup(self) -> dict:

ansys/fluent/core/utils/dump_session_data.py

@@ -100,6 +100,8 @@ def dump_session_data(
 
 
 class DumpDataReader:
+    """Reads dump data."""
+
     def __init__(self, file_name: str):
         with open(
             str(Path(file_name).resolve()),
@@ -108,9 +110,11 @@ class DumpDataReader:
             self._session_data = pickle.load(pickle_obj)
 
     def get_session_data(self):
+        """Get session data."""
         return self._session_data
 
     def get_surface_data(self, surface_ids, data_types) -> list[Union[np.array, None]]:
+        """Get surface data."""
         tag_id = (("type", "surface-data"),)
 
         enum_to_field_name = {
@@ -133,6 +137,7 @@ class DumpDataReader:
     def get_scalar_field_data(
         self, surface_ids, data_location, provide_boundary_values, field_names
     ) -> list[Union[np.array, None]]:
+        """Get scalar field data."""
         tag_id = (
             ("type", "scalar-field"),
             ("dataLocation", data_location),
@@ -150,6 +155,7 @@ class DumpDataReader:
     def get_vector_field_data(
         self, surface_ids, field_names
     ) -> list[Union[np.array, None]]:
+        """Get vector field data."""
         tag_id = (("type", "vector-field"),)
 
         vector_field_data = [
@@ -166,6 +172,7 @@ class DumpDataReader:
     def get_pathlines_data(
         self, surface_ids, field_names, key
     ) -> list[Union[np.array, None]]:
+        """Get pathlines data."""
         pathlines_data = []
         for surface_id in surface_ids:
             for field_name in field_names:

ansys/fluent/core/utils/file_transfer_service.py

@@ -1,3 +1,5 @@
+"""Provides a module for file transfer service."""
+
 import os
 from typing import Any, Callable, Optional, Union  # noqa: F401
 
@@ -66,6 +68,7 @@ class PimFileTransferService:
         return self.file_service
 
     def is_configured(self):
+        """Check pypim configuration."""
         return pypim.is_configured()
 
     def upload_file(self, file_name: str, remote_file_name: Optional[str] = None):

ansys/fluent/core/utils/fix_doc.py

@@ -1,7 +1,10 @@
+"""Provides a module to fix text documentation for a data object."""
+
 from io import StringIO
 
 
 def escape_wildcards(doc: str):
+    """Escape wildcards."""
     new_doc = StringIO()
     prev_c = None
     for i, c in enumerate(doc):
@@ -17,6 +20,7 @@ def escape_wildcards(doc: str):
 
 
 def fix_definition_list_in_class_doc(doc: str):
+    """Fix definition list in class docstring."""
     old_lines = doc.splitlines(keepends=True)
     new_lines = []
     for i, line in enumerate(old_lines):
@@ -41,5 +45,6 @@ def fix_definition_list_in_class_doc(doc: str):
 
 
 def fix_settings_doc(doc: str):
+    """Fix settings docstring."""
     doc = escape_wildcards(doc)
     return fix_definition_list_in_class_doc(doc)

ansys/fluent/core/utils/fldoc.py

@@ -1,3 +1,5 @@
+"""Provides a module to produce text documentation for a data object."""
+
 import pprint
 import pydoc
 import sys

ansys/fluent/core/utils/fluent_version.py

@@ -1,3 +1,5 @@
+"""Provides a module to get Fluent version."""
+
 from enum import Enum
 from functools import total_ordering
 import os
@@ -23,6 +25,7 @@ class ComparisonError(RuntimeError):
 
 
 def get_version(session=None):
+    """Get Fluent version."""
     if session is None:
         # for CI runs, get the version statically from env var set within CI
         image_tag = os.getenv("FLUENT_IMAGE_TAG")
@@ -34,6 +37,7 @@ def get_version(session=None):
 
 
 def get_version_for_file_name(version: Optional[str] = None, session=None):
+    """Get Fluent version for file name."""
     if version is None:
         version = get_version(session)
 

ansys/fluent/core/utils/networking.py

@@ -1,3 +1,5 @@
+"""Provides a module to get networking functionality."""
+
 from concurrent import futures
 import logging
 import socket
@@ -25,6 +27,7 @@ def get_free_port() -> int:
 
 class _HealthServicer(health_pb2_grpc.HealthServicer):
     def Check(self, request, context: grpc.ServicerContext):
+        """Check the status of service."""
         return health_pb2.HealthCheckResponse(
             status=health_pb2.HealthCheckResponse.ServingStatus.SERVING
         )

ansys/fluent/core/utils/search.py

@@ -1,3 +1,5 @@
+"""Provides a module to search a word through the Fluent's object hierarchy.."""
+
 from collections.abc import Mapping
 from pathlib import Path
 import pickle
@@ -21,6 +23,7 @@ from ansys.fluent.core.workflow import (
 
 
 def get_api_tree_file_name(version: str, pyfluent_path: str) -> Path:
+    """Get API tree file name."""
     return (
         (
             (Path(pyfluent_path) / "ansys" / "fluent" / "core")

ansys/fluent/core/utils/setup_for_fluent.py

@@ -1,3 +1,5 @@
+"""Provides a module to get global PyConsole objects."""
+
 from ansys.fluent.core.launcher.launcher import launch_fluent
 from ansys.fluent.core.session_solver import Solver
 

ansys/fluent/core/warnings.py

@@ -1,3 +1,6 @@
+"""Provides a module to get warnings for core functionality."""
+
+
 class PyFluentDeprecationWarning(FutureWarning):
     """Provides the common warning class for all deprecated PyFluent feature."""
 

ansys/fluent/core/workflow.py

@@ -56,6 +56,8 @@ logger = logging.getLogger("pyfluent.datamodel")
 
 def _new_command_for_task(task, session):
     class NewCommandError(Exception):
+        """Raised on an attempt to create command for a given task."""
+
         def __init__(self, task_name):
             super().__init__(f"Could not create command for task {task_name}")
 
@@ -121,9 +123,15 @@ def _refresh_task_accessors(obj):
 def _convert_task_list_to_display_names(workflow_root, task_list):
     if pyfluent.DATAMODEL_USE_STATE_CACHE:
         workflow_state = DataModelCache.get_state("workflow", workflow_root)
+        return [workflow_state[f"TaskObject:{x}"]["_name_"] for x in task_list]
     else:
-        workflow_state = workflow_root.get_remote_state()
-    return [workflow_state[f"TaskObject:{x}"]["_name_"] for x in task_list]
+        _display_names = []
+        _org_path = workflow_root.path
+        for _task_name in task_list:
+            workflow_root.path = [("TaskObject", _task_name), ("_name_", "")]
+            _display_names.append(workflow_root())
+        workflow_root.path = _org_path
+        return _display_names
 
 
 class BaseTask:
@@ -453,8 +461,12 @@ class BaseTask:
         return matches
 
     def display_name(self):
+        """Display name."""
         return self._name_()
 
+    def __repr__(self):
+        return f"<Task '{self.display_name()}'>"
+
 
 class TaskContainer(PyCallableStateObject):
     """Wrap a workflow TaskObject container.
@@ -504,9 +516,11 @@ class TaskContainer(PyCallableStateObject):
         )
 
     def items(self):
+        """Get state items."""
         return self._task_container.get_state().items()
 
     def get_state(self):
+        """Get state."""
         return self._task_container.get_state()
 
     def __call__(self):
@@ -699,7 +713,12 @@ class ArgumentWrapper(PyCallableStateObject):
         if attr in self.__dict__:
             self.__dict__[attr] = value
         else:
-            getattr(self, attr).set_state(value)
+            if self._dynamic_interface:
+                camel_attr = snake_to_camel_case(
+                    str(attr), self._get_camel_case_arg_keys()
+                )
+                attr = camel_attr if camel_attr else attr
+            self.set_state({attr: value})
 
     def __dir__(self):
         arg_list = []

ansys/fluent/tests/test_datamodel_service.py

@@ -10,6 +10,7 @@ import ansys.fluent.core as pyfluent
 from ansys.fluent.core import examples
 from ansys.fluent.core.services.datamodel_se import (
     PyMenuGeneric,
+    ReadOnlyObjectError,
     _convert_variant_to_value,
     convert_path_to_se_path,
 )
@@ -472,3 +473,15 @@ def test_command_creation_inside_singleton(new_mesh_session):
     meshing = new_mesh_session
     read_mesh = meshing.meshing.File.ReadMesh.create_instance()
     assert read_mesh.FileName is not None
+
+
+def test_read_ony_set_state(new_mesh_session):
+    meshing = new_mesh_session
+    meshing.preferences.MeshingWorkflow.SaveCheckpointFiles = True
+    assert meshing.preferences.MeshingWorkflow.CheckpointingOption.is_read_only()
+    with pytest.raises(ReadOnlyObjectError):
+        meshing.preferences.MeshingWorkflow.CheckpointingOption = "Write into memory"
+
+    assert "set_state" not in dir(
+        meshing.preferences.MeshingWorkflow.CheckpointingOption
+    )

ansys/fluent/tests/test_field_data.py

@@ -46,11 +46,11 @@ def test_field_data(new_solver_session) -> None:
     iterate(iter_count=10)
 
     # Get field data object
-    field_data = solver.field_data
+    field_data = solver.fields.field_data
 
     transaction = field_data.new_transaction()
 
-    hot_inlet_surf_id = solver.field_info.get_surfaces_info()["hot-inlet"][
+    hot_inlet_surf_id = solver.fields.field_info.get_surfaces_info()["hot-inlet"][
         "surface_id"
     ][0]
     transaction.add_surfaces_request(
@@ -117,8 +117,8 @@ def test_field_data_allowed_values(new_solver_session) -> None:
         "mixing_elbow.msh.h5", "pyfluent/mixing_elbow"
     )
 
-    field_data = solver.field_data
-    field_info = solver.field_info
+    field_data = solver.fields.field_data
+    field_info = solver.fields.field_info
     transaction = field_data.new_transaction()
     fields_request = transaction.add_scalar_fields_request
 
@@ -173,7 +173,7 @@ def test_field_data_objects_3d(new_solver_session) -> None:
         "mixing_elbow.msh.h5", "pyfluent/mixing_elbow"
     )
 
-    field_data = solver.field_data
+    field_data = solver.fields.field_data
 
     assert [] == field_data.get_scalar_field_data.field_name.allowed_values()
 
@@ -241,7 +241,7 @@ def test_field_data_objects_3d(new_solver_session) -> None:
 def test_field_data_objects_2d(load_disk_mesh) -> None:
     solver = load_disk_mesh
 
-    field_data = solver.field_data
+    field_data = solver.fields.field_data
 
     allowed_args_no_init = field_data.get_scalar_field_data.field_name.allowed_values()
     assert len(allowed_args_no_init) != 0
@@ -302,12 +302,12 @@ def test_field_data_errors(new_solver_session) -> None:
     )
 
     with pytest.raises(DisallowedValuesError) as fne:
-        solver.field_data.get_scalar_field_data(
+        solver.fields.field_data.get_scalar_field_data(
             field_name="y-face-area", surface_ids=[0]
         )
 
     with pytest.raises(DisallowedValuesError) as fne:
-        solver.field_data.get_scalar_field_data(
+        solver.fields.field_data.get_scalar_field_data(
             field_name="partition-neighbors", surface_ids=[0]
         )
 
@@ -316,12 +316,12 @@ def test_field_data_errors(new_solver_session) -> None:
     with pytest.raises(FieldUnavailable) as fnu:
         solver.field_data.get_scalar_field_data(field_name="density", surface_ids=[0])
 
-    y_face_area = solver.field_data.get_scalar_field_data(
+    y_face_area = solver.fields.field_data.get_scalar_field_data(
         field_name="y-face-area", surface_ids=[0]
     )
     assert y_face_area and isinstance(y_face_area, dict)
 
-    partition_neighbors = solver.field_data.get_scalar_field_data(
+    partition_neighbors = solver.fields.field_data.get_scalar_field_data(
         field_name="partition-neighbors", surface_ids=[0]
     )
     assert partition_neighbors and isinstance(partition_neighbors, dict)
@@ -330,15 +330,17 @@ def test_field_data_errors(new_solver_session) -> None:
     solver.solution.initialization.hybrid_initialize()
 
     # Get field data object
-    field_data = solver.field_data
+    field_data = solver.fields.field_data
 
     with pytest.raises(DisallowedValuesError) as sne:
-        solver.field_data.get_scalar_field_data(
+        solver.fields.field_data.get_scalar_field_data(
             field_name="density", surface_name="bob"
         )
 
     with pytest.raises(DisallowedValuesError) as fne:
-        solver.field_data.get_scalar_field_data(field_name="xdensity", surface_ids=[0])
+        solver.fields.field_data.get_scalar_field_data(
+            field_name="xdensity", surface_ids=[0]
+        )
 
 
 @pytest.mark.fluent_version(">=23.2")
@@ -350,20 +352,20 @@ def test_field_info_validators(new_solver_session) -> None:
     solver.file.read(file_type="case", file_name=import_file_name)
     solver.solution.initialization.hybrid_initialize()
 
-    vector_field_1 = solver.field_info.validate_vector_fields("velocity")
+    vector_field_1 = solver.fields.field_info.validate_vector_fields("velocity")
     assert vector_field_1 is None
 
     with pytest.raises(DisallowedValuesError) as vector_field_error:
-        solver.field_info.validate_vector_fields("relative-vel")
+        solver.fields.field_info.validate_vector_fields("relative-vel")
 
-    scalar_field_1 = solver.field_info.validate_scalar_fields("z-velocity")
+    scalar_field_1 = solver.fields.field_info.validate_scalar_fields("z-velocity")
     assert scalar_field_1 is None
 
     with pytest.raises(DisallowedValuesError) as scalar_field_error:
-        solver.field_info.validate_scalar_fields("z-vel")
+        solver.fields.field_info.validate_scalar_fields("z-vel")
 
-    surface = solver.field_info.validate_surfaces(["cold-inlet"])
+    surface = solver.fields.field_info.validate_surfaces(["cold-inlet"])
     assert surface is None
 
     with pytest.raises(DisallowedValuesError) as surface_error:
-        solver.field_info.validate_surfaces(["out"])
+        solver.fields.field_info.validate_surfaces(["out"])

ansys/fluent/tests/test_flobject.py

@@ -886,7 +886,7 @@ def test_settings_matching_names(new_solver_session_no_transcript) -> None:
 @pytest.mark.fluent_version(">=24.2")
 def test_accessor_methods_on_settings_objects(launch_fluent_solver_3ddp_t2):
     solver = launch_fluent_solver_3ddp_t2
-    root = solver._root
+    root = solver.settings
 
     nodes = {}
     expected_type_list = [
@@ -1002,7 +1002,7 @@ def _check_vector_units(obj, units):
 @pytest.mark.fluent_version(">=24.1")
 def test_ansys_units_integration(load_mixing_elbow_mesh):
     solver = load_mixing_elbow_mesh
-    assert isinstance(solver._root.state_with_units(), dict)
+    assert isinstance(solver.settings.state_with_units(), dict)
     hot_inlet = solver.setup.boundary_conditions.velocity_inlet["hot-inlet"]
     turbulence = hot_inlet.turbulence
     turbulence.turbulent_specification = "Intensity and Hydraulic Diameter"

ansys/fluent/tests/test_launcher.py

@@ -28,9 +28,9 @@ from ansys.fluent.core.launcher.process_launch_string import (
 from ansys.fluent.core.launcher.pyfluent_enums import (
     FluentLinuxGraphicsDriver,
     FluentMode,
-    FluentUI,
     FluentWindowsGraphicsDriver,
     LaunchMode,
+    UIMode,
 )
 from ansys.fluent.core.utils.fluent_version import AnsysVersionNotFound, FluentVersion
 import ansys.platform.instancemanagement as pypim
@@ -77,22 +77,22 @@ def test_non_gui_in_windows_throws_exception():
     launcher_utils.is_windows = lambda: True
     try:
         with pytest.raises(InvalidArgument):
-            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v232)
+            _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v232)
         with pytest.raises(InvalidArgument):
-            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v231)
+            _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v231)
         with pytest.raises(InvalidArgument):
-            _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v222)
+            _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v222)
         with pytest.raises(InvalidArgument):
             _raise_non_gui_exception_in_windows(
-                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v232
+                UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v232
             )
         with pytest.raises(InvalidArgument):
             _raise_non_gui_exception_in_windows(
-                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v231
+                UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v231
             )
         with pytest.raises(InvalidArgument):
             _raise_non_gui_exception_in_windows(
-                FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v222
+                UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v222
             )
     finally:
         launcher_utils.is_windows = lambda: default_windows_flag
@@ -103,13 +103,13 @@ def test_non_gui_in_windows_does_not_throw_exception():
     default_windows_flag = launcher_utils.is_windows()
     launcher_utils.is_windows = lambda: True
     try:
-        _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v241)
+        _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v241)
         _raise_non_gui_exception_in_windows(
-            FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v241
+            UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v241
         )
-        _raise_non_gui_exception_in_windows(FluentUI.NO_GUI, FluentVersion.v242)
+        _raise_non_gui_exception_in_windows(UIMode.NO_GUI, FluentVersion.v242)
         _raise_non_gui_exception_in_windows(
-            FluentUI.NO_GUI_OR_GRAPHICS, FluentVersion.v242
+            UIMode.NO_GUI_OR_GRAPHICS, FluentVersion.v242
         )
     finally:
         launcher_utils.is_windows = lambda: default_windows_flag
@@ -305,7 +305,7 @@ def test_watchdog_launch(monkeypatch):
 
 def test_fluent_launchers():
     kwargs = dict(
-        ui=FluentUI.NO_GUI,
+        ui_mode=UIMode.NO_GUI,
         graphics_driver=(
             FluentWindowsGraphicsDriver.AUTO
             if is_windows()
@@ -382,23 +382,23 @@ def test_show_gui_raises_warning():
 
 
 def test_fluent_enums():
-    assert str(FluentUI.GUI) == "gui"
-    assert FluentUI("gui") == FluentUI.GUI
+    assert str(UIMode.GUI) == "gui"
+    assert UIMode("gui") == UIMode.GUI
     with pytest.raises(ValueError):
-        FluentUI("")
-    assert FluentUI.NO_GUI < FluentUI.GUI
+        UIMode("")
+    assert UIMode.NO_GUI < UIMode.GUI
     with pytest.raises(TypeError):
-        FluentUI.NO_GUI < FluentWindowsGraphicsDriver.AUTO
+        UIMode.NO_GUI < FluentWindowsGraphicsDriver.AUTO
 
 
 def test_exposure_and_graphics_driver_arguments():
     with pytest.raises(ValueError):
-        pyfluent.launch_fluent(ui="gu")
+        pyfluent.launch_fluent(ui_mode="gu")
     with pytest.raises(ValueError):
         pyfluent.launch_fluent(graphics_driver="x11" if is_windows() else "dx11")
-    for m in FluentUI:
+    for m in UIMode:
         assert (
-            _build_fluent_launch_args_string(ui=m).strip() == f"3ddp -{m.value[0]}"
+            _build_fluent_launch_args_string(ui_mode=m).strip() == f"3ddp -{m.value[0]}"
             if m.value[0]
             else " 3ddp"
         )

ansys/fluent/tests/test_meshing_queries_fdl.py

@@ -5,6 +5,7 @@ from ansys.fluent.core import examples
 import_filename = examples.download_file("mixing_elbow.msh.h5", "pyfluent/mixing_elbow")
 
 
+@pytest.mark.nightly
 @pytest.mark.fluent_version(">=24.2")
 def test_meshing_utilities(new_mesh_session):
     meshing_session = new_mesh_session