fix(Schemas): add types

Author: BotellaA

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -14,8 +14,10 @@
 
 
 class VtkGenericView(VtkView):
-    prefix = "opengeodeweb_viewer.generic."
-    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+    generic_prefix = "opengeodeweb_viewer.generic."
+    generic_schemas_dict = get_schemas_dict(
+        os.path.join(os.path.dirname(__file__), "schemas")
+    )
 
     def __init__(
         self, mesh_protocols: VtkMeshView, model_protocols: VtkModelView
@@ -24,9 +26,11 @@ def __init__(
         self.mesh_protocols = mesh_protocols
         self.model_protocols = model_protocols
 
-    @exportRpc(prefix + schemas_dict["register"]["rpc"])
+    @exportRpc(generic_prefix + generic_schemas_dict["register"]["rpc"])
     def register(self, params):
-        validate_schema(params, self.schemas_dict["register"], self.prefix)
+        validate_schema(
+            params, self.generic_schemas_dict["register"], self.generic_prefix
+        )
         params = schemas.Register.from_dict(params)
         data_id = params.id
         specific_params = {"id": data_id}
@@ -37,9 +41,11 @@ def register(self, params):
         elif viewer_object == "model":
             self.model_protocols.registerModel(specific_params)
 
-    @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
+    @exportRpc(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
     def deregister(self, params):
-        validate_schema(params, self.schemas_dict["deregister"], self.prefix)
+        validate_schema(
+            params, self.generic_schemas_dict["deregister"], self.generic_prefix
+        )
         params = schemas.Deregister.from_dict(params)
         data_id = params.id
         specific_params = {"id": data_id}

src/opengeodeweb_viewer/rpc/mesh/edges/mesh_edges_protocols.py

@@ -7,6 +7,7 @@
 # Local application imports
 from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+from . import schemas
 
 
 class VtkMeshEdgesView(VtkMeshView):
@@ -15,34 +16,30 @@ class VtkMeshEdgesView(VtkMeshView):
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["visibility"]["rpc"])
     def setMeshEdgesVisibility(self, params):
         validate_schema(
             params, self.mesh_edges_schemas_dict["visibility"], self.mesh_edges_prefix
         )
-        id, visibility = params["id"], params["visibility"]
-        self.SetEdgesVisibility(id, visibility)
+        params = schemas.Visibility.from_dict(params)
+        self.SetEdgesVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["color"]["rpc"])
     def setMeshEdgesColor(self, params):
         validate_schema(
             params, self.mesh_edges_schemas_dict["color"], self.mesh_edges_prefix
         )
-        id, red, green, blue = (
-            params["id"],
-            params["color"]["r"],
-            params["color"]["g"],
-            params["color"]["b"],
-        )
-        self.SetEdgesColor(id, red, green, blue)
+        params = schemas.Color.from_dict(params)
+        color = params.color
+        self.SetEdgesColor(params.id, color.r, color.g, color.b)
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["width"]["rpc"])
     def setMeshEdgesWidth(self, params):
         validate_schema(
             params, self.mesh_edges_schemas_dict["width"], self.mesh_edges_prefix
         )
-        id, size = params["id"], params["width"]
-        self.SetEdgesWidth(id, width)
+        params = schemas.Color.from_dict(params)
+        self.SetEdgesWidth(params.id, params.width)

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -15,6 +15,7 @@
     RpcParamsWithColor,
 )
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
+from . import schemas
 
 
 class VtkMeshView(VtkObjectView):
@@ -30,7 +31,8 @@ def __init__(self) -> None:
     def registerMesh(self, params: RpcParams) -> None:
         print(f"{self.mesh_schemas_dict["register"]}", flush=True)
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
-        data_id = str(params["id"])
+        params = schemas.Register.from_dict(params)
+        data_id = params.id
         try:
             data = self.get_data(data_id)
             file_name = str(data["viewable_file_name"])
@@ -70,52 +72,41 @@ def registerMesh(self, params: RpcParams) -> None:
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
     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)
+        params = schemas.Deregister.from_dict(params)
+        self.deregisterObject(params.id)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
     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)
+        params = schemas.Visibility.from_dict(params)
+        self.SetVisibility(params.id, parmas.visibility)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
     def setMeshOpacity(self, params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["opacity"], self.mesh_prefix)
-        data_id, opacity = str(params["id"]), float(
-            cast(int | float, params["opacity"])
-        )
-        self.SetOpacity(data_id, opacity)
+        params = schemas.Opacity.from_dict(params)
+        self.SetOpacity(params.id, params.opacity)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
     def setMeshColor(self, params: RpcParamsWithColor) -> None:
         validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
-        color_dict = cast(dict[str, int], params["color"])
-        data_id, red, green, blue = (
-            str(params["id"]),
-            int(color_dict["r"]),
-            int(color_dict["g"]),
-            int(color_dict["b"]),
-        )
-        self.SetColor(data_id, red, green, blue)
+        params = schemas.Color.from_dict(params)
+        color = params.color
+        self.SetColor(params.id, color.r, color.g, color.b)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["apply_textures"]["rpc"])
     def meshApplyTextures(self, params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_schemas_dict["apply_textures"], self.mesh_prefix
         )
-        data_id = str(params["id"])
-        textures_info = cast(list[dict[str, str]], params["textures"])
-        self.applyTextures(data_id, textures_info)
-
-    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"]
+        params = schemas.ApplyTextures.from_dict(params)
+        mesh_id = params.id
+        for tex_info in params.textures:
+            texture_id = tex_info.id
             texture_data = Data.get(texture_id)
-            if not texture_data:
+            if texture_data is None:
                 continue
-            texture_file = str(texture_data.viewable_file_name)
+            texture_file = texture_data.viewable_file_name
             if not texture_file.lower().endswith(".vti"):
                 continue
             texture_file_path = self.get_data_file_path(texture_id)
@@ -130,7 +121,7 @@ def applyTextures(self, mesh_id: str, textures_info: list[dict[str, str]]) -> No
             point_data = output.GetPointData()
             for i in range(point_data.GetNumberOfArrays()):
                 array = point_data.GetArray(i)
-                if array.GetName() == texture_name:
+                if array.GetName() == tex_info.texture_name:
                     point_data.SetTCoords(array)
                     break
             actor = cast(vtk.vtkActor, self.get_object(mesh_id)["actor"])

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

@@ -12,6 +12,7 @@
     RpcParamsWithColor,
 )
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+from . import schemas
 
 
 class VtkMeshPointsView(VtkMeshView):
@@ -28,29 +29,25 @@ 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)
+        params = schemas.Visibility.from_dict(params)
+        self.SetPointsVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["color"]["rpc"])
     def setMeshPointsColor(self, params: RpcParamsWithColor) -> None:
         validate_schema(
             params, self.mesh_points_schemas_dict["color"], self.mesh_points_prefix
         )
-        id, red, green, blue = (
-            params["id"],
-            params["color"]["r"],
-            params["color"]["g"],
-            params["color"]["b"],
-        )
-        self.SetPointsColor(id, red, green, blue)
+        params = schemas.Color.from_dict(params)
+        color = params.color
+        self.SetPointsColor(params.id, color.r, color.g, color.b)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["size"]["rpc"])
     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)
+        params = schemas.Size.from_dict(params)
+        self.SetPointsSize(params.id, params.size)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["vertex_attribute"]["rpc"])
     def setMeshPointsVertexAttribute(self, params: RpcParams) -> None:
@@ -59,5 +56,5 @@ def setMeshPointsVertexAttribute(self, params: RpcParams) -> None:
             self.mesh_points_schemas_dict["vertex_attribute"],
             self.mesh_points_prefix,
         )
-        id, name = params["id"], params["name"]
-        self.displayAttributeOnVertices(id, name)
+        params = schemas.VertexAttribute.from_dict(params)
+        self.displayAttributeOnVertices(params.id, pramas.name)

src/opengeodeweb_viewer/rpc/mesh/polygons/polygons_protocols.py

@@ -7,6 +7,7 @@
 # Local application imports
 from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+from . import schemas
 
 
 class VtkMeshPolygonsView(VtkMeshView):
@@ -25,8 +26,8 @@ def setMeshPolygonsVisibility(self, params):
             self.mesh_polygons_schemas_dict["visibility"],
             self.mesh_polygons_prefix,
         )
-        id, visibility = params["id"], params["visibility"]
-        self.SetVisibility(id, visibility)
+        params = schemas.Visibility.from_dict(params)
+        self.SetVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_polygons_prefix + mesh_polygons_schemas_dict["color"]["rpc"])
     def setMeshPolygonsColor(self, params):
@@ -35,13 +36,9 @@ def setMeshPolygonsColor(self, params):
             self.mesh_polygons_schemas_dict["color"],
             self.mesh_polygons_prefix,
         )
-        id, red, green, blue = (
-            params["id"],
-            params["color"]["r"],
-            params["color"]["g"],
-            params["color"]["b"],
-        )
-        self.SetColor(id, red, green, blue)
+        params = schemas.Color.from_dict(params)
+        color = params.color
+        self.SetColor(params.id, color.r, color.g, color.b)
 
     @exportRpc(
         mesh_polygons_prefix + mesh_polygons_schemas_dict["vertex_attribute"]["rpc"]
@@ -52,8 +49,8 @@ def setMeshPolygonsVertexAttribute(self, params):
             self.mesh_polygons_schemas_dict["vertex_attribute"],
             self.mesh_polygons_prefix,
         )
-        id, name = params["id"], params["name"]
-        self.displayAttributeOnVertices(id, name)
+        params = schemas.Color.from_dict(params)
+        self.displayAttributeOnVertices(params.id, params.name)
 
     @exportRpc(
         mesh_polygons_prefix + mesh_polygons_schemas_dict["polygon_attribute"]["rpc"]
@@ -64,5 +61,5 @@ def setMeshPolygonsPolygonAttribute(self, params):
             self.mesh_polygons_schemas_dict["polygon_attribute"],
             self.mesh_polygons_prefix,
         )
-        id, name = params["id"], params["name"]
-        self.displayAttributeOnCells(id, name)
+        params = schemas.Color.from_dict(params)
+        self.displayAttributeOnCells(params.id, params.name)

src/opengeodeweb_viewer/rpc/mesh/polyhedra/polyhedra_protocols.py

@@ -7,6 +7,7 @@
 # Local application imports
 from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+from . import schemas
 
 
 class VtkMeshPolyhedraView(VtkMeshView):
@@ -25,8 +26,8 @@ def setMeshPolyhedraVisibility(self, params):
             self.mesh_polyhedra_schemas_dict["visibility"],
             self.mesh_polyhedra_prefix,
         )
-        id, visibility = params["id"], params["visibility"]
-        self.SetVisibility(id, visibility)
+        params = schemas.Visibility.from_dict(params)
+        self.SetVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_polyhedra_prefix + mesh_polyhedra_schemas_dict["color"]["rpc"])
     def setMeshPolyhedraColor(self, params):
@@ -35,13 +36,9 @@ def setMeshPolyhedraColor(self, params):
             self.mesh_polyhedra_schemas_dict["color"],
             self.mesh_polyhedra_prefix,
         )
-        id, red, green, blue = (
-            params["id"],
-            params["color"]["r"],
-            params["color"]["g"],
-            params["color"]["b"],
-        )
-        self.SetColor(id, red, green, blue)
+        params = schemas.Color.from_dict(params)
+        color = params.color
+        self.SetColor(params.id, color.r, color.g, color.b)
 
     @exportRpc(
         mesh_polyhedra_prefix + mesh_polyhedra_schemas_dict["vertex_attribute"]["rpc"]
@@ -52,8 +49,8 @@ def setMeshPolyhedraVertexAttribute(self, params):
             self.mesh_polyhedra_schemas_dict["vertex_attribute"],
             self.mesh_polyhedra_prefix,
         )
-        id, name = params["id"], params["name"]
-        self.displayAttributeOnVertices(id, name)
+        params = schemas.VertexAttribute.from_dict(params)
+        self.displayAttributeOnVertices(params.id, params.name)
 
     @exportRpc(
         mesh_polyhedra_prefix
@@ -65,5 +62,5 @@ def setMeshPolyhedraPolyhedronAttribute(self, params):
             self.mesh_polyhedra_schemas_dict["polyhedron_attribute"],
             self.mesh_polyhedra_prefix,
         )
-        id, name = params["id"], params["name"]
-        self.displayAttributeOnCells(id, name)
+        params = schemas.Color.from_dict(params)
+        self.displayAttributeOnCells(params.id, params.name)

src/opengeodeweb_viewer/rpc/mesh/schemas/__init__.py

@@ -2,4 +2,5 @@
 from .register import *
 from .opacity import *
 from .deregister import *
+from .color import *
 from .apply_textures import *