ansys-fluent-visualization 0.22.1__tar.gz → 0.23.dev0__tar.gz

{ansys_fluent_visualization-0.22.1 → ansys_fluent_visualization-0.23.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansys-fluent-visualization
-Version: 0.22.1
+Version: 0.23.dev0
 Summary: A python wrapper for ansys Fluent visualization
 License: MIT
 License-File: AUTHORS
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: interactive
 Provides-Extra: single-window
-Requires-Dist: ansys-fluent-core (>=0.35.0,<0.36.0)
+Requires-Dist: ansys-fluent-core (>=0.36.dev1,<1.0)
 Requires-Dist: importlib-metadata (>=4.0,<5.0) ; python_version < "3.9"
 Requires-Dist: matplotlib (>=3.6.0)
 Requires-Dist: pyside6 (>=6.8.1,<6.9.0) ; extra == "single-window"
@@ -69,7 +69,7 @@ PyFluent-Visualization
 
 Overview
 --------
-PyFluent-Visualization provides postprocessing and visualization
+PyFluent-Visualization provides post-processing and visualization
 capabilities for `PyFluent <https://github.com/ansys/pyfluent>`_
 using `PyVista <https://docs.pyvista.org/>`_ and
 `Matplotlib <https://matplotlib.org/>`_.

{ansys_fluent_visualization-0.22.1 → ansys_fluent_visualization-0.23.dev0}/README.rst

@@ -35,7 +35,7 @@ PyFluent-Visualization
 
 Overview
 --------
-PyFluent-Visualization provides postprocessing and visualization
+PyFluent-Visualization provides post-processing and visualization
 capabilities for `PyFluent <https://github.com/ansys/pyfluent>`_
 using `PyVista <https://docs.pyvista.org/>`_ and
 `Matplotlib <https://matplotlib.org/>`_.

{ansys_fluent_visualization-0.22.1 → ansys_fluent_visualization-0.23.dev0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry]
 # Check https://python-poetry.org/docs/pyproject/ for all available sections
 name = "ansys-fluent-visualization"
-version = "0.22.1"
+version = "0.23.dev0"
 description = "A python wrapper for ansys Fluent visualization"
 license = "MIT"
 authors = ["ANSYS, Inc. <ansys.support@ansys.com>"]
@@ -25,7 +25,7 @@ packages = [
 [tool.poetry.dependencies]
 python = ">=3.10,<3.14"
 importlib-metadata = {version = "^4.0", python = "<3.9"}
-ansys-fluent-core = "~=0.35.0"
+ansys-fluent-core = "~=0.36.dev1"
 pyvista = ">=0.44.0"
 matplotlib = ">=3.6.0"
 pyvistaqt = { version = "~=0.11.1", optional = true }
@@ -55,3 +55,25 @@ source = ["ansys/fluent"]
 
 [tool.coverage.report]
 show_missing = true
+
+[tool.bandit]
+exclude_dirs = ["tests"]
+skips = [
+    "B101",
+    "B105",
+    "B106",
+    "B110",
+    "B112",
+    "B301",
+    "B307",
+    "B310",
+    "B311",
+    "B314",
+    "B403",
+    "B404",
+    "B405",
+    "B602",
+    "B603",
+    "B604",
+    "B607",
+    ]

{ansys_fluent_visualization-0.22.1 → ansys_fluent_visualization-0.23.dev0}/src/ansys/fluent/interface/post_objects/post_object_definitions.py

@@ -644,12 +644,12 @@ class VectorDefn(GraphicsDefn):
     class vectors_of(metaclass=PyLocalPropertyMeta):
         """Vector type."""
 
-        value: str = "velocity"
+        value: str = None
 
         @Attribute
         def allowed_values(self):
             """Vectors of allowed values."""
-            return list(self.field_data.vectors())
+            return list(self.field_data.vector_fields())
 
     class field(metaclass=PyLocalPropertyMeta):
         """Vector color field."""

{ansys_fluent_visualization-0.22.1 → ansys_fluent_visualization-0.23.dev0}/src/ansys/fluent/visualization/__init__.py

@@ -27,7 +27,7 @@ try:
 except ModuleNotFoundError:
     import importlib_metadata
 
-_VERSION_INFO = "Build date: September 19, 2025 10:14 UTC ShaID: f20236b"
+_VERSION_INFO = "Build date: November 25, 2025 12:21 UTC ShaID: 1923822"
 __version__ = importlib_metadata.version(__name__.replace(".", "-"))
 
 

{ansys_fluent_visualization-0.22.1 → ansys_fluent_visualization-0.23.dev0}/src/ansys/fluent/visualization/containers.py

@@ -21,6 +21,8 @@
 # SOFTWARE.
 
 """Containers for graphics."""
+import warnings
+
 from ansys.fluent.core.field_data_interfaces import _to_field_name_str
 from ansys.fluent.core.utils.context_managers import _get_active_session
 from ansys.units import VariableDescriptor
@@ -39,6 +41,8 @@ class _GraphicsContainer:
             raise RuntimeError("No solver session provided and none found in context.")
         if "field" in self.kwargs:
             self.kwargs["field"] = _to_field_name_str(self.kwargs["field"])
+        if "vectors_of" in self.kwargs:
+            self.kwargs["vectors_of"] = _to_field_name_str(self.kwargs["vectors_of"])
 
     def __getattr__(self, attr):
         return getattr(self._obj, attr)
@@ -53,22 +57,46 @@ class _GraphicsContainer:
 
 
 class Mesh(_GraphicsContainer):
-    """Mesh.
+    """Mesh visualization object.
+
+    Creates a Fluent mesh graphic object on the specified surfaces.
+    It is typically used to display the computational mesh with optional
+    edge highlighting.
+
+    Parameters
+    ----------
+    surfaces : list[str]
+        List of Fluent surfaces on which the mesh should be displayed.
+    show_edges : ``bool``, optional
+        If ``True``, mesh edges are drawn. If ``False`` (default), the mesh
+        is shown without explicit edge highlighting.
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent container determines
+        the session.
+    **kwargs : dict
+        Additional keyword arguments forwarded to
+        ``Graphics(session).Mesh.create()`` or handled by the base class.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import Mesh
-
     >>> # `solver_session` is a live Fluent session with a case
     >>> # and data which contains the following surfaces
-
     >>> mesh = Mesh(
     >>>     solver=solver_session, show_edges=True, surfaces=["in1", "in2", "in3"]
     >>> )
     """
 
-    def __init__(self, solver=None, **kwargs):
+    def __init__(
+        self, surfaces: list[str], show_edges: bool = False, solver=None, **kwargs
+    ):
         """__init__ method of Mesh class."""
+        kwargs.update(
+            {
+                "show_edges": show_edges,
+                "surfaces": surfaces,
+            }
+        )
         super().__init__(solver, **kwargs)
         self.__dict__["_obj"] = Graphics(session=self.solver).Meshes.create(
             **self.kwargs
@@ -76,14 +104,41 @@ class Mesh(_GraphicsContainer):
 
 
 class Surface(_GraphicsContainer):
-    """Surface.
+    """Surface definition for Fluent post-processing.
+
+    The ``Surface`` class represents any Fluent surface generated for
+    post-processing, including plane surfaces and iso-surfaces. After creation,
+    additional attributes (such as ``field``, ``iso_value``, ``creation_method``,
+    etc.) may be set on the object to fully define the surface.
+
+    Parameters
+    ----------
+    type : str
+        The type of surface to create. Examples include
+        ``"plane-surface"`` and ``"iso-surface"``.
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent container or base
+        class determines the session.
+    **kwargs : dict
+        Additional keyword arguments used to define the surface and passed to
+        ``Graphics(session).Surfaces.create()``. These vary depending on
+        the chosen surface type.
+
+    Notes
+    -----
+    A Surface object may be defined either:
+
+    * Directly at construction time using keyword arguments
+      (e.g., specifying ``creation_method``, ``origin``/``normal``,
+      ``z`` for plane surfaces, etc.)
+
+    * Or incrementally after creation by setting attributes on the
+      surface object before it is first evaluated or drawn.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import Surface
-
     >>> # `solver_session` is a live Fluent session with a case file loaded
-
     >>> # For plane-surface
     >>> surf_xy_plane = Surface(
     >>>     solver=solver_session,
@@ -91,16 +146,19 @@ class Surface(_GraphicsContainer):
     >>>     creation_method="xy-plane",
     >>>     z=-0.0441921
     >>>     )
-
     >>> # For iso-surface
-    >>> surf_outlet_plane = Surface(solver=solver_session)
-    >>> surf_outlet_plane.type = "iso-surface"
+    >>> surf_outlet_plane = Surface(solver=solver_session, type="iso-surface")
     >>> surf_outlet_plane.field = "y-coordinate"
     >>> surf_outlet_plane.iso_value = -0.125017
     """
 
-    def __init__(self, solver=None, **kwargs):
+    def __init__(self, type: str, solver=None, **kwargs):
         """__init__ method of Surface class."""
+        kwargs.update(
+            {
+                "type": type,
+            }
+        )
         super().__init__(solver, **kwargs)
         self.__dict__.update(
             dict(
@@ -183,16 +241,14 @@ class PlaneSurface(Surface):
     Examples
     --------
     >>> from ansys.fluent.visualization import PlaneSurface
-
     >>> # `solver_session` is a live Fluent session with a case file loaded
-
+    >>>
     >>> # Creating using point and normal
     >>> surf_xy_plane = PlaneSurface.create_from_point_and_normal(
     >>>     solver=solver_session,
     >>>     point=[0.0, 0.0, -0.0441921],
     >>>     normal=[0.0, 0.0, 1.0],
     >>>     )
-
     >>> # Create same plane using 'create_xy_plane' method
     >>> surf_xy_plane = PlaneSurface.create_xy_plane(
     >>>     solver=solver_session,
@@ -253,15 +309,33 @@ class PlaneSurface(Surface):
 
 
 class IsoSurface(Surface):
-    """IsoSurface derived from Surface.
-    Provides factory method for creating iso-surfaces.
+    """Iso-surface derived from :class:`Surface`.
+
+    The ``IsoSurface`` class simplifies creation of iso-surfaces by providing
+    a higher-level interface on top of the generic :class:`Surface` class.
+    It supports specifying the scalar field and iso-value directly, and
+    internally configures the corresponding Fluent surface object.
+
+    Parameters
+    ----------
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent container or base class
+        determines the session.
+    field : str or VariableDescriptor, optional
+        The scalar field over which the iso-surface is computed.
+    rendering : str, optional
+        Rendering method for the iso-surface depending on Fluent capabilities.
+    iso_value : float, optional
+        The value of the scalar field at which the iso-surface is extracted.
+    **kwargs : dict
+        Additional keyword arguments forwarded to
+        ``Graphics(session).Surfaces.create()`` or handled by the base class.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import IsoSurface
-
     >>> # `solver_session` is a live Fluent session with a case file loaded
-
+    >>>
     >>> # Creating iso-surface
     >>> surf_outlet_plane = IsoSurface.create(
     >>>     solver=solver_session,
@@ -290,22 +364,54 @@ class IsoSurface(Surface):
 
 
 class Contour(_GraphicsContainer):
-    """Contour.
+    """
+    Contour visualization object.
+
+    The ``Contour`` class represents a Fluent contour plot of a scalar field
+    drawn over one or more surfaces. Contours are commonly used to visualize
+    variations in temperature, pressure, velocity magnitude, turbulence
+    quantities, or any other field available in the solver.
+
+    Parameters
+    ----------
+    field : str or VariableDescriptor
+        Name of the scalar field to be contoured. This defines the quantity
+        used for color interpolation across the specified surfaces.
+    surfaces : list of str
+        List of Fluent surfaces on which the contour is displayed.
+        Surfaces may be boundary zones, interior surfaces, or custom
+        surfaces such as iso-surfaces or plane surfaces.
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent class or container
+        determines the session.
+    **kwargs : dict
+        Additional keyword arguments forwarded to
+        ``Graphics(session).Contours.create()`` or handled by the base class.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import Contour
-
     >>> # `solver_session` is a live Fluent session with a case
     >>> # and data which contains the following surfaces
-
     >>> temperature_contour_object = Contour(
     >>>     solver=solver_session, field="temperature", surfaces=["in1", "in2", "in3",]
     >>> )
     """
 
-    def __init__(self, solver=None, **kwargs):
+    def __init__(
+        self,
+        field: str | VariableDescriptor,
+        surfaces: list[str],
+        solver=None,
+        **kwargs
+    ):
         """__init__ method of Contour class."""
+        kwargs.update(
+            {
+                "field": field,
+                "surfaces": surfaces,
+            }
+        )
         super().__init__(solver, **kwargs)
         self.__dict__["_obj"] = Graphics(session=self.solver).Contours.create(
             **self.kwargs
@@ -313,48 +419,142 @@ class Contour(_GraphicsContainer):
 
 
 class Vector(_GraphicsContainer):
-    """Vector.
+    """Vector visualization object.
+
+    Parameters
+    ----------
+    field : str|VariableDescriptor
+        Name of the variable used for the **vector direction/magnitude**.
+    color_by : str|VariableDescriptor
+        Name of the variable used to **color** the vectors.
+    surfaces : list[str]
+        List of Fluent surfaces on which the vector plot is created.
+    scale : float, optional
+        Scaling factor applied to the vector lengths. Defaults to 1.0.
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent container determines
+        the session.
+    **kwargs : dict
+        Additional keyword arguments forwarded to
+        ``Graphics(session).Vectors.create()``.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import Vector
-
     >>> # `solver_session` is a live Fluent session with a case
     >>> # and data which contains the following surfaces
-
     >>> velocity_vector_object = Vector(
     >>>     solver=solver_session,
-    >>>     field="x-velocity",
+    >>>     field="velocity",
+    >>>     color_by="pressure",
     >>>     surfaces=["solid_up:1:830"],
     >>>     scale=2,
     >>> )
     """
 
-    def __init__(self, solver=None, **kwargs):
+    def __init__(
+        self,
+        field: str | VariableDescriptor,
+        surfaces: list[str],
+        color_by: str | VariableDescriptor | None = None,
+        scale: float = 1.0,
+        solver=None,
+        **kwargs
+    ):
         """__init__ method of Vector class."""
+        if color_by is None:
+            color_by = field
+        kwargs.update(
+            {
+                "vectors_of": field,
+                "field": color_by,
+                "surfaces": surfaces,
+                "scale": scale,
+            }
+        )
         super().__init__(solver, **kwargs)
         self.__dict__["_obj"] = Graphics(session=self.solver).Vectors.create(
             **self.kwargs
         )
+        if field not in self._obj.vectors_of.allowed_values:
+            warnings.warn(
+                "API update: `field` now represents the vector variable, and `color_by`"
+                " controls the scalar coloring field.\n"
+                "Your input seems to use `field` as a scalar (old behavior). "
+                "It is being interpreted as `color_by`, and the vector field has been "
+                "defaulted to 'velocity' for compatibility.\n"
+                "Please update your code to: field=<vector>, color_by=<scalar>."
+            )
+
+    @staticmethod
+    def _get_mapped_attrs(attr):
+        _attr_map = {
+            "field": "vectors_of",
+            "color_by": "field",
+        }
+        return _attr_map.get(attr)
+
+    def __getattr__(self, attr):
+        attr = self._get_mapped_attrs(attr) or attr
+        return getattr(self._obj, attr)
+
+    def __setattr__(self, attr, value):
+        attr = self._get_mapped_attrs(attr) or attr
+        if attr == "surfaces":
+            value = list(value)
+        setattr(self._obj, attr, value)
 
 
 class Pathline(_GraphicsContainer):
-    """Pathline.
+    """Pathline visualization object.
+
+    The ``Pathline`` class generates pathlines, which represent the trajectories
+    of massless particles as they travel through the flow field based on the
+    underlying velocity data. Pathlines are commonly used to visualize flow
+    patterns, mixing, recirculation, and streamline-like behavior in transient
+    or steady-state solutions.
+
+    Parameters
+    ----------
+    field : str or VariableDescriptor
+        The field used to determine particle motion, typically a velocity-based
+        variable (e.g., ``"velocity-magnitude"``, ``"x-velocity"``, etc.).
+    surfaces : list of str
+        List of seed surfaces where pathlines originate. These may include
+        boundary zones, inlets, interior surfaces, or user-defined surfaces.
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent class or container
+        determines the session.
+    **kwargs : dict
+        Additional keyword arguments forwarded to
+        ``Graphics(session).Pathlines.create()`` or handled by the base class.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import Pathline
-
     >>> # `solver_session` is a live Fluent session with a case
     >>> # and data which contains the following surfaces
-
-    >>> pathlines = Pathline(solver=solver_session)
-    >>> pathlines.field = "velocity-magnitude"
-    >>> pathlines.surfaces = ["inlet", "inlet1", "inlet2"]
+    >>> pathlines = Pathline(
+    >>>     solver=solver_session,
+    >>>     field="velocity-magnitude",
+    >>>     surfaces = ["inlet", "inlet1", "inlet2"],
+    >>> )
     """
 
-    def __init__(self, solver=None, **kwargs):
+    def __init__(
+        self,
+        field: str | VariableDescriptor,
+        surfaces: list[str],
+        solver=None,
+        **kwargs
+    ):
         """__init__ method of Pathline class."""
+        kwargs.update(
+            {
+                "field": field,
+                "surfaces": surfaces,
+            }
+        )
         super().__init__(solver, **kwargs)
         self.__dict__["_obj"] = Graphics(session=self.solver).Pathlines.create(
             **self.kwargs
@@ -362,12 +562,33 @@ class Pathline(_GraphicsContainer):
 
 
 class XYPlot(_GraphicsContainer):
-    """XYPlot.
+    """XY plot visualization object.
+
+    The ``XYPlot`` class creates a Fluent XY plot of a scalar field evaluated
+    along one or more surfaces. XY plots are typically used to visualize
+    variations of a quantity along a line, surface intersection, or custom
+    geometric curve.
+
+    Parameters
+    ----------
+    surfaces : list of str
+        List of Fluent surfaces on which the XY plot is evaluated. These may be
+        boundary zones, interior surfaces, or user-defined surfaces such as line
+        surfaces, intersections, or extracted curves.
+    y_axis_function : str or VariableDescriptor
+        The scalar field whose values are plotted on the Y-axis of the plot.
+        Examples include ``"temperature"``, ``"pressure"``,
+        ``"velocity-magnitude"``, or any available field in the solver.
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent container or base class
+        determines the session.
+    **kwargs : dict
+        Additional keyword arguments forwarded to
+        ``Graphics(session).XYPlots.create()`` or handled by the base class.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import XYPlot
-
     >>> xy_plot = XYPlot(
     >>>     solver=solver_session,
     >>>     surfaces=["outlet"],
@@ -375,8 +596,21 @@ class XYPlot(_GraphicsContainer):
     >>> )
     """
 
-    def __init__(self, solver=None, local_surfaces_provider=None, **kwargs):
+    def __init__(
+        self,
+        surfaces: list[str],
+        y_axis_function: str | VariableDescriptor,
+        solver=None,
+        local_surfaces_provider=None,
+        **kwargs
+    ):
         """__init__ method of XYPlot class."""
+        kwargs.update(
+            {
+                "y_axis_function": y_axis_function,
+                "surfaces": surfaces,
+            }
+        )
         super().__init__(solver, **kwargs)
         if "y_axis_function" in self.kwargs:
             self.kwargs["y_axis_function"] = _to_field_name_str(
@@ -388,18 +622,42 @@ class XYPlot(_GraphicsContainer):
 
 
 class Monitor(_GraphicsContainer):
-    """Monitor.
+    """Monitor visualization object.
+
+    The ``Monitor`` class provides access to Fluent monitor data for plotting,
+    visualization, or post-processing. Monitors typically track quantities
+    such as residuals, mass flow rates, forces, moments, lift/drag coefficients,
+    or any user-defined monitored variables over iterative or time-dependent
+    calculations.
+
+    Parameters
+    ----------
+    monitor_set_name : str
+        Name of the Fluent monitor set to load. Examples include
+        ``"residual"``, ``"mass-flow"`` or any user-created monitor defined
+        in the Fluent session.
+    solver : FluentSession, optional
+        Active Fluent session. If ``None``, the parent class or container
+        determines the session.
+    **kwargs : dict
+        Additional arguments forwarded to
+        ``Graphics(session).Monitors.create()`` or handled by the base class.
 
     Examples
     --------
     >>> from ansys.fluent.visualization import Monitor
-
-    >>> residual = Monitor(solver=solver_session)
-    >>> residual.monitor_set_name = "residual"
+    >>> residual = Monitor(solver=solver_session, monitor_set_name="residual")
     """
 
-    def __init__(self, solver=None, local_surfaces_provider=None, **kwargs):
+    def __init__(
+        self, monitor_set_name: str, solver=None, local_surfaces_provider=None, **kwargs
+    ):
         """__init__ method of Monitor class."""
+        kwargs.update(
+            {
+                "monitor_set_name": monitor_set_name,
+            }
+        )
         super().__init__(solver, **kwargs)
         self.__dict__["_obj"] = Plots(
             session=self.solver, local_surfaces_provider=Graphics(solver).Surfaces

{ansys_fluent_visualization-0.22.1 → ansys_fluent_visualization-0.23.dev0}/src/ansys/fluent/visualization/renderer.py

@@ -251,7 +251,7 @@ class GraphicsWindow:
            Session ID for refreshing the windows that belong only to this
            session. The default is ``""``, in which case the windows in all
            sessions are refreshed.
-        overlay : bool, Optional
+        overlay : ``bool``, optional
             Overlay graphics over existing graphics.
         """
         if self.window_id: