refacto types in utils_functions.py

Author: MaxNumerique

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -8,7 +8,12 @@
 from opengeodeweb_microservice.database.data import Data
 
 # Local application imports
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.utils_functions import (
+    get_schemas_dict,
+    validate_schema,
+    RpcParams,
+    RpcParamsWithColor,
+)
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
 
 
@@ -22,7 +27,7 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
-    def registerMesh(self, params: dict[str, str | int | float | bool]) -> None:
+    def registerMesh(self, params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
         data_id = str(params["id"])
         try:
@@ -62,30 +67,27 @@ def registerMesh(self, params: dict[str, str | int | float | bool]) -> None:
             raise
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
-    def deregisterMesh(self, params: dict[str, str | int | float | bool]) -> None:
+    def deregisterMesh(self, params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["deregister"], self.mesh_prefix)
         data_id = str(params["id"])
         self.deregisterObject(data_id)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
-    def SetMeshVisibility(self, params: dict[str, str | int | float | bool]) -> None:
+    def SetMeshVisibility(self, params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["visibility"], self.mesh_prefix)
         data_id, visibility = str(params["id"]), bool(params["visibility"])
         self.SetVisibility(data_id, visibility)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
-    def setMeshOpacity(self, params: dict[str, str | int | float | bool]) -> None:
+    def setMeshOpacity(self, params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["opacity"], self.mesh_prefix)
         data_id, opacity = str(params["id"]), float(params["opacity"])
         self.SetOpacity(data_id, opacity)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
-    def setMeshColor(
-        self,
-        params: dict[str, str | int | float | bool | dict[str, str | int | float]],
-    ) -> None:
+    def setMeshColor(self, params: RpcParamsWithColor) -> None:
         validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
-        color_dict = cast(dict[str, str | int | float], params["color"])
+        color_dict = cast(dict[str, int], params["color"])
         data_id, red, green, blue = (
             str(params["id"]),
             int(color_dict["r"]),
@@ -95,7 +97,7 @@ def setMeshColor(
         self.SetColor(data_id, red, green, blue)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["apply_textures"]["rpc"])
-    def meshApplyTextures(self, params: dict[str, str | list[dict[str, str]]]) -> None:
+    def meshApplyTextures(self, params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_schemas_dict["apply_textures"], self.mesh_prefix
         )

src/opengeodeweb_viewer/rpc/mesh/points/mesh_points_protocols.py

@@ -1,12 +1,16 @@
 # Standard library imports
 import os
-from typing import Union
 
 # Third party imports
 from wslink import register as exportRpc
 
 # Local application imports
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.utils_functions import (
+    get_schemas_dict,
+    validate_schema,
+    RpcParams,
+    RpcParamsWithColor,
+)
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
 
 
@@ -20,15 +24,15 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["visibility"]["rpc"])
-    def setMeshPointsVisibility(self, params: dict[str, Union[str, bool]]) -> None:
+    def setMeshPointsVisibility(self, params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_points_schemas_dict["visibility"], self.mesh_points_prefix
         )
         id, visibility = params["id"], params["visibility"]
         self.SetPointsVisibility(id, visibility)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["color"]["rpc"])
-    def setMeshPointsColor(self, params: dict[str, Union[str, dict[str, int]]]) -> None:
+    def setMeshPointsColor(self, params: RpcParamsWithColor) -> None:
         validate_schema(
             params, self.mesh_points_schemas_dict["color"], self.mesh_points_prefix
         )
@@ -41,15 +45,15 @@ def setMeshPointsColor(self, params: dict[str, Union[str, dict[str, int]]]) -> N
         self.SetPointsColor(id, red, green, blue)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["size"]["rpc"])
-    def setMeshPointsSize(self, params: dict[str, Union[str, int]]) -> None:
+    def setMeshPointsSize(self, params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_points_schemas_dict["size"], self.mesh_points_prefix
         )
         id, size = params["id"], params["size"]
         self.SetPointsSize(id, size)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["vertex_attribute"]["rpc"])
-    def setMeshPointsVertexAttribute(self, params: dict[str, str]) -> None:
+    def setMeshPointsVertexAttribute(self, params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_points_schemas_dict["vertex_attribute"],

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -1,7 +1,6 @@
 # Standard library imports
 import math
 import os
-from typing import Union
 
 # Third party imports
 import vtk
@@ -12,7 +11,13 @@
 from wslink import register as exportRpc
 
 # Local application imports
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.utils_functions import (
+    get_schemas_dict,
+    validate_schema,
+    RpcParams,
+    RpcParamsWithColor,
+    RpcParamsWithList,
+)
 from opengeodeweb_viewer.vtk_protocol import VtkView
 
 
@@ -26,9 +31,7 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["reset_visualization"]["rpc"])
-    def resetVisualization(
-        self, params: dict[str, Union[str, int, float, bool]]
-    ) -> None:
+    def resetVisualization(self, params: RpcParams) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["reset_visualization"], self.viewer_prefix
         )
@@ -83,12 +86,7 @@ def resetVisualization(
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["set_background_color"]["rpc"])
-    def setBackgroundColor(
-        self,
-        params: dict[
-            str, Union[str, int, float, bool, dict[str, Union[str, int, float]]]
-        ],
-    ) -> None:
+    def setBackgroundColor(self, params: RpcParamsWithColor) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["set_background_color"], self.viewer_prefix
         )
@@ -106,7 +104,7 @@ def setBackgroundColor(
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["reset_camera"]["rpc"])
-    def resetCamera(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def resetCamera(self, params: RpcParams) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["reset_camera"], self.viewer_prefix
         )
@@ -116,9 +114,7 @@ def resetCamera(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["take_screenshot"]["rpc"])
-    def takeScreenshot(
-        self, params: dict[str, Union[str, int, float, bool]]
-    ) -> dict[str, Union[str, bytes]]:
+    def takeScreenshot(self, params: RpcParams) -> dict[str, str | bytes]:
         validate_schema(
             params, self.viewer_schemas_dict["take_screenshot"], self.viewer_prefix
         )
@@ -167,7 +163,7 @@ def takeScreenshot(
         return {"blob": self.addAttachment(file_content)}
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["update_data"]["rpc"])
-    def updateData(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def updateData(self, params: RpcParams) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["update_data"], self.viewer_prefix
         )
@@ -190,9 +186,7 @@ def updateData(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["get_point_position"]["rpc"])
-    def getPointPosition(
-        self, params: dict[str, Union[str, int, float, bool]]
-    ) -> dict[str, float]:
+    def getPointPosition(self, params: RpcParams) -> dict[str, float]:
         validate_schema(
             params, self.viewer_schemas_dict["get_point_position"], self.viewer_prefix
         )
@@ -220,9 +214,7 @@ def computeEpsilon(self, renderer: vtk.vtkRenderer, z: float) -> float:
         return math.sqrt(epsilon) * 0.0125
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["picked_ids"]["rpc"])
-    def pickedIds(
-        self, params: dict[str, Union[str, int, float, bool, list[str]]]
-    ) -> dict[str, list[str]]:
+    def pickedIds(self, params: RpcParamsWithList) -> dict[str, list[str]]:
         validate_schema(
             params, self.viewer_schemas_dict["picked_ids"], self.viewer_prefix
         )
@@ -247,7 +239,7 @@ def pickedIds(
         return {"array_ids": array_ids}
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["grid_scale"]["rpc"])
-    def toggleGridScale(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def toggleGridScale(self, params: RpcParams) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["grid_scale"], self.viewer_prefix
         )
@@ -258,28 +250,15 @@ def toggleGridScale(self, params: dict[str, Union[str, int, float, bool]]) -> No
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["axes"]["rpc"])
-    def toggleAxes(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def toggleAxes(self, params: RpcParams) -> None:
         validate_schema(params, self.viewer_schemas_dict["axes"], self.viewer_prefix)
         id, visibility = "axes", params["visibility"]
         actor = self.get_object(id)["actor"]
         actor.SetVisibility(visibility)
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["update_camera"]["rpc"])
-    def updateCamera(
-        self,
-        params: dict[
-            str,
-            Union[
-                str,
-                int,
-                float,
-                bool,
-                dict[str, Union[str, int, float, list[float]]],
-                list[float],
-            ],
-        ],
-    ) -> None:
+    def updateCamera(self, params: RpcParams) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["update_camera"], self.viewer_prefix
         )
@@ -301,14 +280,14 @@ def updateCamera(
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["render_now"]["rpc"])
-    def renderNow(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def renderNow(self, params: RpcParams) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["render_now"], self.viewer_prefix
         )
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["set_z_scaling"]["rpc"])
-    def setZScaling(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def setZScaling(self, params: RpcParams) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["set_z_scaling"], self.viewer_prefix
         )

src/opengeodeweb_viewer/utils_functions.py

@@ -6,7 +6,16 @@
 import fastjsonschema
 from fastjsonschema import JsonSchemaException
 
-# Local application imports
+type JsonPrimitive = str | int | float | bool
+type JsonValue = JsonPrimitive | dict[str, JsonValue] | list[JsonValue]
+type RpcParams = dict[str, JsonValue]
+
+type ColorDict = dict[str, int]
+type RpcParamsWithColor = dict[str, JsonPrimitive | ColorDict]
+type RpcParamsWithList = dict[str, JsonPrimitive | list[str]]
+type RpcTestParams = list[
+    dict[str, str | int | float | bool | dict[str, int] | list[str]] | int
+] | None
 
 
 def get_schemas_dict(path):
@@ -21,7 +30,7 @@ def get_schemas_dict(path):
     return schemas_dict
 
 
-def validate_schema(params, schema, prefix=""):
+def validate_schema(params: RpcParams, schema: dict, prefix: str = "") -> None:
     print(f"{prefix}{schema['rpc']}", f"{params=}", flush=True)
     try:
         validate = fastjsonschema.compile(schema)

src/tests/conftest.py

@@ -6,14 +6,12 @@
 import vtk
 import os
 import shutil
-import time
-import os
-from pathlib import Path
 import xml.etree.ElementTree as ET
 from typing import Callable, Generator
 from opengeodeweb_viewer import config
 from opengeodeweb_microservice.database.connection import get_session, init_database
 from opengeodeweb_microservice.database.data import Data
+from opengeodeweb_viewer.utils_functions import RpcTestParams
 
 
 class ServerMonitor:
@@ -31,14 +29,7 @@ def __init__(self, log: str) -> None:
         self._init_ws()
         self._drain_initial_messages()
 
-    def call(
-        self,
-        rpc: str,
-        params: (
-            list[dict[str, str | int | float | bool | dict[str, int] | list[str]] | int]
-            | None
-        ) = None,
-    ) -> None:
+    def call(self, rpc: str, params: RpcTestParams = None) -> None:
         if params is None:
             params = [{}]
         self.ws.send(