Optional and union types replaced by python actual types

Author: MaxNumerique

src/opengeodeweb_viewer/object/object_methods.py

@@ -1,12 +1,10 @@
 # Standard library imports
 import os
-from typing import Optional, Union
 
 # Third party imports
 import vtk
 
 # Local application imports
-# from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.vtk_protocol import VtkView
 
 
@@ -19,7 +17,7 @@ def registerObject(
         id: str,
         file_name: str,
         reader: vtk.vtkDataReader,
-        filter: Optional[vtk.vtkAlgorithm],
+        filter: vtk.vtkAlgorithm | None,
         mapper: vtk.vtkMapper,
     ) -> None:
         actor = vtk.vtkActor()

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -1,6 +1,6 @@
 # Standard library imports
 import os
-from typing import Optional, Union, cast
+from typing import cast
 
 # Third party imports
 import vtk
@@ -22,7 +22,7 @@ def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
-    def registerMesh(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def registerMesh(self, params: dict[str, str | int | float | bool]) -> None:
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
         data_id = str(params["id"])
         try:
@@ -75,34 +75,30 @@ def registerMesh(self, params: dict[str, Union[str, int, float, bool]]) -> None:
             raise
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
-    def deregisterMesh(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def deregisterMesh(self, params: dict[str, str | int | float | bool]) -> None:
         validate_schema(params, self.mesh_schemas_dict["deregister"], self.mesh_prefix)
         data_id = str(params["id"])
         self.deregisterObject(data_id)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
-    def SetMeshVisibility(
-        self, params: dict[str, Union[str, int, float, bool]]
-    ) -> None:
+    def SetMeshVisibility(self, params: dict[str, str | int | float | bool]) -> 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)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
-    def setMeshOpacity(self, params: dict[str, Union[str, int, float, bool]]) -> None:
+    def setMeshOpacity(self, params: dict[str, str | int | float | bool]) -> None:
         validate_schema(params, self.mesh_schemas_dict["opacity"], self.mesh_prefix)
         data_id, opacity = str(params["id"]), float(params["opacity"])
         self.SetOpacity(data_id, opacity)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
     def setMeshColor(
         self,
-        params: dict[
-            str, Union[str, int, float, bool, dict[str, Union[str, int, float]]]
-        ],
+        params: dict[str, str | int | float | bool | dict[str, str | int | float]],
     ) -> None:
         validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
-        color_dict = cast(dict[str, Union[str, int, float]], params["color"])
+        color_dict = cast(dict[str, str | int | float], params["color"])
         data_id, red, green, blue = (
             str(params["id"]),
             int(color_dict["r"]),
@@ -112,9 +108,7 @@ def setMeshColor(
         self.SetColor(data_id, red, green, blue)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["apply_textures"]["rpc"])
-    def meshApplyTextures(
-        self, params: dict[str, Union[str, list[dict[str, str]]]]
-    ) -> None:
+    def meshApplyTextures(self, params: dict[str, str | list[dict[str, str]]]) -> None:
         validate_schema(
             params, self.mesh_schemas_dict["apply_textures"], self.mesh_prefix
         )

src/opengeodeweb_viewer/vtk_protocol.py

@@ -1,6 +1,6 @@
 # Standard library imports
 import os
-from typing import Optional, Union
+from typing import Union
 
 # Third party imports
 import vtk
@@ -51,7 +51,7 @@ def get_data(self, data_id: str) -> dict[str, Union[str, list[str], None]]:
             print(f"Error fetching data {data_id}: {e}")
             raise
 
-    def get_data_file_path(self, data_id: str, filename: Optional[str] = None) -> str:
+    def get_data_file_path(self, data_id: str, filename: str = None) -> str:
         if filename is None:
             data = self.get_data(data_id)
             viewable_file_name = data["viewable_file_name"]
@@ -83,7 +83,7 @@ def register_object(
         self,
         id: str,
         reader: vtk.vtkAlgorithm,
-        filter: Optional[vtk.vtkAlgorithm],
+        filter: vtk.vtkAlgorithm,
         actor: vtk.vtkActor,
         mapper: vtk.vtkMapper,
         textures: dict[str, Union[str, int, float]],

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, Generator
+from typing import Callable, Generator
 from opengeodeweb_viewer import config
 from opengeodeweb_microservice.database.connection import get_session, init_database
 from opengeodeweb_microservice.database.data import Data
@@ -34,14 +34,10 @@ def __init__(self, log: str) -> None:
     def call(
         self,
         rpc: str,
-        params: Optional[
-            list[
-                Union[
-                    dict[str, Union[str, int, float, bool, dict[str, int], list[str]]],
-                    int,
-                ]
-            ]
-        ] = None,
+        params: (
+            list[dict[str, str | int | float | bool | dict[str, int] | list[str]] | int]
+            | None
+        ) = None,
     ) -> None:
         if params is None:
             params = [{}]
@@ -65,7 +61,7 @@ def print_log(self) -> None:
                 output += line
         print(output)
 
-    def get_response(self) -> Union[bytes, dict[str, object], str]:
+    def get_response(self) -> bytes | dict[str, object] | str:
         response = self.ws.recv()
         if isinstance(response, bytes):
             return response
@@ -217,7 +213,7 @@ def configure_test_environment() -> Generator[None, None, None]:
 @pytest.fixture
 def dataset_factory() -> Callable[..., str]:
     def create_dataset(
-        *, id: str, viewable_file_name: str, geode_object: Optional[str] = None
+        *, id: str, viewable_file_name: str, geode_object: str | None = None
     ) -> str:
         session = get_session()
         if geode_object is None: