ansys-fluent-core 0.35.dev1__py3-none-any.whl → 0.36.dev0__py3-none-any.whl

ansys/fluent/core/session_pure_meshing.pyi

@@ -34,6 +34,9 @@ from ansys.fluent.core.generated.datamodel_252.preferences import (
     Root as preferences_root,
 )
 from ansys.fluent.core.generated.datamodel_252.workflow import Root as workflow_root
+from ansys.fluent.core.generated.datamodel_261.meshing_workflow import (
+    Root as meshing_workflow_root,
+)
 from ansys.fluent.core.generated.meshing.tui_252 import main_menu
 
 class PureMeshing:
@@ -45,6 +48,8 @@ class PureMeshing:
     def meshing_utilities(self) -> meshing_utilities_root: ...
     @property
     def workflow(self) -> workflow_root: ...
+    @property
+    def meshing_workflow(self) -> meshing_workflow_root: ...
     def watertight(self): ...
     def fault_tolerant(self): ...
     def two_dimensional_meshing(self): ...

ansys/fluent/core/session_utilities.py

@@ -90,8 +90,9 @@ class SessionBase:
 
         Parameters
         ----------
-        ui_mode : UIMode
-            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+        ui_mode : UIMode or str, optional
+            Defines the user interface mode for Fluent. Accepts either a ``UIMode`` value
+            or a corresponding string such as ``"no_gui"``, ``"hidden_gui"``, or ``"gui"``.
         graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
             Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
             (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
@@ -194,8 +195,9 @@ class SessionBase:
 
         Parameters
         ----------
-        ui_mode : UIMode
-            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+        ui_mode : UIMode or str, optional
+            Defines the user interface mode for Fluent. Accepts either a ``UIMode`` value
+            or a corresponding string such as ``"no_gui"``, ``"hidden_gui"``, or ``"gui"``.
         graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
             Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
             (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
@@ -287,7 +289,8 @@ class SessionBase:
         Parameters
         ----------
         ui_mode : UIMode or str, optional
-            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+            Defines the user interface mode for Fluent. Accepts either a ``UIMode`` value
+            or a corresponding string such as ``"no_gui"``, ``"hidden_gui"``, or ``"gui"``.
         graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
             Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
             (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).

ansys/fluent/core/solver/flobject.py

@@ -80,6 +80,7 @@ from ansys.fluent.core.variable_strategies import (
     FluentFieldDataNamingStrategy as naming_strategy,
 )
 import ansys.units
+from ansys.units import VariableDescriptor
 
 from . import _docstrings
 from ..pyfluent_warnings import warning_for_fluent_dev_version
@@ -676,7 +677,21 @@ class Textual(Property):
             Either str or VariableDescriptor.
         kwargs : Any
             Keyword arguments.
+
+        Raises
+        ------
+        TypeError
+            If state is not a string.
         """
+        allowed_types = (str, VariableDescriptor)
+
+        if not isinstance(state, allowed_types):
+            if self._has_migration_adapter:
+                return self.base_set_state(state=state, **kwargs)
+            raise TypeError(
+                f"Expected state to be {' or '.join(t.__name__ for t in allowed_types)}, "
+                f"got {type(state).__name__}."
+            )
         return self.base_set_state(state=_to_field_name_str(state), **kwargs)
 
 
@@ -2282,6 +2297,10 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
                 )
             cls._allowed_values = allowed_values
 
+        has_migration_adapter = info.get("has-migration-adapter?", False)
+        if has_migration_adapter:
+            cls._has_migration_adapter = True
+
     except Exception:
         print(
             f"Unable to construct class for '{name}' of "

ansys/fluent/core/solver/function/reduction.py

@@ -211,6 +211,8 @@ def _eval_reduction(
         weight = "Weight=" + str(weight)
         locations = str(locations) + ", " + weight
 
+    if hasattr(expr, "definition"):
+        expr = expr.definition()
     expr_str = _expr_to_expr_str(naming_strategy().to_string(expr))
     if condition:
         expr_str = expr_str + ", " + condition

ansys/fluent/core/ui/__init__.py

@@ -0,0 +1,64 @@
+# Copyright (C) 2021 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Public exposure of ui UI for PyFluent."""
+
+
+def in_jupyter():
+    """Checks if the library is being used in a Jupyter environment."""
+    try:
+        from IPython import get_ipython
+
+        return "IPKernelApp" in get_ipython().config
+    except (ImportError, AttributeError):
+        return False
+
+
+if in_jupyter():
+    from ansys.fluent.core.ui.jupyter_ui import (
+        set_auto_refresh,
+        settings_ui,
+    )
+else:
+    from ansys.fluent.core.ui.standalone_web_ui import (  # noqa: F401
+        build_settings_view,
+        set_auto_refresh,
+    )
+
+
+def ui(settings_obj):
+    """PyFluent ui UI wrapper."""
+    if in_jupyter():
+        import IPython
+        from IPython.display import display
+
+        if hasattr(IPython, "get_ipython") and "ZMQInteractiveShell" in str(
+            type(IPython.get_ipython())
+        ):
+            display(settings_ui(settings_obj))
+    else:
+        import panel as pn
+
+        pn.extension()
+        view = build_settings_view(settings_obj)
+        view.servable()
+        pn.serve(view)

ansys/fluent/core/ui/jupyter_ui.py

@@ -0,0 +1,203 @@
+# Copyright (C) 2021 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Render ui UI in Jupyter notebook."""
+
+from ansys.fluent.core.ui.utils import (
+    _parse_path,
+    _render_widget_from_props_generic,
+    _safe_get_properties,
+)
+
+try:
+    import ipywidgets as widgets
+except ModuleNotFoundError as exc:
+    raise ModuleNotFoundError(
+        "Missing dependencies, use 'pip install ansys-fluent-core[ui-jupyter]' to install them."
+    ) from exc
+
+from ansys.fluent.core.solver.flobject import (
+    BaseCommand,
+    Group,
+    NamedObject,
+)
+
+
+def set_auto_refresh():
+    """Refreshes the UI w.r.t. server state for each command execution or parameter invocation."""
+    raise NotImplementedError("This is yet to be implemented in jupyter environment.")
+
+
+def _render_widgets_from_props(settings_obj, label, props):
+    """Render widget using pre-fetched props instead of repeated calls."""
+    return _render_widget_from_props_generic(settings_obj, label, props, widgets)
+
+
+def _param_ui(settings_obj, props):
+    label = props["python_name"].replace("_", " ").capitalize()
+
+    def get_fn():
+        try:
+            return getattr(props["parent"], props["python_name"])
+        except AttributeError:
+            return props["parent"][props["obj_name"]]
+
+    def set_fn(v):
+        return setattr(settings_obj.parent, props["python_name"], v)
+
+    widget = _render_widgets_from_props(get_fn(), label, props)
+    output = widgets.Output()
+    with output:
+        output.clear_output()
+        print(_parse_path(settings_obj))
+    if hasattr(widget, "_is_list_text"):
+        typ, parse_csv = widget._is_list_text
+
+        def commit_text_list(change):
+            if change["name"] == "value":
+                raw = change["new"]
+                vals = (
+                    [typ(v.strip()) for v in raw.split(",") if v.strip()]
+                    if parse_csv
+                    else list(change["new"])
+                )
+                with output:
+                    output.clear_output()
+                    set_fn(vals)
+                    print(f"{_parse_path(settings_obj)} = {vals}")
+
+        widget.observe(commit_text_list)
+    else:
+
+        def on_change(change):
+            if change["name"] == "value":
+                with output:
+                    output.clear_output()
+                    try:
+                        set_fn(change["new"])
+                        print(f"{_parse_path(settings_obj)} = {change['new']}")
+                    except Exception as e:
+                        print(f"Error setting {label}: {e}")
+
+        widget.observe(on_change)
+    return widgets.VBox([widget, output])
+
+
+def _command_ui(func, props):
+    """
+    Renders input widgets for function arguments based on .argument_names()
+    and executes func(**kwargs) on button click.
+    """
+
+    # Get argument names from the function object
+    if not hasattr(func, "argument_names"):
+        return widgets.HTML("Command has no 'argument_names()'.")
+
+    arg_names = func.argument_names
+    arg_widgets = {}
+    controls = []
+    for name in arg_names:
+        child_obj = getattr(func, name)
+        child_props = _safe_get_properties(child_obj)
+        widget = _render_widgets_from_props(child_obj, name, child_props)
+        arg_widgets[name] = widget
+        controls.append(widget)
+
+    # Run button
+    button = widgets.Button(
+        description=f"Run {props['python_name']}", button_style="success"
+    )
+    output = widgets.Output()
+    with output:
+        output.clear_output()
+        print(_parse_path(func))
+
+    def on_click(_):
+        kwargs = {name: w.value for name, w in arg_widgets.items()}
+        with output:
+            output.clear_output()
+            try:
+                func(**kwargs)
+                kwargs_str = "("
+                for k, v in kwargs.items():
+                    if type(v) is str:
+                        if v != "":
+                            kwargs_str += f"{k}='{v}', "
+                    else:
+                        kwargs_str += f"{k}={v}, "
+                print(f"{_parse_path(func)}" + kwargs_str.strip()[:-1] + ")")
+            except Exception as e:
+                print("Error:", e)
+
+    button.on_click(on_click)
+    return widgets.VBox(controls + [button, output])
+
+
+def settings_ui(obj, indent=0):
+    """Render settings objects into ui graphics."""
+    props = _safe_get_properties(obj)
+    if isinstance(obj, (Group, NamedObject)):
+        if isinstance(obj, Group):
+            command_names = obj.get_active_command_names()
+            child_names = obj.get_active_child_names() + command_names
+        else:
+            command_names = obj.command_names
+            child_names = list(obj) + command_names
+        accordions = []
+        for child_name in child_names:
+
+            def lazy_loader(name=child_name, parent=obj, lvl=indent + 1):
+                try:
+                    child_obj = getattr(parent, name)
+                except AttributeError:
+                    child_obj = parent[name]
+                return settings_ui(child_obj, lvl)
+
+            acc = widgets.Accordion(children=[widgets.HTML("Loading...")])
+            if child_name in command_names:
+                acc.set_title(0, f"⚡ {child_name}")
+            else:
+                acc.set_title(0, child_name)
+
+            def on_selected(change, loader=lazy_loader, accordion=acc):
+                if change["name"] == "selected_index" and change["new"] == 0:
+                    if isinstance(accordion.children[0], widgets.HTML):
+                        accordion.children = [loader()]
+
+            acc.observe(on_selected, names="selected_index")
+            accordions.append(acc)
+
+        return widgets.VBox(accordions)
+
+    else:
+        if isinstance(obj, BaseCommand):
+            return (
+                widgets.VBox([_command_ui(obj, props)])
+                if props["is_active"]
+                else widgets.HTML("")
+            )
+        else:
+            return (
+                widgets.VBox([_param_ui(obj, props)])
+                if props["is_active"]
+                else widgets.HTML("")
+            )

ansys/fluent/core/ui/standalone_web_ui.py

@@ -0,0 +1,296 @@
+# Copyright (C) 2021 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Web UI for Fluent settings using Panel with lazy loading and batched property access."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List
+
+try:
+    import panel as pn
+    import param
+except ModuleNotFoundError as exc:
+    raise ModuleNotFoundError(
+        "Missing dependencies, use 'pip install ansys-fluent-core[ui]' to install them."
+    ) from exc
+
+from ansys.fluent.core.solver.flobject import (
+    BaseCommand,
+    Group,
+    NamedObject,
+)
+from ansys.fluent.core.ui.utils import (
+    _parse_path,
+    _render_widget_from_props_generic,
+    _safe_get_properties,
+)
+
+_path_backup_dict = {}
+
+AUTO_REFRESH = False
+
+
+def set_auto_refresh():
+    """Refreshes the UI w.r.t. server state for each command execution or parameter invocation."""
+    global AUTO_REFRESH
+    AUTO_REFRESH = True
+
+
+pn.extension()
+
+# global trigger for refresh (Panel Param depends on it)
+_refresh = pn.state.cache.get("fluent_refresh", None)
+if _refresh is None:
+
+    class Refresh(param.Parameterized):
+        """Refresh."""
+
+        bump = param.Event()
+
+    _refresh = Refresh()
+    pn.state.cache["fluent_refresh"] = _refresh
+
+
+def _render_widget_from_props(
+    settings_obj, label: str, props: Dict[str, Any]
+) -> pn.viewable.Viewable:
+    """Produce a Panel widget from type+props. No backend mutation here."""
+    return _render_widget_from_props_generic(settings_obj, label, props, pn.widgets)
+
+
+def _param_view(settings_obj, props: Dict[str, Any]) -> pn.viewable.Viewable:
+    label = props["python_name"].replace("_", " ").capitalize()
+
+    def get_fn():
+        try:
+            return getattr(props["parent"], props["python_name"])
+        except AttributeError:
+            return props["parent"][props["obj_name"]]
+
+    def set_fn(v):
+        return setattr(settings_obj.parent, props["python_name"], v)
+
+    w = _render_widget_from_props(get_fn(), label, props)
+    obj_apth = _parse_path(settings_obj)
+    if obj_apth in _path_backup_dict:
+        console = pn.pane.Markdown(
+            f"```\n{obj_apth} = {_path_backup_dict[obj_apth]}\n```",
+            sizing_mode="stretch_width",
+        )
+    else:
+        console = pn.pane.Markdown(f"```\n{obj_apth}\n```", sizing_mode="stretch_width")
+
+    # Change handlers
+    if hasattr(w, "_is_list_text"):
+        typ, parse_csv = w._is_list_text
+
+        def _commit_list(event):
+            if event is None:
+                return
+            newv = event.new
+            if parse_csv:
+                raw = newv or ""
+                vals = [typ(v.strip()) for v in raw.split(",") if v.strip()]
+            else:
+                vals = list(newv or [])
+            try:
+                set_fn(vals)
+                console.object = f"```\n{_parse_path(settings_obj)} = {vals}\n```"
+                _path_backup_dict[_parse_path(settings_obj)] = vals
+                if AUTO_REFRESH:
+                    _refresh.bump = True
+            except Exception as e:
+                console.object = f"```\nError setting {label}: {e}\n```"
+
+        w.param.watch(_commit_list, "value", onlychanged=True)
+    else:
+
+        def _commit(event):
+            if event is None:
+                return
+            try:
+                set_fn(event.new)
+                console.object = f"```\n{_parse_path(settings_obj)} = {event.new}\n```"
+                _path_backup_dict[_parse_path(settings_obj)] = event.new
+                if AUTO_REFRESH:
+                    _refresh.bump = True
+            except Exception as e:
+                console.object = f"```\nError setting {label}: {e}\n```"
+
+        w.param.watch(_commit, "value", onlychanged=True)
+
+    return pn.Column(
+        w, console, sizing_mode="stretch_width", margin=(10, 20), align="start"
+    )
+
+
+def _command_view(func, props: Dict[str, Any]) -> pn.viewable.Viewable:
+    """Render command arguments (on demand) and execute only on click."""
+    # Safely fetch argument names (does NOT execute the command)
+    if not hasattr(func, "argument_names"):
+        return pn.pane.HTML("<i>Command has no 'argument_names()'.</i>")
+    arg_names = func.argument_names
+    arg_widgets: Dict[str, Any] = {}
+    controls: List[pn.viewable.Viewable] = []
+
+    # Build argument widgets immediately when this view is created
+    for name in arg_names:
+        param_obj = getattr(func, name)  # safe: this just references the arg handle
+        pprops = _safe_get_properties(param_obj)
+        widget = _render_widget_from_props(param_obj, name, pprops)
+        arg_widgets[name] = widget
+        controls.append(widget)
+
+    btn = pn.widgets.Button(name=f"Run {props['python_name']}", button_type="success")
+    obj_path = _parse_path(func)
+    if obj_path in _path_backup_dict:
+        console = pn.pane.Markdown(
+            f"```\n{_path_backup_dict[obj_path]}\n```", sizing_mode="stretch_width"
+        )
+    else:
+        console = pn.pane.Markdown(f"```\n{obj_path}\n```", sizing_mode="stretch_width")
+
+    def _run(_):
+        kwargs = {n: w.value for n, w in arg_widgets.items()}
+        try:
+            func(**kwargs)  # Executes ONLY here
+            # Render kwargs similarly to your ipywidgets formatter
+            parts = []
+            for k, v in kwargs.items():
+                if isinstance(v, str):
+                    if v != "":
+                        parts.append(f"{k}='{v}'")
+                else:
+                    parts.append(f"{k}={v}")
+            call = f"{_parse_path(func)}({', '.join(parts)})"
+            console.object = f"```\n{call}\n```"
+            _path_backup_dict[_parse_path(func)] = call
+            if AUTO_REFRESH:
+                _refresh.bump = True
+        except Exception as e:
+            console.object = f"```\nError: {e}\n```"
+
+    btn.on_click(_run)
+    return pn.Column(
+        *controls,
+        btn,
+        console,
+        sizing_mode="stretch_width",
+        margin=(10, 20),
+        align="start",
+    )
+
+
+# ---------------------------
+# Lazy accordion (recursive)
+# ---------------------------
+
+
+def _lazy_section(
+    title: str, loader: Callable[[], pn.viewable.Viewable]
+) -> pn.Accordion:
+    """
+    A single-node Accordion whose body is constructed ON FIRST EXPAND.
+    Subsequent expands reuse the existing content.
+    """
+    placeholder = pn.pane.Markdown("*(loading…)*")
+    acc = pn.Accordion((title, placeholder), sizing_mode="stretch_width")
+
+    def _load_content():
+        try:
+            return loader()
+        except Exception as e:
+            return pn.pane.Markdown(f"**Error loading section**: {e}")
+
+    def _maybe_load(event=None):
+        if acc.active and 0 in acc.active:
+            content = _load_content()
+            acc[0] = (title, content)
+
+    # Trigger when first opened
+    acc.param.watch(_maybe_load, "active", onlychanged=True)
+
+    def _on_refresh(event):
+        if acc.active and 0 in acc.active:
+            _maybe_load()
+
+    _refresh.param.watch(_on_refresh, "bump")
+
+    return acc
+
+
+# ---------------------------
+# Main entry (recursive renderer)
+# ---------------------------
+
+
+def _settings_view(obj, indent: int = 0) -> pn.viewable.Viewable:
+    """Recursively build the view for a settings object (lazy children)."""
+    props = _safe_get_properties(obj)
+
+    if isinstance(obj, (Group, NamedObject)):
+        if isinstance(obj, Group):
+            command_names = obj.get_active_command_names()
+            child_names = obj.get_active_child_names() + command_names
+        else:
+            command_names = obj.command_names
+            child_names = list(obj) + command_names
+    else:
+        if isinstance(obj, BaseCommand):
+            return _command_view(obj, props) if props["is_active"] else pn.pane.HTML("")
+        else:
+            return _param_view(obj, props) if props["is_active"] else pn.pane.HTML("")
+
+    sections: List[pn.viewable.Viewable] = []
+
+    for child_name in child_names:
+        # Build a lazy loader that only resolves the child on expand
+        def _loader(name=child_name, parent=obj, lvl=indent + 1):
+            try:
+                child_obj = getattr(parent, name)
+            except AttributeError:
+                child_obj = parent[name]
+            return _settings_view(child_obj, lvl)
+
+        # Each child gets its own one-item accordion (mirrors your ipywidgets UX)
+        if child_name in command_names:
+            display_name = f"⚡ {child_name}"
+        else:
+            display_name = child_name
+        sections.append(_lazy_section(display_name, _loader))
+
+    return pn.Column(
+        *(pn.Column(sec, margin=(5, 0)) for sec in sections),
+        sizing_mode="fixed",
+        margin=(10, 20),
+        align="start",
+        css_classes=["rounded-box"],
+    )
+
+
+def build_settings_view(settings_obj) -> pn.viewable.Viewable:
+    """
+    Public API: pass any Fluent settings object.
+    Internally uses _root to render absolute paths and builds a lazy, web UI.
+    """
+    return _settings_view(settings_obj)