rpc params

Author: BotellaA

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -27,11 +27,11 @@ def __init__(
         self.model_protocols = model_protocols
 
     @exportRpc(generic_prefix + generic_schemas_dict["register"]["rpc"])
-    def register(self, params):
+    def register(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.generic_schemas_dict["register"], self.generic_prefix
         )
-        params = schemas.Register.from_dict(params)
+        params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         specific_params = {"id": data_id}
         data = self.get_data(data_id)
@@ -42,11 +42,11 @@ def register(self, params):
             self.model_protocols.registerModel(specific_params)
 
     @exportRpc(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
-    def deregister(self, params):
+    def deregister(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.generic_schemas_dict["deregister"], self.generic_prefix
         )
-        params = schemas.Deregister.from_dict(params)
+        params = schemas.Deregister.from_dict(rpc_params)
         data_id = params.id
         specific_params = {"id": data_id}
         data = self.get_data(data_id)

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

@@ -20,26 +20,26 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["visibility"]["rpc"])
-    def setMeshEdgesVisibility(self, params):
+    def setMeshEdgesVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_edges_schemas_dict["visibility"], self.mesh_edges_prefix
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetEdgesVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["color"]["rpc"])
-    def setMeshEdgesColor(self, params):
+    def setMeshEdgesColor(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_edges_schemas_dict["color"], self.mesh_edges_prefix
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_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):
+    def setMeshEdgesWidth(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_edges_schemas_dict["width"], self.mesh_edges_prefix
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_params)
         self.SetEdgesWidth(params.id, params.width)

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -28,10 +28,10 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
-    def registerMesh(self, params: RpcParams) -> None:
+    def registerMesh(self, rpc_params: RpcParams) -> None:
         print(f"{self.mesh_schemas_dict["register"]}", flush=True)
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
-        params = schemas.Register.from_dict(params)
+        params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         try:
             data = self.get_data(data_id)
@@ -70,36 +70,36 @@ def registerMesh(self, params: RpcParams) -> None:
             raise
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
-    def deregisterMesh(self, params: RpcParams) -> None:
+    def deregisterMesh(self, rpc_params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["deregister"], self.mesh_prefix)
-        params = schemas.Deregister.from_dict(params)
+        params = schemas.Deregister.from_dict(rpc_params)
         self.deregisterObject(params.id)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
-    def SetMeshVisibility(self, params: RpcParams) -> None:
+    def SetMeshVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["visibility"], self.mesh_prefix)
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetVisibility(params.id, parmas.visibility)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
-    def setMeshOpacity(self, params: RpcParams) -> None:
+    def setMeshOpacity(self, rpc_params: RpcParams) -> None:
         validate_schema(params, self.mesh_schemas_dict["opacity"], self.mesh_prefix)
-        params = schemas.Opacity.from_dict(params)
+        params = schemas.Opacity.from_dict(rpc_params)
         self.SetOpacity(params.id, params.opacity)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
-    def setMeshColor(self, params: RpcParamsWithColor) -> None:
+    def setMeshColor(self, rpc_params: RpcParamsWithColor) -> None:
         validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_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:
+    def meshApplyTextures(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_schemas_dict["apply_textures"], self.mesh_prefix
         )
-        params = schemas.ApplyTextures.from_dict(params)
+        params = schemas.ApplyTextures.from_dict(rpc_params)
         mesh_id = params.id
         for tex_info in params.textures:
             texture_id = tex_info.id

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

@@ -25,36 +25,36 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["visibility"]["rpc"])
-    def setMeshPointsVisibility(self, params: RpcParams) -> None:
+    def setMeshPointsVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_points_schemas_dict["visibility"], self.mesh_points_prefix
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetPointsVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["color"]["rpc"])
-    def setMeshPointsColor(self, params: RpcParamsWithColor) -> None:
+    def setMeshPointsColor(self, rpc_params: RpcParamsWithColor) -> None:
         validate_schema(
             params, self.mesh_points_schemas_dict["color"], self.mesh_points_prefix
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_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:
+    def setMeshPointsSize(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.mesh_points_schemas_dict["size"], self.mesh_points_prefix
         )
-        params = schemas.Size.from_dict(params)
+        params = schemas.Size.from_dict(rpc_params)
         self.SetPointsSize(params.id, params.size)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["vertex_attribute"]["rpc"])
-    def setMeshPointsVertexAttribute(self, params: RpcParams) -> None:
+    def setMeshPointsVertexAttribute(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_points_schemas_dict["vertex_attribute"],
             self.mesh_points_prefix,
         )
-        params = schemas.VertexAttribute.from_dict(params)
+        params = schemas.VertexAttribute.from_dict(rpc_params)
         self.displayAttributeOnVertices(params.id, pramas.name)

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

@@ -20,46 +20,46 @@ def __init__(self):
         super().__init__()
 
     @exportRpc(mesh_polygons_prefix + mesh_polygons_schemas_dict["visibility"]["rpc"])
-    def setMeshPolygonsVisibility(self, params):
+    def setMeshPolygonsVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polygons_schemas_dict["visibility"],
             self.mesh_polygons_prefix,
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_polygons_prefix + mesh_polygons_schemas_dict["color"]["rpc"])
-    def setMeshPolygonsColor(self, params):
+    def setMeshPolygonsColor(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polygons_schemas_dict["color"],
             self.mesh_polygons_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_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"]
     )
-    def setMeshPolygonsVertexAttribute(self, params):
+    def setMeshPolygonsVertexAttribute(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polygons_schemas_dict["vertex_attribute"],
             self.mesh_polygons_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_params)
         self.displayAttributeOnVertices(params.id, params.name)
 
     @exportRpc(
         mesh_polygons_prefix + mesh_polygons_schemas_dict["polygon_attribute"]["rpc"]
     )
-    def setMeshPolygonsPolygonAttribute(self, params):
+    def setMeshPolygonsPolygonAttribute(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polygons_schemas_dict["polygon_attribute"],
             self.mesh_polygons_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_params)
         self.displayAttributeOnCells(params.id, params.name)

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

@@ -20,47 +20,47 @@ def __init__(self):
         super().__init__()
 
     @exportRpc(mesh_polyhedra_prefix + mesh_polyhedra_schemas_dict["visibility"]["rpc"])
-    def setMeshPolyhedraVisibility(self, params):
+    def setMeshPolyhedraVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polyhedra_schemas_dict["visibility"],
             self.mesh_polyhedra_prefix,
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_polyhedra_prefix + mesh_polyhedra_schemas_dict["color"]["rpc"])
-    def setMeshPolyhedraColor(self, params):
+    def setMeshPolyhedraColor(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polyhedra_schemas_dict["color"],
             self.mesh_polyhedra_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_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"]
     )
-    def setMeshPolyhedraVertexAttribute(self, params):
+    def setMeshPolyhedraVertexAttribute(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polyhedra_schemas_dict["vertex_attribute"],
             self.mesh_polyhedra_prefix,
         )
-        params = schemas.VertexAttribute.from_dict(params)
+        params = schemas.VertexAttribute.from_dict(rpc_params)
         self.displayAttributeOnVertices(params.id, params.name)
 
     @exportRpc(
         mesh_polyhedra_prefix
         + mesh_polyhedra_schemas_dict["polyhedron_attribute"]["rpc"]
     )
-    def setMeshPolyhedraPolyhedronAttribute(self, params):
+    def setMeshPolyhedraPolyhedronAttribute(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.mesh_polyhedra_schemas_dict["polyhedron_attribute"],
             self.mesh_polyhedra_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_params)
         self.displayAttributeOnCells(params.id, params.name)

src/opengeodeweb_viewer/rpc/model/blocks/model_blocks_protocols.py

@@ -20,22 +20,22 @@ def __init__(self):
         super().__init__()
 
     @exportRpc(model_blocks_prefix + model_blocks_schemas_dict["visibility"]["rpc"])
-    def setModelBlocksPolyhedraVisibility(self, params):
+    def setModelBlocksPolyhedraVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.model_blocks_schemas_dict["visibility"],
             self.model_blocks_prefix,
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetBlocksVisibility(params.id, params.block_ids, params.visibility)
 
     @exportRpc(model_blocks_prefix + model_blocks_schemas_dict["color"]["rpc"])
-    def setModelBlocksPolyhedraColor(self, params):
+    def setModelBlocksPolyhedraColor(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.model_blocks_schemas_dict["color"],
             self.model_blocks_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_params)
         color = params.color
         self.SetBlocksColor(params.id, params.block_ids, color.r, color.g, color.b)

src/opengeodeweb_viewer/rpc/model/corners/model_corners_protocols.py

@@ -19,22 +19,22 @@ def __init__(self):
         super().__init__()
 
     @exportRpc(model_corners_prefix + model_corners_schemas_dict["visibility"]["rpc"])
-    def setModelCornersPointsVisibility(self, params):
+    def setModelCornersPointsVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.model_corners_schemas_dict["visibility"],
             self.model_corners_prefix,
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetBlocksVisibility(params.id, params.block_ids, params.visibility)
 
     @exportRpc(model_corners_prefix + model_corners_schemas_dict["color"]["rpc"])
-    def setModelCornersPointsColor(self, params):
+    def setModelCornersPointsColor(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.model_corners_schemas_dict["color"],
             self.model_corners_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_params)
         color = params.color
         self.SetBlocksColor(params.id, params.block_ids, color.r, color.g, color.b)

src/opengeodeweb_viewer/rpc/model/edges/model_edges_protocols.py

@@ -20,9 +20,9 @@ def __init__(self):
         super().__init__()
 
     @exportRpc(model_edges_prefix + model_edges_schemas_dict["visibility"]["rpc"])
-    def setModelEdgesVisibility(self, params):
+    def setModelEdgesVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params, self.model_edges_schemas_dict["visibility"], self.model_edges_prefix
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetEdgesVisibility(params.id, params.visibility)

src/opengeodeweb_viewer/rpc/model/lines/model_lines_protocols.py

@@ -20,22 +20,22 @@ def __init__(self):
         super().__init__()
 
     @exportRpc(model_lines_prefix + model_lines_schemas_dict["visibility"]["rpc"])
-    def setModelLinesEdgesVisibility(self, params):
+    def setModelLinesEdgesVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.model_lines_schemas_dict["visibility"],
             self.model_lines_prefix,
         )
-        params = schemas.Visibility.from_dict(params)
+        params = schemas.Visibility.from_dict(rpc_params)
         self.SetBlocksVisibility(params.id, params.block_ids, params.visibility)
 
     @exportRpc(model_lines_prefix + model_lines_schemas_dict["color"]["rpc"])
-    def setModelLinesEdgesColor(self, params):
+    def setModelLinesEdgesColor(self, rpc_params: RpcParams) -> None:
         validate_schema(
             params,
             self.model_lines_schemas_dict["color"],
             self.model_lines_prefix,
         )
-        params = schemas.Color.from_dict(params)
+        params = schemas.Color.from_dict(rpc_params)
         color = params.color
         self.SetBlocksColor(params.id, params.block_ids, color.r, color.g, color.b)