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

ansys/fluent/core/services/field_data.py

@@ -70,9 +70,14 @@ class FieldDataService(StreamingService):
         """GetSurfacesInfo RPC of FieldData service."""
         return self._stub.GetSurfacesInfo(request, metadata=self._metadata)
 
-    # pylint: disable=missing-raises-doc
     def get_fields(self, request):
-        """GetFields RPC of FieldData service."""
+        """GetFields RPC of FieldData service.
+
+        Raises
+        ------
+        RuntimeError
+            If an empty chunk encountered during field extraction.
+        """
         chunk_iterator = self._stub.GetFields(request, metadata=self._metadata)
         if not chunk_iterator.is_active():
             raise RuntimeError(
@@ -194,16 +199,19 @@ class FieldInfo:
         return info
 
     def validate_scalar_fields(self, field_name: str):
+        """Validate scalar fields."""
         _AllowedScalarFieldNames(
             self._is_data_valid, info=self.get_scalar_fields_info()
         ).valid_name(field_name)
 
     def validate_vector_fields(self, field_name: str):
+        """Validate vector fields."""
         _AllowedVectorFieldNames(
             self._is_data_valid, info=self.get_vector_fields_info()
         ).valid_name(field_name)
 
     def validate_surfaces(self, surfaces: List[str]):
+        """Validate surfaces."""
         for surface in surfaces:
             _AllowedSurfaceNames(info=self.get_surfaces_info()).valid_name(surface)
 
@@ -268,9 +276,14 @@ class _AllowedSurfaceNames(_AllowedNames):
     def __call__(self, respect_data_valid: bool = True) -> List[str]:
         return self._info if self._info else self._field_info.get_surfaces_info()
 
-    # pylint: disable=missing-raises-doc
     def valid_name(self, surface_name: str) -> str:
-        """Returns valid names."""
+        """Returns valid names.
+
+        Raises
+        ------
+        DisallowedValuesError
+            If surface name is invalid.
+        """
         if validate_inputs and not self.is_valid(surface_name):
             raise DisallowedValuesError("surface", surface_name, self())
         return surface_name
@@ -593,7 +606,9 @@ class FieldTransaction:
         skip: int, optional
             Pathlines to skip. The default is ``0``.
         reverse: bool, optional
-            Whether to draw pathlines in reverse direction. The default is ``False``.
+            Whether to draw pathlines in a reverse direction. The default is ``False``.
+        accuracy_control_on: bool, optional
+            Whether to control accuracy. The default is ``False``.
         tolerance: float, optional
             Pathlines tolerance. The default is ``0.001``.
         coarsen: int, optional
@@ -1421,6 +1436,8 @@ class FieldData:
             Pathlines to skip. The default is ``0``.
         reverse: bool, optional
             Whether to draw pathlines in reverse direction. The default is ``False``.
+        accuracy_control_on: bool, optional
+            Whether to control accuracy. The default is ``False``.
         tolerance: float, optional
             Pathlines tolerance. The default is ``0.001``.
         coarsen: int, optional

ansys/fluent/core/services/health_check.py

@@ -62,7 +62,6 @@ class HealthCheckService:
         response = self._stub.Check(request, metadata=self._metadata)
         return HealthCheckService.Status(response.status).name
 
-    # pylint: disable=missing-raises-doc
     def wait_for_server(self, timeout: int) -> None:
         """Keeps a watch on the health of the Fluent connection.
 

ansys/fluent/core/services/reduction.py

@@ -168,6 +168,8 @@ class ReductionService:
 
 
 class BadReductionRequest(Exception):
+    """Raised on an attempt to make a bad reduction request."""
+
     def __init__(self, err):
         super().__init__(f"Could not complete reduction function request: {err}")
 

ansys/fluent/core/services/settings.py

@@ -33,61 +33,73 @@ class _SettingsServiceImpl:
     def set_var(
         self, request: SettingsModule.SetVarRequest
     ) -> SettingsModule.SetVarResponse:
+        """Set a variable."""
         return self.__stub.SetVar(request, metadata=self.__metadata)
 
     def get_var(
         self, request: SettingsModule.GetVarRequest
     ) -> SettingsModule.GetVarResponse:
+        """Get a variable."""
         return self.__stub.GetVar(request, metadata=self.__metadata)
 
     def rename(
         self, request: SettingsModule.RenameRequest
     ) -> SettingsModule.RenameResponse:
+        """Rename an object."""
         return self.__stub.Rename(request, metadata=self.__metadata)
 
     def create(
         self, request: SettingsModule.CreateRequest
     ) -> SettingsModule.CreateResponse:
+        """Create an object."""
         return self.__stub.Create(request, metadata=self.__metadata)
 
     def delete(
         self, request: SettingsModule.DeleteRequest
     ) -> SettingsModule.DeleteResponse:
+        """Delete an object."""
         return self.__stub.Delete(request, metadata=self.__metadata)
 
     def get_object_names(
         self, request: SettingsModule.GetObjectNamesRequest
     ) -> SettingsModule.GetObjectNamesResponse:
+        """Get object names."""
         return self.__stub.GetObjectNames(request, metadata=self.__metadata)
 
     def get_list_size(
         self, request: SettingsModule.GetListSizeRequest
     ) -> SettingsModule.GetListSizeResponse:
+        """Get list size."""
         return self.__stub.GetListSize(request, metadata=self.__metadata)
 
     def resize_list_object(
         self, request: SettingsModule.ResizeListObjectRequest
     ) -> SettingsModule.ResizeListObjectResponse:
+        """Resize list object."""
         return self.__stub.ResizeListObject(request, metadata=self.__metadata)
 
     def get_static_info(
         self, request: SettingsModule.GetStaticInfoRequest
     ) -> SettingsModule.GetStaticInfoResponse:
+        """Get static info."""
         return self.__stub.GetStaticInfo(request, metadata=self.__metadata)
 
     def execute_cmd(
         self, request: SettingsModule.ExecuteCommandRequest
     ) -> SettingsModule.ExecuteCommandResponse:
+        """Execute the command."""
         return self.__stub.ExecuteCommand(request, metadata=self.__metadata)
 
     def execute_query(
         self, request: SettingsModule.ExecuteQueryRequest
     ) -> SettingsModule.ExecuteQueryResponse:
+        """Execute the query."""
         return self.__stub.ExecuteQuery(request, metadata=self.__metadata)
 
     def get_attrs(
         self, request: SettingsModule.GetAttrsRequest
     ) -> SettingsModule.GetAttrsResponse:
+        """Get attributes."""
         return self.__stub.GetAttrs(request, metadata=self.__metadata)
 
 
@@ -286,10 +298,15 @@ class SettingsService:
 
         return ret
 
-    # pylint: disable=missing-raises-doc
     @_trace
     def get_static_info(self) -> dict[str, Any]:
-        """Get static-info for settings."""
+        """Get static-info for settings.
+
+        Raises
+        ------
+        RuntimeError
+            If type is empty.
+        """
         request = SettingsModule.GetStaticInfoRequest()
         request.root = "fluent"
         response = self._service_impl.get_static_info(request)

ansys/fluent/core/services/solution_variables.py

@@ -59,7 +59,7 @@ class SolutionVariableInfo:
 
     .. code-block:: python
 
-        >>> solution_variable_info = solver_session.solution_variable_info
+        >>> solution_variable_info = solver_session.fields.solution_variable_info
         >>>
         >>> wall_fluid_info = solution_variable_info.get_variables_info(zone_names=['wall' , "fluid"], domain_name="mixture")
         >>> wall_fluid_info.solution_variables
@@ -117,10 +117,12 @@ class SolutionVariableInfo:
 
         @property
         def solution_variables(self) -> List[str]:
+            """Solution variables."""
             return list(self._solution_variables_info.keys())
 
         @property
         def svars(self) -> List[str]:
+            """Solution variables."""
             warnings.warn(
                 "svars is deprecated, use solution_variables instead",
                 DeprecationWarning,
@@ -155,6 +157,7 @@ class SolutionVariableInfo:
 
             @property
             def count(self) -> int:
+                """Get zone count."""
                 return sum(
                     [partition_info.count for partition_info in self.partitions_info]
                 )
@@ -178,13 +181,16 @@ class SolutionVariableInfo:
 
         @property
         def zones(self) -> List[str]:
+            """Get zone names."""
             return list(self._zones_info.keys())
 
         @property
         def domains(self) -> List[str]:
+            """Get domain names."""
             return list(self._domains_info.keys())
 
         def domain_id(self, domain_name) -> int:
+            """Get domain id."""
             return self._domains_info.get(domain_name, None)
 
     def __init__(
@@ -231,6 +237,7 @@ class SolutionVariableInfo:
     def get_svars_info(
         self, zone_names: List[str], domain_name: str = "mixture"
     ) -> SolutionVariables:
+        """Get solution variables info."""
         warnings.warn(
             "get_svars_info is deprecated, use get_variables_info instead",
             DeprecationWarning,
@@ -282,6 +289,7 @@ class ZoneError(ValueError):
 
 class _AllowedNames:
     def is_valid(self, name):
+        """Check whether a given name is valid or not."""
         return name in self()
 
 
@@ -302,6 +310,7 @@ class _AllowedSvarNames:
         zone_names: List[str],
         domain_name: str = "mixture",
     ):
+        """Check whether solution variable name is valid or not."""
         return solution_variable_name in self(
             zone_names=zone_names, domain_name=domain_name
         )
@@ -312,6 +321,13 @@ class _AllowedSvarNames:
         zone_names: List[str],
         domain_name: str = "mixture",
     ):
+        """Get a valid solution variable name.
+
+        Raises
+        ------
+        SvarError
+            If the given solution variable name is invalid.
+        """
         if not self.is_valid(
             solution_variable_name, zone_names=zone_names, domain_name=domain_name
         ):
@@ -330,6 +346,13 @@ class _AllowedZoneNames(_AllowedNames):
         return self._zones_info.zones
 
     def valid_name(self, zone_name):
+        """Get a valid zone name.
+
+        Raises
+        ------
+        ZoneError
+            If the given zone name is invalid.
+        """
         if not self.is_valid(zone_name):
             raise ZoneError(
                 zone_name=zone_name,
@@ -346,6 +369,13 @@ class _AllowedDomainNames(_AllowedNames):
         return self._zones_info.domains
 
     def valid_name(self, domain_name):
+        """Get a valid domain name.
+
+        Raises
+        ------
+        ZoneError
+            If the given domain name is invalid.
+        """
         if not self.is_valid(domain_name):
             raise ZoneError(
                 domain_name=domain_name,
@@ -360,6 +390,7 @@ class _SvarMethod:
             self._accessor = accessor
 
         def allowed_values(self):
+            """Get allowed values."""
             return sorted(self._accessor())
 
     def __init__(self, svar_accessor, args_allowed_values_accessors):
@@ -429,9 +460,9 @@ class SolutionVariableData:
     -------
     .. code-block:: python
         >>>
-        >>> solution_variable_data = solver_session.solution_variable_data
+        >>> solution_variable_data = solver_session.fields.solution_variable_data
         >>>
-        >>> sv_t_wall_fluid=solver_session.solution_variable_data.get_data(solution_variable_name="SV_T", domain_name="mixture", zone_names=["fluid", "wall"])
+        >>> sv_t_wall_fluid=solver_session.fields.solution_variable_data.get_data(solution_variable_name="SV_T", domain_name="mixture", zone_names=["fluid", "wall"])
         >>>
         >>> sv_t_wall_fluid.domain
         >>> 'mixture'
@@ -456,6 +487,8 @@ class SolutionVariableData:
     """
 
     class Data:
+        """Solution variable data."""
+
         def __init__(self, domain_name, zone_id_name_map, solution_variable_data):
             self._domain_name = domain_name
             self._data = {
@@ -465,14 +498,17 @@ class SolutionVariableData:
 
         @property
         def domain(self):
+            """Domain name."""
             return self._domain_name
 
         @property
         def zones(self):
+            """Zone name."""
             return list(self._data.keys())
 
         @property
         def data(self):
+            """Solution variable data."""
             return self._data
 
         def __getitem__(self, name):
@@ -577,6 +613,7 @@ class SolutionVariableData:
         zone_names: List[str],
         domain_name: Optional[str] = "mixture",
     ) -> Data:
+        """Get solution variable data."""
         warnings.warn(
             "get_svar_data is deprecated, use get_data instead",
             DeprecationWarning,
@@ -693,6 +730,7 @@ class SolutionVariableData:
         zone_names_to_svar_data: List[str],
         domain_name: Optional[str] = "mixture",
     ) -> Data:
+        """Set solution variable data."""
         warnings.warn(
             "set_svar_data is deprecated, use set_data instead",
             DeprecationWarning,

ansys/fluent/core/session.py

@@ -110,10 +110,10 @@ class BaseSession:
         file_transfer_service: Optional[Any] = None,
     ):
         """Build a BaseSession object from fluent_connection object."""
-        self.fluent_connection = fluent_connection
+        self._fluent_connection = fluent_connection
         self._file_transfer_service = file_transfer_service
-        self.error_state = self.fluent_connection.error_state
-        self.scheme_eval = self.fluent_connection.scheme_eval
+        self._error_state = fluent_connection._error_state
+        self.scheme_eval = fluent_connection.scheme_eval
         self.rp_vars = RPVars(self.scheme_eval.string_eval)
         self._preferences = None
         self.journal = Journal(self.scheme_eval)
@@ -128,14 +128,14 @@ class BaseSession:
         self.datamodel_service_tui = service_creator("tui").create(
             fluent_connection._channel,
             fluent_connection._metadata,
-            self.error_state,
+            self._error_state,
             self.scheme_eval,
         )
 
         self.datamodel_service_se = service_creator("datamodel").create(
             fluent_connection._channel,
             fluent_connection._metadata,
-            self.error_state,
+            self._error_state,
             self._file_transfer_service,
         )
 
@@ -145,18 +145,18 @@ class BaseSession:
         self._batch_ops_service = service_creator("batch_ops").create(
             fluent_connection._channel, fluent_connection._metadata
         )
-        self.events_service = service_creator("events").create(
+        self._events_service = service_creator("events").create(
             fluent_connection._channel, fluent_connection._metadata
         )
         self.events_manager = EventsManager(
-            self.events_service, self.error_state, self.fluent_connection._id
+            self._events_service, self._error_state, fluent_connection._id
         )
 
         self._monitors_service = service_creator("monitors").create(
-            fluent_connection._channel, fluent_connection._metadata, self.error_state
+            fluent_connection._channel, fluent_connection._metadata, self._error_state
         )
         self.monitors_manager = MonitorsManager(
-            self.fluent_connection._id, self._monitors_service
+            fluent_connection._id, self._monitors_service
         )
 
         self.events_manager.register_callback(
@@ -168,33 +168,41 @@ class BaseSession:
 
         self.events_manager.start()
 
-        self._field_data_service = self.fluent_connection.create_grpc_service(
-            FieldDataService, self.error_state
-        )
-        self.field_info = service_creator("field_info").create(
-            self._field_data_service, _IsDataValid(self.scheme_eval)
-        )
-        self.field_data = service_creator("field_data").create(
-            self._field_data_service,
-            self.field_info,
-            _IsDataValid(self.scheme_eval),
-            self.scheme_eval,
-        )
-        self.field_data_streaming = FieldDataStreaming(
-            self.fluent_connection._id, self._field_data_service
+        self._field_data_service = self._fluent_connection.create_grpc_service(
+            FieldDataService, self._error_state
         )
 
-        self.settings_service = service_creator("settings").create(
+        class Fields:
+            """Container for field and solution variables."""
+
+            def __init__(self, _session):
+                """Initialize Fields."""
+                self.field_info = service_creator("field_info").create(
+                    _session._field_data_service, _IsDataValid(_session.scheme_eval)
+                )
+                self.field_data = service_creator("field_data").create(
+                    _session._field_data_service,
+                    self.field_info,
+                    _IsDataValid(_session.scheme_eval),
+                    _session.scheme_eval,
+                )
+                self.field_data_streaming = FieldDataStreaming(
+                    _session._fluent_connection._id, _session._field_data_service
+                )
+
+        self.fields = Fields(self)
+
+        self._settings_service = service_creator("settings").create(
             fluent_connection._channel,
             fluent_connection._metadata,
             self.scheme_eval,
-            self.error_state,
+            self._error_state,
         )
 
         self.health_check_service = fluent_connection.health_check_service
         self.connection_properties = fluent_connection.connection_properties
 
-        self.fluent_connection.register_finalizer_cb(
+        self._fluent_connection.register_finalizer_cb(
             self.datamodel_service_se.unsubscribe_all_events
         )
         for obj in (
@@ -203,12 +211,39 @@ class BaseSession:
             self.events_manager,
             self.monitors_manager,
         ):
-            self.fluent_connection.register_finalizer_cb(obj.stop)
+            self._fluent_connection.register_finalizer_cb(obj.stop)
+
+    @property
+    def field_info(self):
+        """Provides access to Fluent field information."""
+        warnings.warn(
+            "field_info is deprecated. Use fields.field_info instead.",
+            DeprecationWarning,
+        )
+        return self.fields.field_info
+
+    @property
+    def field_data(self):
+        """Fluent field data on surfaces."""
+        warnings.warn(
+            "field_data is deprecated. Use fields.field_data instead.",
+            DeprecationWarning,
+        )
+        return self.fields.field_data
+
+    @property
+    def field_data_streaming(self):
+        """Field gRPC streaming service of Fluent."""
+        warnings.warn(
+            "field_data_streaming is deprecated. Use fields.field_data_streaming instead.",
+            DeprecationWarning,
+        )
+        return self.fields.field_data_streaming
 
     @property
     def id(self) -> str:
         """Return the session ID."""
-        return self.fluent_connection._id
+        return self._fluent_connection._id
 
     def start_journal(self, file_name: str):
         """Executes tui command to start journal."""
@@ -221,7 +256,7 @@ class BaseSession:
         self.journal.stop()
 
     @classmethod
-    def create_from_server_info_file(
+    def _create_from_server_info_file(
         cls,
         server_info_file_name: str,
         file_transfer_service: Optional[Any] = None,
@@ -266,15 +301,12 @@ class BaseSession:
     def exit(self, **kwargs) -> None:
         """Exit session."""
         logger.debug("session.exit() called")
-        self.fluent_connection.exit(**kwargs)
+        self._fluent_connection.exit(**kwargs)
 
     def force_exit(self) -> None:
-        """Terminate session."""
-        self.fluent_connection.force_exit()
-
-    def force_exit_container(self) -> None:
-        """Terminate Docker container session."""
-        self.fluent_connection.force_exit_container()
+        """Immediately terminates the Fluent session, losing unsaved progress and
+        data."""
+        self._fluent_connection.force_exit()
 
     def upload(self, file_name: str):
         """Upload a file to the server.
@@ -284,7 +316,8 @@ class BaseSession:
         file_name : str
             Name of the local file to upload to the server.
         """
-        return self._file_transfer_service.upload_file(file_name)
+        if self._file_transfer_service:
+            return self._file_transfer_service.upload_file(file_name)
 
     def download(self, file_name: str, local_directory: Optional[str] = "."):
         """Download a file from the server.
@@ -296,7 +329,8 @@ class BaseSession:
         local_directory : str, optional
             Local destination directory. The default is the current working directory.
         """
-        return self._file_transfer_service.download_file(file_name, local_directory)
+        if self._file_transfer_service:
+            return self._file_transfer_service.download_file(file_name, local_directory)
 
     def __enter__(self):
         return self
@@ -305,3 +339,11 @@ class BaseSession:
         """Close the Fluent connection and exit Fluent."""
         logger.debug("session.__exit__() called")
         self.exit()
+
+    def __dir__(self):
+        dir_list = set(list(self.__dict__.keys()) + dir(type(self))) - {
+            "field_data",
+            "field_info",
+            "field_data_streaming",
+        }
+        return sorted(dir_list)

ansys/fluent/core/session_base_meshing.py

@@ -1,3 +1,5 @@
+"""Provides a module to get base Meshing session."""
+
 import importlib
 import logging
 
@@ -98,6 +100,7 @@ class BaseMeshing:
 
     @property
     def meshing(self):
+        """Meshing object."""
         if self._meshing is None:
             self._meshing = self._meshing_root
         return self._meshing
@@ -123,6 +126,7 @@ class BaseMeshing:
 
     @property
     def meshing_utilities(self):
+        """A wrapper over the Fluent's meshing queries."""
         if self._meshing_utilities is None:
             self._meshing_utilities = self._meshing_utilities_root
         return self._meshing_utilities

ansys/fluent/core/session_meshing.py

@@ -38,7 +38,7 @@ class Meshing(PureMeshing):
     def _switch_to_solver(self) -> Any:
         self.tui.switch_to_solution_mode("yes")
         solver_session = Solver(
-            fluent_connection=self.fluent_connection,
+            fluent_connection=self._fluent_connection,
             file_transfer_service=self._file_transfer_service,
         )
         delattr(self, "switch_to_solver")

ansys/fluent/core/session_pure_meshing.py

@@ -27,17 +27,6 @@ class PureMeshing(BaseSession):
     in this mode.
     """
 
-    rules = [
-        "workflow",
-        "meshing",
-        "MeshingUtilities",
-        "PartManagement",
-        "PMFileManagement",
-    ]
-
-    for r in rules:
-        DataModelCache.set_config(r, "name_key", NameKey.INTERNAL)
-
     def __init__(
         self,
         fluent_connection: FluentConnection,
@@ -62,23 +51,23 @@ class PureMeshing(BaseSession):
         )
 
         self.meshing_queries_service = fluent_connection.create_grpc_service(
-            MeshingQueriesService, self.error_state
+            MeshingQueriesService, self._error_state
         )
 
         datamodel_service_se = self.datamodel_service_se
         self.datamodel_streams = {}
         if pyfluent.DATAMODEL_USE_STATE_CACHE:
-            for rules in self.__class__.rules:
+            for _rules in rules:
                 stream = DatamodelStream(datamodel_service_se)
                 stream.register_callback(
-                    functools.partial(DataModelCache.update_cache, rules=rules)
+                    functools.partial(DataModelCache.update_cache, rules=_rules)
                 )
-                self.datamodel_streams[rules] = stream
+                self.datamodel_streams[_rules] = stream
                 stream.start(
-                    rules=rules,
+                    rules=_rules,
                     no_commands_diff_state=pyfluent.DATAMODEL_USE_NOCOMMANDS_DIFF_STATE,
                 )
-                self.fluent_connection.register_finalizer_cb(stream.stop)
+                self._fluent_connection.register_finalizer_cb(stream.stop)
 
     @property
     def tui(self):
@@ -173,3 +162,15 @@ class PureMeshing(BaseSession):
             clean_up_mesh_file,
             overwrite_previous,
         )
+
+
+rules = [
+    "workflow",
+    "meshing",
+    "MeshingUtilities",
+    "PartManagement",
+    "PMFileManagement",
+]
+
+for r in rules:
+    DataModelCache.set_config(r, "name_key", NameKey.INTERNAL)

ansys/fluent/core/session_shared.py

@@ -1,3 +1,5 @@
+"""Provides a module for codegen messages."""
+
 _CODEGEN_MSG_DATAMODEL = (
     "Currently calling the datamodel API in a generic manner. "
     "Please run `python codegen/allapigen.py` from the top-level pyfluent "