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

ansys/fluent/core/filereader/casereader.py

@@ -4,9 +4,10 @@ import warnings
 
 from ansys.fluent.core.warnings import PyFluentDeprecationWarning
 
+from .case_file import CaseFile as CaseReader  # noqa: F401
+
 # Compatibility aliases
 warnings.warn(
     "Use case_file.CaseFile instead of casereader.CaseReader",
     PyFluentDeprecationWarning,
 )
-from .case_file import CaseFile as CaseReader  # noqa: F401

ansys/fluent/core/filereader/data_file.py

@@ -36,17 +36,17 @@ class DataFile:
 
     Methods
     -------
-    case_file
+    case_file()
         Get the name of case file.
-    get_face_variables
-        Get the variables list available at face.
-    get_phases
+    get_phases()
         Get the list of phases.
-    get_cell_variables
+    get_face_variables(phase_name)
+        Get the variables list available at face.
+    get_cell_variables(phase_name)
         Get the variables list available at cell.
-    get_face_scalar_field_data
+    get_face_scalar_field_data(phase_name, field_name, surface_id)
         Get the scalar field data for face.
-    get_face_vector_field_data
+    get_face_vector_field_data(phase_name, surface_id)
         Get the vector field data for face.
     """
 

ansys/fluent/core/filereader/lispy.py

@@ -1,5 +1,7 @@
 """Provides a module for Scheme Interpreter in Python."""
 
+# flake8: noqa: E266
+
 ################ Scheme Interpreter in Python
 
 ## (c) Peter Norvig, 2010; See http://norvig.com/lispy2.html
@@ -48,6 +50,7 @@ class Procedure:
     """A user-defined Scheme procedure."""
 
     def __init__(self, params, exp, env):
+        """Initialize Procedure."""
         self.params, self.exp, self.env = params, exp, env
 
     def __call__(self, *args):
@@ -91,6 +94,7 @@ class InputPort:
     tokenizer = r"""\s*(,@|[('`,)]|"(?:[\\].|[^\\"])*"|;.*|[^\s('"`,;)]*)(.*)"""
 
     def __init__(self, file):
+        """Initialize InputPort."""
         self.file = file
         self.line = ""
 
@@ -252,6 +256,7 @@ class Env(dict):
     """An environment: a dict of {'var':val} pairs, with an outer Env."""
 
     def __init__(self, params=(), args=(), outer=None):
+        """Initialize Env."""
         # Bind paarm list to corresponding args, or single param to list of args
         self.outer = outer
         if isa(params, Symbol):
@@ -497,7 +502,7 @@ _append, _cons, _let = map(Sym, "append cons let".split())
 
 
 def expand_quasiquote(x):
-    """Expand `x => 'x; `,x => x; `(,@x y) => (append x y)"""
+    """Expand ```x`` => ``'x``; ```,x`` => ``x``; ```(,@x y)`` => ``(append x y)``."""
     if not is_pair(x):
         return [_quote, x]
     require(x, x[0] is not _unquotesplicing, "can't splice here")

ansys/fluent/core/fluent_connection.py

@@ -2,21 +2,22 @@
 
 from __future__ import annotations
 
+import ctypes
 from ctypes import c_int, sizeof
 from dataclasses import dataclass
 import itertools
 import logging
 import os
 from pathlib import Path
+import platform
 import socket
 import subprocess
 import threading
-from typing import Any, Callable, List, Tuple
+from typing import Any, Callable, List, Tuple, TypeVar
 import warnings
 import weakref
 
 import grpc
-import psutil
 
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.services import service_creator
@@ -39,6 +40,7 @@ class PortNotProvided(ValueError):
     """Raised when port is not provided."""
 
     def __init__(self):
+        """Initialize PortNotProvided."""
         super().__init__(
             "Provide the 'port' to connect to an existing Fluent instance."
         )
@@ -48,6 +50,7 @@ class UnsupportedRemoteFluentInstance(ValueError):
     """Raised when 'wait_process_finished' does not support remote Fluent session."""
 
     def __init__(self):
+        """Initialize UnsupportedRemoteFluentInstance."""
         super().__init__("Remote Fluent instance is unsupported.")
 
 
@@ -55,6 +58,7 @@ class WaitTypeError(TypeError):
     """Raised when invalid ``wait`` type is provided."""
 
     def __init__(self):
+        """Initialize WaitTypeError."""
         super().__init__("Invalid 'wait' type.")
 
 
@@ -82,6 +86,7 @@ class MonitorThread(threading.Thread):
     """
 
     def __init__(self):
+        """Initialize MonitorThread."""
         super().__init__(daemon=True)
         self.cbs: List[Callable] = []
 
@@ -93,7 +98,10 @@ class MonitorThread(threading.Thread):
             cb()
 
 
-def get_container(container_id_or_name: str) -> bool | Container | None:
+ContainerT = TypeVar("ContainerT")
+
+
+def get_container(container_id_or_name: str) -> bool | ContainerT | None:
     """Get the Docker container object.
 
     Returns
@@ -199,7 +207,7 @@ class FluentConnectionProperties:
     cortex_pid: int | None = None
     cortex_host: str | None = None
     fluent_host_pid: int | None = None
-    inside_container: bool | Container | None = None
+    inside_container: bool | ContainerT | None = None
 
     def list_names(self) -> list:
         """Returns list with all property names."""
@@ -262,7 +270,7 @@ class _ConnectionInterface:
             logger.debug("Cortex connection properties successfully obtained.")
         except _InactiveRpcError:
             logger.warning(
-                "Fluent Cortex properties unobtainable. 'force exit()' and other"
+                "Fluent Cortex properties unobtainable. 'force exit()' and other "
                 "methods are not going to work properly. Proceeding..."
             )
             fluent_host_pid = None
@@ -292,6 +300,26 @@ class _ConnectionInterface:
         self.scheme_eval.exec(("(exit-server)",))
 
 
+def _pid_exists(pid):
+    if platform.system() == "Linux":
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            return False
+        else:
+            return True
+    elif platform.system() == "Windows":
+        process_query_limited_information = 0x1000
+        process_handle = ctypes.windll.kernel32.OpenProcess(
+            process_query_limited_information, 0, pid
+        )
+        if process_handle == 0:
+            return False
+        else:
+            ctypes.windll.kernel32.CloseHandle(process_handle)
+            return True
+
+
 class FluentConnection:
     """Encapsulates a Fluent connection.
 
@@ -601,8 +629,8 @@ class FluentConnection:
             )
         else:
             _response = timeout_loop(
-                lambda connection: psutil.pid_exists(connection.fluent_host_pid)
-                or psutil.pid_exists(connection.cortex_pid),
+                lambda connection: _pid_exists(connection.fluent_host_pid)
+                or _pid_exists(connection.cortex_pid),
                 wait,
                 args=(self.connection_properties,),
                 idle_period=0.5,