type mesh_protocols and test_viewer_protocols

Author: MaxNumerique

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -1,5 +1,6 @@
 # Standard library imports
 import os
+from typing import Any, Dict, List
 
 # Third party imports
 import vtk
@@ -17,11 +18,11 @@ class VtkMeshView(VtkObjectView):
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
-    def registerMesh(self, params):
+    def registerMesh(self, params: Dict[str, Any]) -> None:
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
         data_id = params["id"]
         try:
@@ -78,25 +79,25 @@ def registerMesh(self, params):
             raise
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
-    def deregisterMesh(self, params):
+    def deregisterMesh(self, params: Dict[str, Any]) -> 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):
+    def SetMeshVisibility(self, params: Dict[str, Any]) -> 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):
+    def setMeshOpacity(self, params: Dict[str, Any]) -> 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):
+    def setMeshColor(self, params: Dict[str, Any]) -> None:
         validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
         data_id, red, green, blue = (
             params["id"],
@@ -107,14 +108,14 @@ def setMeshColor(self, params):
         self.SetColor(data_id, red, green, blue)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["apply_textures"]["rpc"])
-    def meshApplyTextures(self, params):
+    def meshApplyTextures(self, params: Dict[str, Any]) -> 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):
+    def applyTextures(self, mesh_id: str, textures_info: List[Dict[str, Any]]) -> None:
         for tex_info in textures_info:
             texture_id = tex_info["id"]
             texture_name = tex_info["texture_name"]
@@ -140,7 +141,7 @@ def applyTextures(self, mesh_id: str, textures_info: list):
             actor.SetTexture(texture)
         self.render()
 
-    def displayAttributeOnVertices(self, data_id: str, name: str):
+    def displayAttributeOnVertices(self, data_id: str, name: str) -> None:
         reader = self.get_object(data_id)["reader"]
         points = reader.GetOutput().GetPointData()
         points.SetActiveScalars(name)
@@ -150,7 +151,7 @@ def displayAttributeOnVertices(self, data_id: str, name: str):
         mapper.SetScalarRange(points.GetScalars().GetRange())
         self.render()
 
-    def displayAttributeOnCells(self, data_id, name):
+    def displayAttributeOnCells(self, data_id: str, name: str) -> None:
         reader = self.get_object(data_id)["reader"]
         cells = reader.GetOutput().GetCellData()
         cells.SetActiveScalars(name)

src/tests/test_viewer_protocols.py

@@ -1,35 +1,35 @@
 # Standard library imports
 import os
+from typing import Callable
 
 # Third party imports
-import pytest
 
 # Local application imports
 from opengeodeweb_viewer.rpc.viewer.viewer_protocols import VtkViewerView
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
 
-
 # Local application imports
 from .mesh.test_mesh_protocols import test_register_mesh
+from .conftest import ServerMonitor
 
 
-def test_reset_visualization(server):
+def test_reset_visualization(server: ServerMonitor) -> None:
     server.call(
         VtkViewerView.viewer_prefix
         + VtkViewerView.viewer_schemas_dict["reset_visualization"]["rpc"]
     )
     assert server.compare_image(3, "viewer/reset_visualization.jpeg") == True
 
 
-def test_reset_camera(server):
+def test_reset_camera(server: ServerMonitor) -> None:
     server.call(
         VtkViewerView.viewer_prefix
         + VtkViewerView.viewer_schemas_dict["reset_camera"]["rpc"]
     )
     assert server.compare_image(3, "viewer/reset_camera.jpeg") == True
 
 
-def test_set_viewer_background_color(server):
+def test_set_viewer_background_color(server: ServerMonitor) -> None:
     server.call(
         VtkViewerView.viewer_prefix
         + VtkViewerView.viewer_schemas_dict["set_background_color"]["rpc"],
@@ -38,7 +38,9 @@ def test_set_viewer_background_color(server):
     assert server.compare_image(3, "viewer/set_background_color.jpeg") == True
 
 
-def test_get_point_position(server, dataset_factory):
+def test_get_point_position(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
     test_register_mesh(server, dataset_factory)
 
     server.call(
@@ -65,7 +67,9 @@ def test_get_point_position(server, dataset_factory):
     assert type(z) is float
 
 
-def test_take_screenshot(server, dataset_factory):
+def test_take_screenshot(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
     test_register_mesh(server, dataset_factory)
 
     # Take a screenshot with background jpg
@@ -154,7 +158,9 @@ def test_take_screenshot(server, dataset_factory):
     assert server.images_diff(first_image_path, second_image_path) == 0.0
 
 
-def test_picked_ids(server, dataset_factory):
+def test_picked_ids(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
 
     test_register_mesh(server, dataset_factory)
 
@@ -182,7 +188,9 @@ def test_picked_ids(server, dataset_factory):
     assert isinstance(array_ids, list)
 
 
-def test_grid_scale(server, dataset_factory):
+def test_grid_scale(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
     data_id = "123456789"
     dataset_factory(id=data_id, viewable_file_name="hat.vtp")
     server.call(
@@ -204,7 +212,9 @@ def test_grid_scale(server, dataset_factory):
     assert server.compare_image(3, "viewer/grid_scale_on.jpeg") == True
 
 
-def test_axes(server, dataset_factory):
+def test_axes(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
 
     test_reset_visualization(server)
 
@@ -216,7 +226,9 @@ def test_axes(server, dataset_factory):
     assert server.compare_image(3, "viewer/axes_off.jpeg") == True
 
 
-def test_update_camera(server, dataset_factory):
+def test_update_camera(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
     test_register_mesh(server, dataset_factory)
 
     camera_options = {
@@ -239,7 +251,9 @@ def test_update_camera(server, dataset_factory):
     assert server.compare_image(3, "viewer/update_camera.jpeg") == True
 
 
-def test_render_now(server, dataset_factory):
+def test_render_now(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
     test_register_mesh(server, dataset_factory)
 
     camera_options = {
@@ -269,7 +283,9 @@ def test_render_now(server, dataset_factory):
     assert server.compare_image(3, "viewer/render_now.jpeg") == True
 
 
-def test_set_z_scaling(server, dataset_factory):
+def test_set_z_scaling(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
     dataset_factory(id="123456789", viewable_file_name="polygon_attribute.vtp")
 
     server.call(
@@ -312,7 +328,9 @@ def test_set_z_scaling(server, dataset_factory):
     assert server.compare_image(3, "viewer/set_z_scaling.jpeg") == True
 
 
-def test_combined_scaling_and_grid(server, dataset_factory):
+def test_combined_scaling_and_grid(
+    server: ServerMonitor, dataset_factory: Callable[..., str]
+) -> None:
     server.call(
         VtkViewerView.viewer_prefix
         + VtkViewerView.viewer_schemas_dict["reset_visualization"]["rpc"],