Any types

Author: MaxNumerique

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -1,6 +1,6 @@
 # Standard library imports
 import os
-from typing import Any
+from typing import Optional, Union
 
 # Third party imports
 import vtk
@@ -22,13 +22,13 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
-    def registerMesh(self, params: dict[str, Any]) -> None:
+    def registerMesh(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
         data_id = params["id"]
         try:
             _ = self.get_data(data_id)
             file_path = self.get_data_file_path(data_id)
-
+            
             reader = vtk.vtkXMLGenericDataObjectReader()
             reader.SetFileName(file_path)
             filter = {}
@@ -75,25 +75,25 @@ def registerMesh(self, params: dict[str, Any]) -> None:
             raise
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
-    def deregisterMesh(self, params: dict[str, Any]) -> None:
+    def deregisterMesh(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(params, self.mesh_schemas_dict["deregister"], self.mesh_prefix)
         data_id = params["id"]
         self.deregisterObject(data_id)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
-    def SetMeshVisibility(self, params: dict[str, Any]) -> None:
+    def SetMeshVisibility(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(params, self.mesh_schemas_dict["visibility"], self.mesh_prefix)
         data_id, visibility = params["id"], params["visibility"]
         self.SetVisibility(data_id, visibility)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
-    def setMeshOpacity(self, params: dict[str, Any]) -> None:
+    def setMeshOpacity(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(params, self.mesh_schemas_dict["opacity"], self.mesh_prefix)
         data_id, opacity = params["id"], params["opacity"]
         self.SetOpacity(data_id, opacity)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
-    def setMeshColor(self, params: dict[str, Any]) -> None:
+    def setMeshColor(self, params: dict[str, Union[str, int, float, bool, dict]]) -> None:
         validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
         data_id, red, green, blue = (
             params["id"],
@@ -104,14 +104,14 @@ def setMeshColor(self, params: dict[str, Any]) -> None:
         self.SetColor(data_id, red, green, blue)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["apply_textures"]["rpc"])
-    def meshApplyTextures(self, params: dict[str, Any]) -> None:
+    def meshApplyTextures(self, params: dict[str, Union[str, list]]) -> None:
         validate_schema(
             params, self.mesh_schemas_dict["apply_textures"], self.mesh_prefix
         )
         data_id, textures_info = params["id"], params["textures"]
         self.applyTextures(data_id, textures_info)
 
-    def applyTextures(self, mesh_id: str, textures_info: list[dict[str, Any]]) -> None:
+    def applyTextures(self, mesh_id: str, textures_info: list[dict[str, str]]) -> None:
         for tex_info in textures_info:
             texture_id = tex_info["id"]
             texture_name = tex_info["texture_name"]

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -1,7 +1,7 @@
 # Standard library imports
 import math
 import os
-from typing import Any
+from typing import Union
 
 # Third party imports
 import vtk
@@ -26,7 +26,7 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["reset_visualization"]["rpc"])
-    def resetVisualization(self, params: dict[str, Any]) -> None:
+    def resetVisualization(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["reset_visualization"], self.viewer_prefix
         )
@@ -81,7 +81,7 @@ def resetVisualization(self, params: dict[str, Any]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["set_background_color"]["rpc"])
-    def setBackgroundColor(self, params: dict[str, Any]) -> None:
+    def setBackgroundColor(self, params: dict[str, Union[str, int, float, bool, dict]]) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["set_background_color"], self.viewer_prefix
         )
@@ -99,7 +99,7 @@ def setBackgroundColor(self, params: dict[str, Any]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["reset_camera"]["rpc"])
-    def resetCamera(self, params: dict[str, Any]) -> None:
+    def resetCamera(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["reset_camera"], self.viewer_prefix
         )
@@ -109,7 +109,7 @@ def resetCamera(self, params: dict[str, Any]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["take_screenshot"]["rpc"])
-    def takeScreenshot(self, params: dict[str, Any]) -> dict[str, Any]:
+    def takeScreenshot(self, params: dict[str, Union[str, int, float, bool]]) -> dict[str, Union[str, bytes]]:
         validate_schema(
             params, self.viewer_schemas_dict["take_screenshot"], self.viewer_prefix
         )
@@ -158,7 +158,7 @@ def takeScreenshot(self, params: dict[str, Any]) -> dict[str, Any]:
         return {"blob": self.addAttachment(file_content)}
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["update_data"]["rpc"])
-    def updateData(self, params: dict[str, Any]) -> None:
+    def updateData(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["update_data"], self.viewer_prefix
         )
@@ -181,7 +181,7 @@ def updateData(self, params: dict[str, Any]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["get_point_position"]["rpc"])
-    def getPointPosition(self, params: dict[str, Any]) -> dict[str, float]:
+    def getPointPosition(self, params: dict[str, Union[str, int, float, bool]]) -> dict[str, float]:
         validate_schema(
             params, self.viewer_schemas_dict["get_point_position"], self.viewer_prefix
         )
@@ -193,7 +193,7 @@ def getPointPosition(self, params: dict[str, Any]) -> dict[str, float]:
         ppos = picker.GetPickPosition()
         return {"x": ppos[0], "y": ppos[1], "z": ppos[2]}
 
-    def computeEpsilon(self, renderer: Any, z: float) -> float:
+    def computeEpsilon(self, renderer: vtk.vtkRenderer, z: float) -> float:
         renderer.SetDisplayPoint(0, 0, z)
         renderer.DisplayToWorld()
         windowLowerLeft = renderer.GetWorldPoint()
@@ -209,7 +209,7 @@ def computeEpsilon(self, renderer: Any, z: float) -> float:
         return math.sqrt(epsilon) * 0.0125
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["picked_ids"]["rpc"])
-    def pickedIds(self, params: dict[str, Any]) -> dict[str, list[str]]:
+    def pickedIds(self, params: dict[str, Union[str, int, float, bool, list]]) -> dict[str, list[str]]:
         validate_schema(
             params, self.viewer_schemas_dict["picked_ids"], self.viewer_prefix
         )
@@ -234,7 +234,7 @@ def pickedIds(self, params: dict[str, Any]) -> dict[str, list[str]]:
         return {"array_ids": array_ids}
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["grid_scale"]["rpc"])
-    def toggleGridScale(self, params: dict[str, Any]) -> None:
+    def toggleGridScale(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["grid_scale"], self.viewer_prefix
         )
@@ -245,15 +245,15 @@ def toggleGridScale(self, params: dict[str, Any]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["axes"]["rpc"])
-    def toggleAxes(self, params: dict[str, Any]) -> None:
+    def toggleAxes(self, params: dict[str, Union[str, int, float, bool]]) -> 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, Any]) -> None:
+    def updateCamera(self, params: dict[str, Union[str, int, float, bool, dict, list]]) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["update_camera"], self.viewer_prefix
         )
@@ -275,14 +275,14 @@ def updateCamera(self, params: dict[str, Any]) -> None:
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["render_now"]["rpc"])
-    def renderNow(self, params: dict[str, Any]) -> None:
+    def renderNow(self, params: dict[str, Union[str, int, float, bool]]) -> 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, Any]) -> None:
+    def setZScaling(self, params: dict[str, Union[str, int, float, bool]]) -> None:
         validate_schema(
             params, self.viewer_schemas_dict["set_z_scaling"], self.viewer_prefix
         )

src/tests/conftest.py

@@ -10,7 +10,7 @@
 import os
 from pathlib import Path
 import xml.etree.ElementTree as ET
-from typing import Callable, Optional, Union, Any, Generator
+from typing import Callable, Optional, Union, Generator
 from opengeodeweb_viewer import config
 from opengeodeweb_microservice.database.connection import get_session, init_database
 from opengeodeweb_microservice.database.data import Data
@@ -31,7 +31,7 @@ def __init__(self, log: str) -> None:
         self._init_ws()
         self._drain_initial_messages()
 
-    def call(self, rpc: str, params: Optional[list[dict[str, Any]]] = None) -> None:
+    def call(self, rpc: str, params: Optional[list[Union[dict, int]]] = None) -> None:
         if params is None:
             params = [{}]
         self.ws.send(
@@ -54,7 +54,7 @@ def print_log(self) -> None:
                 output += line
         print(output)
 
-    def get_response(self) -> Union[bytes, dict[str, Any], str]:
+    def get_response(self) -> Union[bytes, dict[str, Union[str, int, float, bool, list, dict]], str]:
         response = self.ws.recv()
         if isinstance(response, bytes):
             return response
@@ -174,7 +174,7 @@ class Starter(ProcessStarter):
 
 
 @pytest.fixture
-def server(xprocess: Any) -> Generator[ServerMonitor, None, None]:
+def server(xprocess: Union[object, type]) -> Generator[ServerMonitor, None, None]:
     name, Starter, Monitor = HELPER.get_xprocess_args()
     os.environ["PYTHON_ENV"] = "test"
     _, log = xprocess.ensure(name, Starter)