mypy 1

Author: MaxNumerique

src/opengeodeweb_viewer/config.py

@@ -33,7 +33,7 @@ def _copy_test_assets(
     valid_exts: set[str],
     uploads_directory: str,
     structure_directory: str,
-):
+) -> None:
     for root, directories, files in os.walk(src_data):
         for directory in directories:
             for test_id in test_ids:

src/opengeodeweb_viewer/object/object_methods.py

@@ -13,7 +13,7 @@ class VtkObjectView(VtkView):
     def __init__(self):
         super().__init__()
 
-    def registerObject(self, id, file_name, reader, filter, mapper):
+    def registerObject(self, id: str, file_name: str, reader, filter, mapper):
         actor = vtk.vtkActor()
         self.register_object(id, reader, filter, actor, mapper, {})
         reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, id, file_name))
@@ -30,15 +30,15 @@ def registerObject(self, id, file_name, reader, filter, mapper):
         renderWindow.Render()
         self.render()
 
-    def deregisterObject(self, data_id):
+    def deregisterObject(self, data_id: str):
         actor = self.get_object(data_id)["actor"]
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
         self.deregister_object(data_id)
         self.render()
 
-    def applyTextures(self, data_id, textures):
+    def applyTextures(self, data_id: str, textures):
         textures_array = []
         images_reader_array = []
 
@@ -57,7 +57,7 @@ def applyTextures(self, data_id, textures):
 
             new_texture = vtk.vtkTexture()
             image_reader = vtk.vtkXMLImageDataReader()
-            texture_path = os.path.join(self.DATA_FOLDER_PATH, data_id, id_texture)
+            texture_path = os.path.join(self.DATA_FOLDER_PATH, data_id: str, id_texture)
             image_reader.SetFileName(texture_path)
 
             shader_texture_name = f"VTK_TEXTURE_UNIT_{index}"
@@ -86,77 +86,77 @@ def applyTextures(self, data_id, textures):
 
         self.render()
 
-    def SetVisibility(self, data_id, visibility):
+    def SetVisibility(self, data_id: str, visibility):
         actor = self.get_object(data_id)["actor"]
         actor.SetVisibility(visibility)
         self.render()
 
-    def SetOpacity(self, data_id, opacity):
+    def SetOpacity(self, data_id: str, opacity):
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetOpacity(opacity)
         self.render()
 
-    def SetColor(self, data_id, red, green, blue):
+    def SetColor(self, data_id: str, red, green, blue):
         mapper = self.get_object(data_id)["mapper"]
         mapper.ScalarVisibilityOff()
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetEdgesVisibility(self, data_id, visibility):
+    def SetEdgesVisibility(self, data_id: str, visibility):
         actor = self.get_object(data_id)["actor"]
         max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "edges":
-            self.SetVisibility(data_id, visibility)
+            self.SetVisibility(data_id: str, visibility)
         else:
             actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
-    def SetEdgesWidth(self, data_id, width):
+    def SetEdgesWidth(self, data_id: str, width):
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetEdgeWidth(width)
         self.render()
 
-    def SetEdgesColor(self, data_id, red, green, blue):
+    def SetEdgesColor(self, data_id: str, red, green, blue):
         actor = self.get_object(data_id)["actor"]
         max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "edges":
-            self.SetColor(data_id, red, green, blue)
+            self.SetColor(data_id: str, red, green, blue)
         else:
             actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetPointsVisibility(self, data_id, visibility):
+    def SetPointsVisibility(self, data_id: str, visibility):
         actor = self.get_object(data_id)["actor"]
         max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "points":
-            self.SetVisibility(data_id, visibility)
+            self.SetVisibility(data_id: str, visibility)
         else:
             actor.GetProperty().SetVertexVisibility(visibility)
             actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
-    def SetPointsSize(self, data_id, size):
+    def SetPointsSize(self, data_id: str, size):
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetPointSize(size)
         self.render()
 
-    def SetPointsColor(self, data_id, red, green, blue):
+    def SetPointsColor(self, data_id: str, red, green, blue):
         actor = self.get_object(data_id)["actor"]
         max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "points":
-            self.SetColor(data_id, red, green, blue)
+            self.SetColor(data_id: str, red, green, blue)
         else:
             actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetBlocksVisibility(self, data_id, block_ids, visibility):
+    def SetBlocksVisibility(self, data_id: str, block_ids, visibility):
         mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockVisibility(block_id, visibility)
         self.render()
 
-    def SetBlocksColor(self, data_id, block_ids, red, green, blue):
+    def SetBlocksColor(self, data_id: str, block_ids, red, green, blue):
         mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -140,7 +140,7 @@ def applyTextures(self, mesh_id: str, textures_info: list):
             actor.SetTexture(texture)
         self.render()
 
-    def displayAttributeOnVertices(self, data_id, name):
+    def displayAttributeOnVertices(self, data_id: str, name: str):
         reader = self.get_object(data_id)["reader"]
         points = reader.GetOutput().GetPointData()
         points.SetActiveScalars(name)

src/opengeodeweb_viewer/rpc/model/model_protocols.py

@@ -20,7 +20,12 @@ class VtkModelView(VtkObjectView):
     def __init__(self):
         super().__init__()
 
-    def _build_model_pipeline(self, file_path: str):
+    def _build_model_pipeline(self, file_path: str) -> tuple[
+        vtk.vtkXMLMultiBlockDataReader,
+        vtk.vtkGeometryFilter,
+        vtk.vtkCompositePolyDataMapper,
+        vtk.vtkActor,
+    ]:
         reader = vtk.vtkXMLMultiBlockDataReader()
         reader.SetFileName(file_path)
         geometry = vtk.vtkGeometryFilter()

src/opengeodeweb_viewer/vtk_protocol.py

@@ -18,7 +18,7 @@ def __init__(self):
         self.DataReader = vtk.vtkXMLPolyDataReader()
         self.ImageReader = vtk.vtkXMLImageDataReader()
 
-    def get_data_base(self):
+    def get_data_base(self) -> dict:
         return self.getSharedObject("db")
 
     def get_data(self, data_id):
@@ -47,12 +47,12 @@ def get_data(self, data_id):
             print(f"Error fetching data {data_id}: {e}")
             raise
 
-    def get_data_file_path(self, data_id, filename=None):
+    def get_data_file_path(self, data_id: str, filename=None) -> str:
         if filename is None:
             data = self.get_data(data_id)
             filename = data["viewable_file_name"]
 
-        return os.path.join(self.DATA_FOLDER_PATH, data_id, filename)
+        return os.path.join(self.DATA_FOLDER_PATH, data_id: str, filename)
 
     def get_renderer(self):
         return self.getSharedObject("renderer")

src/tests/conftest.py

@@ -31,7 +31,7 @@ def __init__(self, log):
         self._init_ws()
         self._drain_initial_messages()
 
-    def call(self, rpc, params=[{}]):
+    def call(self, rpc, params=[{}]) -> None:
         return self.ws.send(
             json.dumps(
                 {
@@ -62,15 +62,15 @@ def get_response(self):
             return response
 
     @staticmethod
-    def _reader_for_file(path: str):
+    def _reader_for_file(path: str) -> vtk.vtkImageReader2:
         lower = path.lower()
         if lower.endswith(".png"):
             return vtk.vtkPNGReader()
         if lower.endswith(".jpg") or lower.endswith(".jpeg"):
             return vtk.vtkJPEGReader()
         return vtk.vtkJPEGReader()
 
-    def images_diff(self, first_image_path, second_image_path):
+    def images_diff(self, first_image_path: str, second_image_path: str) -> float:
         if ".png" in first_image_path:
             first_reader = vtk.vtkPNGReader()
         elif (".jpg" in first_image_path) or (".jpeg" in first_image_path):
@@ -117,7 +117,7 @@ def compare_image(self, nb_messages, filename):
 
             return self.images_diff(test_file_path, path_image) == 0.0
 
-    def _init_ws(self):
+    def _init_ws(self) -> None:
         self.ws.send(
             json.dumps(
                 {
@@ -129,7 +129,9 @@ def _init_ws(self):
         )
         self.call("viewport.image.push.observer.add", [-1])
 
-    def _drain_initial_messages(self, max_messages: int = 5, timeout: float = 4.0):
+    def _drain_initial_messages(
+        self, max_messages: int = 5, timeout: float = 4.0
+    ) -> None:
 
         self.ws.settimeout(timeout)
         for _ in range(max_messages):

src/tests/mesh/points/test_mesh_points_protocols.py

@@ -10,9 +10,9 @@
 # from src.tests.test_data_helpers import create_mesh_data
 
 
-def test_points_visibility(server, dataset_factory):
+def test_points_visibility(server, dataset_factory : callable):
     mesh_id = "123456789"
-    test_register_mesh(server, dataset_factory)
+    test_register_mesh(server, dataset_factory : callable)
 
     server.call(
         VtkMeshPointsView.mesh_points_prefix
@@ -22,9 +22,9 @@ def test_points_visibility(server, dataset_factory):
     assert server.compare_image(3, "mesh/points/visibility.jpeg") == True
 
 
-def test_points_size(server, dataset_factory):
+def test_points_size(server, dataset_factory : callable):
     mesh_id = "123456789"
-    test_points_visibility(server, dataset_factory)
+    test_points_visibility(server, dataset_factory : callable)
 
     server.call(
         VtkMeshPointsView.mesh_points_prefix
@@ -34,9 +34,9 @@ def test_points_size(server, dataset_factory):
     assert server.compare_image(3, "mesh/points/size.jpeg") == True
 
 
-def test_points_color(server, dataset_factory):
+def test_points_color(server, dataset_factory : callable):
     mesh_id = "123456789"
-    test_points_size(server, dataset_factory)
+    test_points_size(server, dataset_factory : callable)
 
     server.call(
         VtkMeshPointsView.mesh_points_prefix
@@ -46,7 +46,7 @@ def test_points_color(server, dataset_factory):
     assert server.compare_image(3, "mesh/points/color.jpeg") == True
 
 
-def test_points_with_point_set(server, dataset_factory):
+def test_points_with_point_set(server, dataset_factory : callable):
     mesh_id = "44556677"
 
     dataset_factory(id=mesh_id, viewable_file_name="points.vtp")

src/tests/model/test_model_protocols.py

@@ -1,7 +1,7 @@
 from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
 
 
-def test_register_model(server, dataset_factory):
+def test_register_model(server, dataset_factory : callable):
 
     dataset_factory(id="123456789", viewable_file_name="CrossSection.vtm")
     server.call(
@@ -11,7 +11,7 @@ def test_register_model(server, dataset_factory):
     assert server.compare_image(3, "model/register.jpeg") == True
 
 
-def test_register_model_cube(server, dataset_factory):
+def test_register_model_cube(server, dataset_factory : callable):
 
     dataset_factory(id="123456789", viewable_file_name="cube.vtm")
     server.call(
@@ -21,9 +21,9 @@ def test_register_model_cube(server, dataset_factory):
     assert server.compare_image(3, "model/cube_register.jpeg") == True
 
 
-def test_visibility_model(server, dataset_factory):
+def test_visibility_model(server, dataset_factory : callable):
 
-    test_register_model(server, dataset_factory)
+    test_register_model(server, dataset_factory : callable)
 
     server.call(
         VtkModelView.model_prefix
@@ -33,9 +33,9 @@ def test_visibility_model(server, dataset_factory):
     assert server.compare_image(3, "model/visibility.jpeg") == True
 
 
-def test_deregister_model(server, dataset_factory):
+def test_deregister_model(server, dataset_factory : callable):
 
-    test_register_model(server, dataset_factory)
+    test_register_model(server, dataset_factory : callable)
 
     server.call(
         VtkModelView.model_prefix