streamlit-pyvista 0.0.1__tar.gz

streamlit_pyvista-0.0.1/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: streamlit-pyvista
+Version: 0.0.1
+Summary: 
+Author: Maxime Rochat
+Author-email: rochat.max@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiohttp (==3.9.3)
+Requires-Dist: aiosignal (==1.3.1)
+Requires-Dist: altair (==5.2.0)
+Requires-Dist: async-timeout (==4.0.3)
+Requires-Dist: attrs (==23.2.0)
+Requires-Dist: blinker (==1.7.0)
+Requires-Dist: cachetools (==5.3.2)
+Requires-Dist: certifi (==2024.2.2)
+Requires-Dist: charset-normalizer (==3.3.2)
+Requires-Dist: click (==8.1.7)
+Requires-Dist: contourpy (==1.2.0)
+Requires-Dist: cycler (==0.12.1)
+Requires-Dist: fonttools (==4.49.0)
+Requires-Dist: frozenlist (==1.4.1)
+Requires-Dist: gitdb (==4.0.11)
+Requires-Dist: gitpython (==3.1.42)
+Requires-Dist: idna (==3.6)
+Requires-Dist: importlib-metadata (==7.0.1)
+Requires-Dist: jinja2 (==3.1.3)
+Requires-Dist: jsonschema (==4.21.1)
+Requires-Dist: jsonschema-specifications (==2023.12.1)
+Requires-Dist: kiwisolver (==1.4.5)
+Requires-Dist: markdown-it-py (==3.0.0)
+Requires-Dist: markupsafe (==2.1.5)
+Requires-Dist: matplotlib (==3.8.3)
+Requires-Dist: mdurl (==0.1.2)
+Requires-Dist: more-itertools (==10.2.0)
+Requires-Dist: multidict (==6.0.5)
+Requires-Dist: numpy (==1.26.4)
+Requires-Dist: packaging (==23.2)
+Requires-Dist: pandas (==2.2.0)
+Requires-Dist: pillow (==10.2.0)
+Requires-Dist: platformdirs (==4.2.0)
+Requires-Dist: pooch (==1.8.1)
+Requires-Dist: protobuf (==4.25.3)
+Requires-Dist: pyarrow (==15.0.0)
+Requires-Dist: pydeck (==0.8.1b0)
+Requires-Dist: pygments (==2.17.2)
+Requires-Dist: pyparsing (==3.1.1)
+Requires-Dist: pytest (>=8.1.1,<9.0.0)
+Requires-Dist: python-dateutil (==2.8.2)
+Requires-Dist: pytz (==2024.1)
+Requires-Dist: pyvista (==0.43.3)
+Requires-Dist: referencing (==0.33.0)
+Requires-Dist: requests (==2.31.0)
+Requires-Dist: rich (==13.7.0)
+Requires-Dist: rpds-py (==0.18.0)
+Requires-Dist: scooby (==0.9.2)
+Requires-Dist: six (==1.16.0)
+Requires-Dist: smmap (==5.0.1)
+Requires-Dist: streamlit (==1.31.1)
+Requires-Dist: tenacity (==8.2.3)
+Requires-Dist: toml (==0.10.2)
+Requires-Dist: toolz (==0.12.1)
+Requires-Dist: tornado (==6.4)
+Requires-Dist: trame (==3.5.2)
+Requires-Dist: trame-client (==2.16.1)
+Requires-Dist: trame-plotly (==3.0.2)
+Requires-Dist: trame-server (==2.17.2)
+Requires-Dist: trame-vtk (==2.8.5)
+Requires-Dist: trame-vuetify (==2.4.2)
+Requires-Dist: typing-extensions (==4.9.0)
+Requires-Dist: tzdata (==2024.1)
+Requires-Dist: tzlocal (==5.2)
+Requires-Dist: urllib3 (==2.2.1)
+Requires-Dist: validators (==0.22.0)
+Requires-Dist: vtk (==9.3.0)
+Requires-Dist: watchdog (==4.0.0)
+Requires-Dist: wslink (==1.12.4)
+Requires-Dist: yarl (==1.9.4)
+Requires-Dist: zipp (==3.17.0)
+Description-Content-Type: text/markdown
+
+# streamlit-pyvista
+A Streamlit component that allow support for new pyvista viewer backend : Trame. 
+
+
+

streamlit_pyvista-0.0.1/README.md

@@ -0,0 +1,4 @@
+# streamlit-pyvista
+A Streamlit component that allow support for new pyvista viewer backend : Trame. 
+
+

streamlit_pyvista-0.0.1/pyproject.toml

@@ -0,0 +1,93 @@
+[tool.poetry]
+name = "streamlit-pyvista"
+version = "0.0.1"
+description = ""
+authors = ["Maxime Rochat <rochat.max@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+aiohttp = "3.9.3"
+aiosignal = "1.3.1"
+altair = "5.2.0"
+async-timeout = "4.0.3"
+attrs = "23.2.0"
+blinker = "1.7.0"
+cachetools = "5.3.2"
+certifi = "2024.2.2"
+charset-normalizer = "3.3.2"
+click = "8.1.7"
+contourpy = "1.2.0"
+cycler = "0.12.1"
+fonttools = "4.49.0"
+frozenlist = "1.4.1"
+gitdb = "4.0.11"
+gitpython = "3.1.42"
+idna = "3.6"
+importlib-metadata = "7.0.1"
+jinja2 = "3.1.3"
+jsonschema = "4.21.1"
+jsonschema-specifications = "2023.12.1"
+kiwisolver = "1.4.5"
+markdown-it-py = "3.0.0"
+markupsafe = "2.1.5"
+matplotlib = "3.8.3"
+mdurl = "0.1.2"
+more-itertools = "10.2.0"
+multidict = "6.0.5"
+numpy = "1.26.4"
+packaging = "23.2"
+pandas = "2.2.0"
+pillow = "10.2.0"
+platformdirs = "4.2.0"
+pooch = "1.8.1"
+protobuf = "4.25.3"
+pyarrow = "15.0.0"
+pydeck = "0.8.1b0"
+pygments = "2.17.2"
+pyparsing = "3.1.1"
+python-dateutil = "2.8.2"
+pytz = "2024.1"
+pyvista = "0.43.3"
+referencing = "0.33.0"
+requests = "2.31.0"
+rich = "13.7.0"
+rpds-py = "0.18.0"
+scooby = "0.9.2"
+six = "1.16.0"
+smmap = "5.0.1"
+streamlit = "1.31.1"
+tenacity = "8.2.3"
+toml = "0.10.2"
+toolz = "0.12.1"
+tornado = "6.4"
+trame = "3.5.2"
+trame-client = "2.16.1"
+trame-plotly = "3.0.2"
+trame-server = "2.17.2"
+trame-vtk = "2.8.5"
+trame-vuetify = "2.4.2"
+typing-extensions = "4.9.0"
+tzdata = "2024.1"
+tzlocal = "5.2"
+urllib3 = "2.2.1"
+validators = "0.22.0"
+vtk = "9.3.0"
+watchdog = "4.0.0"
+wslink = "1.12.4"
+yarl = "1.9.4"
+zipp = "3.17.0"
+pytest = "^8.1.1"
+
+
+[build-system]
+requires = ["poetry-core", "poetry-dynamic-versioning"]
+build-backend = "poetry_dynamic_versioning.backend"
+
+
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+style = "semver"
+

streamlit_pyvista-0.0.1/streamlit_pyvista/MeshViewerComponent.py

@@ -0,0 +1,83 @@
+import os
+import time
+
+import streamlit as st
+import streamlit.components.v1 as components
+import requests
+import json
+import subprocess
+import threading
+
+class MeshViewerComponent:
+
+    def __init__(self, mesh_path: str = None, sequence_size=1, server_url="http://127.0.0.1:8080"):
+        if not os.path.isabs(mesh_path):
+            mesh_path = os.getcwd() + "/" + mesh_path
+
+        if sequence_size != 1:
+            self.mesh_array = []
+            for i in range(sequence_size):
+                path = mesh_path % i
+                if not os.path.exists(path):
+                    raise FileNotFoundError(f"The file '{path}' does not exist.")
+        elif not os.path.exists(mesh_path):
+            raise FileNotFoundError(f"The file '{mesh_path}' does not exist.")
+
+        self.server_url = server_url
+        self.sequence_size = sequence_size
+        self.mesh_path = mesh_path
+        self.width = 800
+        self.height = 900
+        self.setup_server()
+        self.set_mesh()
+
+    def is_server_alive(self):
+        try:
+            requests.get(self.server_url)
+            return True
+        except Exception as e:
+            return False
+
+    def setup_server(self):
+        if self.is_server_alive():
+            return
+
+
+        print("Started new server")
+        trame_viewer_thread = threading.Thread(target=self.run_trame_viewer)
+        # Start the thread
+        trame_viewer_thread.start()
+
+
+    def run_trame_viewer(self):
+        try:
+            pass
+            subprocess.run(["python3", os.path.dirname(os.path.abspath(__file__)) + "/trame_viewer.py"], check=True) #stdout=subprocess.DEVNULL,  stderr=subprocess.DEVNULL,
+        except subprocess.CalledProcessError as e:
+            print("Error:", e)
+
+    def wait_for_server_alive(self):
+        init_time = time.time()
+        while not self.is_server_alive():
+            if time.time() - init_time >= 3:
+                init_time = time.time()
+                self.setup_server()
+
+    def set_mesh(self):
+        self.wait_for_server_alive()
+        url = self.server_url + "/select_mesh"
+        data = {
+            "mesh_path": self.mesh_path,
+            "nbr_frames": self.sequence_size,
+            "width": self.width,
+            "height": self.height
+                }
+        print(f"MESH LOADED IS {self.mesh_path}")
+        headers = {"Content-Type": "application/json"}
+        print("send request")
+        response = requests.get(url, data=json.dumps(data), headers=headers, timeout=2000)
+        resp_body = response.json()
+        if "request_space" in resp_body:
+            self.height = resp_body["request_space"]
+    def show(self):
+        components.iframe("http://127.0.0.1:8080/index.html", width=self.width, height=self.height) # , scrolling=True

streamlit_pyvista-0.0.1/streamlit_pyvista/__init__.py

@@ -0,0 +1,2 @@
+from .trame_viewer import MeshViewer
+from .MeshViewerComponent import MeshViewerComponent

streamlit_pyvista-0.0.1/streamlit_pyvista/trame_viewer.py

@@ -0,0 +1,479 @@
+import pyvista as pv
+from pyvista import examples
+from pyvista.trame.ui import plotter_ui
+from trame.app import get_server
+from trame.ui.vuetify3 import VAppLayout
+from trame.widgets import vuetify3 as vuetify
+from trame.widgets import html
+from aiohttp import web
+from trame.decorators import TrameApp, change, controller
+
+
+import os
+import numpy as np
+import time, threading
+import asyncio
+from abc import ABC, abstractmethod
+
+from typing import Dict
+
+
+
+@TrameApp()
+class MeshViewer:
+
+    def __init__(self, mesh=None, plotter=None, server=None):
+
+        pv.OFF_SCREEN = True
+        self.scalar_bar_exist = None
+        if server is None:
+            self.server = get_server()
+        else:
+            self.server = server
+        self.slider_playing = False
+        self.path = None
+
+        self.mesh = None
+        self.clean_mesh = None
+
+        self.style = {
+            "background-color": "black",
+            "font-color": "white"
+        }
+
+        self.pl = self.setup_pl()
+
+        setattr(self, "on_server_bind", self.server.controller.add("on_server_bind")(self.on_server_bind))
+
+        # self.replace_mesh(mesh)
+        self.my_routes = [
+            web.get("/select_mesh", self.change_mesh),
+        ]
+
+        self.setup_state()
+
+        self.setup_timer()
+
+        self.loop = asyncio.get_event_loop()
+
+        self.mesh_array = None
+
+        self.state.options = [None]
+        self.state.options_warp = ["None", "A", "B"]
+
+        self.actor = None
+        self.width = 800
+        self.height = 900
+        self.ui = self.build_ui()
+
+
+
+    def setup_pl(self) -> pv.Plotter:
+        pl = pv.Plotter()
+        pl.background_color = self.style["background-color"]
+        pl.theme.font.color = self.style["font-color"]
+        self.bounds_scalar = None
+        self.scalar_bar_exist = False
+        self.scalar_bar_mapper = None
+        return pl
+
+    def setup_state(self):
+        self.state.is_full_screen = False
+        self.state.mesh_representation = self.state.options[0] if self.state.options is not None else None
+        self.state.warped_field = None
+
+        self.state.warp_input = 0
+        self.state.wireframe_on = True
+        self.state.slider_value = 0
+        self.state.play_pause_icon = "mdi-play"
+        self.prev_bar_repr = self.state.mesh_representation
+        self.prev_wrap = "0"
+
+    def setup_timer(self):
+        self.timeout = 0.25
+        self.timer = threading.Thread(target=self.timer_callback)
+        self.sequence_bounds = [0, 70]
+
+    @change("mesh_representation")
+    def update_mesh_representation(self, mesh_representation, **kwargs):
+
+        if self.mesh is not None and self.mesh.active_scalars is not None:
+            self.pl.remove_scalar_bar()
+
+        self.prev_bar_repr = mesh_representation
+
+        if mesh_representation == "None":
+            self.state.mesh_representation = None
+        for i in range(self.sequence_bounds[1]):
+            if self.mesh_array is not None:
+                self.mesh_array[i].set_active_scalars(self.state.mesh_representation)
+        # self.replace_mesh(self.mesh)
+
+        self.update_mesh_from_index(self.state.slider_value)
+        self.update_warp_input()
+        self.ui = self.build_ui()
+        # self.update_mesh_from_index(1)
+
+    @change("warp_input")
+    def update_warp_input(self, **kwargs):
+
+        try:
+            new_warp = float(self.state.warp_input)
+
+            dim = self.mesh.point_data.get_array(self.state.mesh_representation).ndim  # 1 if scalar, 2 if vector
+            if dim == 1:
+                new_pyvista_mesh = self.clean_mesh.warp_by_scalar(self.state.warped_field,
+                                                                  factor=new_warp)
+            else:
+                new_pyvista_mesh = self.clean_mesh.warp_by_vector(self.state.warped_field,
+                                                                  factor=new_warp)
+
+            self.prev_wrap = self.state.warp_input
+            self.replace_mesh(new_pyvista_mesh)
+
+
+        except ValueError as e:
+            print(e)
+            pass
+        except Exception as e:
+            print(e)
+        finally:
+            return
+
+    @change("warped_field")
+    def update_warped_field(self, warped_field, **kwargs):
+        if warped_field is None or warped_field == "None":
+            return
+        self.update_warp_input(warped_field= warped_field)
+
+    @change("wireframe_on")
+    def update_wireframe_on(self, **kwargs):
+        self.replace_mesh(self.mesh)
+
+    @change("slider_value")
+    def slider_value_change(self, slider_value, **kwargs):
+        self.update_mesh_from_index(int(slider_value))
+        self.state.warp_input = 0
+
+    @property
+    def state(self):
+        return self.server.state
+
+    @property
+    def ctrl(self):
+        return self.server.controller
+
+    def timer_callback(self):
+
+        print(self.slider_playing)
+        while self.slider_playing and self.server.running:
+            self.state.slider_value = (self.state.slider_value + 1) % self.sequence_bounds[1]
+
+            # self.update_mesh_from_index(self.state.slider_value)
+
+            self.loop.call_soon_threadsafe(self.update_mesh_from_index, self.state.slider_value)
+            self.loop.call_soon_threadsafe(self.server.force_state_push, "slider_value")
+            time.sleep(0.25)
+
+        self.timer = threading.Thread(target=self.timer_callback)
+
+    def update_mesh_from_index(self, idx):
+        if self.mesh_array is not None:
+            self.clean_mesh = self.mesh_array[idx]
+            self.replace_mesh(self.mesh_array[idx])
+            # self.update_warp_input()
+
+    def handle_new_mesh(self, mesh_path, seq_len):
+        self.mesh_array = []
+        if seq_len == 1:
+            if not os.path.exists(mesh_path):
+                print(f"Error, the file {mesh_path} does not exist")
+                return
+            self.mesh_array.append(pv.read(mesh_path))
+            return
+
+        for i in range(self.sequence_bounds[1]):
+            path = self.path % i
+            if not os.path.exists(path):
+                print(f"Error, the file {path} does not exist")
+                return
+            self.mesh_array.append(pv.read(path))
+
+    async def change_mesh(self, request):
+
+        request_body: Dict[str, str] = await request.json()
+        self.path = request_body.get("mesh_path", None)
+        self.width = request_body.get("width", self.width)
+        self.height = request_body.get("height", self.height)
+        self.sequence_bounds[1] = request_body.get("nbr_frames", self.sequence_bounds[1])
+        print(f"PATH RECEIVED IS {self.path}")
+        if self.path is None:
+            print("Error : No filepath found in the change mesh request")
+            return
+
+        self.handle_new_mesh(self.path, self.sequence_bounds[1])
+
+        self.state.mesh_representation = None
+        self.replace_mesh(self.mesh_array[0])
+
+        self.state.options = self.mesh_array[0].array_names.copy()
+        self.state.options.insert(0, "None")
+        self.state.options_warp = self.mesh_array[0].array_names.copy()
+        self.state.options_warp.insert(0, "None")
+
+        self.computes_bounds_scalar()
+        self.update_ui()
+        response_body = {}
+        if self.height - self.estimate_controller_height()[1] < 700:
+            response_body["request_space"] = 1.65 * self.height
+
+        self.pl.reset_camera()
+        return web.json_response(response_body, status=200)
+
+    def compute_field_interval(self, field=None):
+        if field is None:
+            field = self.state.mesh_representation
+        if field is None or field == "None":
+            field = self.state.options[1]
+        max_bound = -np.inf
+        min_bound = np.inf
+        for i in range(self.sequence_bounds[1]):
+            l_max = self.mesh_array[i].get_array(field).max()
+            l_min = self.mesh_array[i].get_array(field).min()
+            if l_max > max_bound:
+                max_bound = l_max
+            if l_min < min_bound:
+                min_bound = l_min
+        return min_bound, max_bound
+
+    def show_scalar_bar(self, field=None):
+        if self.mesh_array is None:
+            return
+        if field is None:
+            field = self.state.mesh_representation
+        if field is None:
+            return
+
+        if self.bounds_scalar is None:
+            self.computes_bounds_scalar()
+
+        bounds = self.bounds_scalar.get(field, None)
+        if bounds is not None:
+            self.pl.mapper.lookup_table.SetTableRange(bounds[0], bounds[1])
+            self.pl.add_scalar_bar(self.state.mesh_representation)
+
+        return self.pl.mapper
+
+    def computes_bounds_scalar(self):
+        if self.state.options is None:
+            return
+
+        # store bounds and mapper for all the fields available except "None" which is the first one of the options array
+        self.bounds_scalar = {}
+
+        for field in self.state.options[1:]:
+            self.bounds_scalar[field] = self.compute_field_interval(field)
+        print(self.bounds_scalar)
+
+    def replace_mesh(self, new_mesh):
+        if new_mesh is None:
+            return
+
+        # set custom style
+        kwargs_plot = {}
+        if self.state.wireframe_on:
+            kwargs_plot["style"] = "wireframe"
+
+        # update mesh and set its active scalar field, as well as adding the scalar bar
+        self.mesh = new_mesh
+
+        # Set the active scalar and create it's scalar bar if it does not exist
+        self.mesh.set_active_scalars(self.state.mesh_representation)
+
+        self.pl.mapper = self.show_scalar_bar(self.state.mesh_representation)
+
+        # Replace actor with the new mesh (automatically update the actor because they have the same name)
+        self.actor = self.pl.add_mesh(self.mesh, style="wireframe" if self.state.wireframe_on else None,
+                                      name="displayed_mesh", show_scalar_bar=True,
+                                      scalar_bar_args={"mapper": self.pl.mapper})
+
+    def start_server(self):
+        try:
+            self.server.start()
+        except KeyboardInterrupt:
+            # Stop the thread that manage the play of the mesh sequence
+            self.timer.join()  # Wait for the timer thread to finish
+
+    def update_ui(self):
+        if self.mesh is not None and self.mesh.active_scalars is not None:
+            self.pl.remove_scalar_bar()
+        self.ui = self.build_ui()
+
+    def option_dropdown(self):
+        return vuetify.VSelect(
+            v_model=("mesh_representation", "None"),
+            items=("options", self.state.options),
+            label="Representation",
+            hide_details=True,
+            dense=True,
+            outlined=True,
+            classes="pt-1",
+        )
+
+    def build_slider(self):
+        row = html.Div(style='display:flex;justify-content:center;align-content:center;gap:20px;')
+        with row:
+            with vuetify.VBtn(
+                    icon=True,
+                    click=self.play_button
+            ):
+                vuetify.VIcon("{{ play_pause_icon }}")
+            html.Div("{{ slider_value }}")
+            vuetify.VSlider(
+                ref="slider",
+                label="",
+                min=self.sequence_bounds[0],
+                max=self.sequence_bounds[1] - 1,
+                v_model=("slider_value", 8),
+                step=1
+            )
+        return row
+
+    @controller.set("play_button")
+    def play_button(self):
+        if self.sequence_bounds[1] <= 1:
+            print("Impossible to start the sequence since it's a unique mesh")
+            return
+
+        # Invert the state of the play button and if it's playing start the timer updating frame at a fixed interval
+        self.slider_playing = not self.slider_playing
+        if self.slider_playing and not self.timer.is_alive():
+            self.state.play_pause_icon = "mdi-pause"
+
+            self.timer.start()
+        else:
+            self.state.play_pause_icon = "mdi-play"
+        self.update_ui()
+
+
+    def build_warp_option(self):
+        return vuetify.VSelect(
+                v_model=("warped_field"),
+                items=("options_warp", self.state.options_warp),
+                label="Warped Field",
+                hide_details=True,
+                dense=True,
+                outlined=True,
+                classes="pt-1",
+            )
+
+    def build_warper(self):
+        warper = vuetify.VCol(cols="6")
+        with warper:
+            print("array of options ------------------")
+            print(self.state.options_warp)
+            options = ['None', 'U', 'V', 'A', 'E', 'dE']
+            options = self.state.options_warp
+            print(options)
+            self.build_warp_option()
+
+            # self.option_dropdown(field_linked="warped_field", options=self.state.options)
+            if self.state.mesh_representation != "None" and self.state.mesh_representation is not None:
+
+                html.Input(type="number", label="warp",
+                           v_model=("warp_input", 0.0),
+                           ref=f"warp-input",
+                           step="1"
+                           )
+
+        return warper
+
+    def build_mesh_control_layout(self):
+        layout = html.Div()
+        with (layout):
+            with vuetify.VRow(dense=True):
+                with vuetify.VCol(cols="6"):
+                    if self.state.options[0] is not None:
+                        self.option_dropdown()
+                self.build_warper()
+            vuetify.VCheckbox(v_model=("wireframe_on",), label="Wireframe on")
+            if self.sequence_bounds[1] != 1:
+                self.build_slider()
+
+            with vuetify.VBtn(click=self.request_full, style="position: absolute; bottom:25px; right:25px;", icon=True):
+                vuetify.VIcon("mdi-fullscreen" if not self.state.is_full_screen else "mdi-fullscreen-exit")
+        return layout
+
+    def estimate_controller_height(self):
+        if self.mesh_array is not None and self.state.mesh_representation is not None:
+            ndim = self.mesh_array[0].get_array(self.state.mesh_representation).shape[1]
+            return 30 * ndim, 9 * 30
+        return 0.2 * self.height, 9 * 30
+
+    def build_ui(self):
+        control_height = self.estimate_controller_height()[0]
+        if not self.state.is_full_screen:
+            plotter_height = self.height - control_height
+            plotter_height = f"{plotter_height}px"
+            width = f"{self.width}px"
+
+
+        else:
+            plotter_height = "100%"
+            width = "100%"
+
+        print(self.height)
+
+        with VAppLayout(self.server) as layout:
+            with layout.root:
+                with html.Div(
+                        style=f"height: {self.height}px ;width:{width}"):  # add the following arg: style="height: 100vh; width:100vw" to have the plotter taking all screen
+                    with html.Div(ref="container", style=f"height:{plotter_height};padding: 0;"):
+                        with vuetify.VCol(style=f"height:{plotter_height};padding: 0;"):
+                            if self.slider_playing:
+                                plotter_ui(self.pl, default_server_rendering=True, mode="server",
+                                           style="width: 100%; height:100%;background-color: black;")
+                            else:
+                                plotter_ui(self.pl, default_server_rendering=True,
+                                           style="width: 100%; height:100%;background-color: black;")
+
+                    with vuetify.VCol(style=f"height:{control_height}px;padding: 0;width:100%;"):
+                        self.build_mesh_control_layout()
+            return layout
+
+    def on_server_bind(self, wslink_server):
+        wslink_server.app.add_routes(self.my_routes)
+
+    def request_full(self):
+        self.server.js_call("container", "requestFullscreen")
+        # if not self.state.is_full_screen:
+        #     self.server.js_call("container", "requestFullscreen")
+        # else:
+        #     self.server.js_call("", "exitFullscreen()")
+        self.state.is_full_screen = not self.state.is_full_screen
+        self.update_ui()
+
+
+class Component(ABC):
+    def __init__(self, state, ctrl):
+        self.supported_handler = ["change"]
+        self.state = state
+        self.ctrl = ctrl
+
+
+    # add corresponding decorator to fucntion (change or set)
+    @abstractmethod
+    def handler(self, new_value, **kwargs):
+        pass
+
+    @abstractmethod
+    def render(self):
+        pass
+
+
+
+if __name__ == "__main__":
+    mv = MeshViewer()
+    mv.start_server()
+    # sm = ServerManager()
+    # sm.start_server()