Merge pull request #92 from Geode-solutions/fix/database

database integration. using id from database of OGW-Microservice's da…

Author: BotellaA

.gitignore

@@ -11,4 +11,7 @@ build
 *.egg-info
 .coverage*
 .mypy_cache
+*.db
+tests/data
+
 opengeodeweb_viewer_schemas.json

pyproject.toml

@@ -7,27 +7,25 @@ build-backend = "setuptools.build_meta"
 name = "OpenGeodeWeb-Viewer"
 version = "0.0.0"
 dynamic = ["dependencies"]
-authors = [
-  { name="Geode-solutions", email="[email protected]" },
-]
+authors = [{ name = "Geode-solutions", email = "[email protected]" }]
 description = "OpenGeodeWeb-Viewer is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem"
 readme = "README.md"
 requires-python = ">=3.9"
 classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
 ]
 
 [project.urls]
 "Homepage" = "https://github.com/Geode-solutions/OpenGeodeWeb-Viewer"
 "Bug Tracker" = "https://github.com/Geode-solutions/OpenGeodeWeb-Viewer/issues"
 
 [project.scripts]
-opengeodeweb_viewer = "opengeodeweb_viewer.vtkw_server:run_server"
+opengeodeweb-viewer = "opengeodeweb_viewer.vtkw_server:run_server"
 
 [tool.setuptools.dynamic]
-dependencies = {file = ["requirements.txt"]}
+dependencies = { file = ["requirements.txt"] }
 
 [tool.setuptools.packages.find]
 where = ["src"]

requirements.txt

@@ -61,4 +61,3 @@ wslink==1.12.4
 yarl>=1
     # via aiohttp
 
-opengeodeweb-microservice==1.*,>=1.0.4rc7

src/opengeodeweb_viewer/config.py

@@ -1,20 +1,19 @@
 import os
-import tempfile
 from shutil import copyfile, copytree
 from sys import platform
 
 
-def default_config():
+def default_config() -> None:
     os.environ["DEFAULT_HOST"] = "localhost"
     os.environ["DEFAULT_PORT"] = "1234"
 
 
-def prod_config():
+def prod_config() -> None:
     default_config()
     os.environ["DATA_FOLDER_PATH"] = "/data/"
 
 
-def dev_config():
+def dev_config() -> None:
     default_config()
     if platform == "linux":
         os.environ["DATA_FOLDER_PATH"] = "/temp/OpenGeodeWeb_Data/"
@@ -26,51 +25,39 @@ def dev_config():
         os.mkdir(os.environ.get("DATA_FOLDER_PATH"))
 
 
-def test_config(path):
-    default_config()
-
-    tmp_data_root = tempfile.mkdtemp(prefix="ogw_test_data_")
-    os.environ["DATA_FOLDER_PATH"] = tmp_data_root
-
-    src_data = os.path.join(path, "data")
-    if not os.path.isdir(src_data):
-        raise FileNotFoundError(f"Test data folder not found: {src_data}")
-
-    test_ids = ["123456789", "12345678"]
-    valid_exts = {".vtp", ".vti", ".vtu", ".vtm"}
-
-    project_uuid = "test-project-uuid"
-    data_uuid = "test-data-uuid"
-    uploads_directory = os.path.join(tmp_data_root, project_uuid, "uploads")
-    structure_directory = os.path.join(tmp_data_root, project_uuid, data_uuid)
-
-    for directory in [
-        *test_ids,
-        uploads_directory,
-        structure_directory,
-    ]:  # create directories for tests
-        os.makedirs(
-            (
-                os.path.join(tmp_data_root, directory)
-                if isinstance(directory, str)
-                else directory
-            ),
-            exist_ok=True,
-        )
-
+def _copy_test_assets(
+    src_data: str,
+    tmp_data_root: str,
+    test_ids: list[str],
+    valid_exts: set[str],
+    uploads_directory: str,
+    structure_directory: str,
+) -> None:
     for root, directories, files in os.walk(src_data):
         for directory in directories:
-            dst = os.path.join(tmp_data_root, test_ids[0], directory)
-            copytree(os.path.join(root, directory), dst, dirs_exist_ok=True)
-
+            for test_id in test_ids:
+                dst = os.path.join(tmp_data_root, test_id, directory)
+                copytree(os.path.join(root, directory), dst, dirs_exist_ok=True)
         for file in files:
             if os.path.splitext(file)[1].lower() not in valid_exts:
                 continue
-
             src = os.path.join(root, file)
             for test_id in test_ids:
                 copyfile(src, os.path.join(tmp_data_root, test_id, file))
             copyfile(src, os.path.join(structure_directory, file))
             copyfile(src, os.path.join(uploads_directory, file))
 
-    print(f"\nDATA_FOLDER_PATH set to: {tmp_data_root}", flush=True)
+
+def test_config() -> None:
+    default_config()
+    if "DATA_FOLDER_PATH" not in os.environ:
+        data_path = os.path.join(os.path.dirname(__file__), "..", "..", "tests", "data")
+        os.environ["DATA_FOLDER_PATH"] = os.path.abspath(data_path)
+
+    data_path = os.environ["DATA_FOLDER_PATH"]
+    if not os.path.exists(data_path):
+        os.makedirs(data_path, exist_ok=True)
+
+    db_file = os.path.join(data_path, "project.db")
+    if not os.path.exists(db_file):
+        open(db_file, "a").close()

src/opengeodeweb_viewer/object/object_methods.py

@@ -5,15 +5,21 @@
 import vtk
 
 # Local application imports
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.vtk_protocol import VtkView
 
 
 class VtkObjectView(VtkView):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
-    def registerObject(self, id, file_name, reader, filter, mapper):
+    def registerObject(
+        self,
+        id: str,
+        file_name: str,
+        reader: vtk.vtkDataReader,
+        filter: vtk.vtkAlgorithm | None,
+        mapper: vtk.vtkMapper,
+    ) -> None:
         actor = vtk.vtkActor()
         self.register_object(id, reader, filter, actor, mapper, {})
         reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, id, file_name))
@@ -30,19 +36,19 @@ def registerObject(self, id, file_name, reader, filter, mapper):
         renderWindow.Render()
         self.render()
 
-    def deregisterObject(self, id):
-        actor = self.get_object(id)["actor"]
+    def deregisterObject(self, data_id: str) -> None:
+        actor = self.get_object(data_id)["actor"]
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
-        self.deregister_object(id)
+        self.deregister_object(data_id)
         self.render()
 
-    def applyTextures(self, id, textures):
-        textures_array = []
-        images_reader_array = []
+    def applyTextures(self, data_id: str, textures: list[dict[str, str]]) -> None:
+        textures_array: list[vtk.vtkTexture] = []
+        images_reader_array: list[vtk.vtkXMLImageDataReader] = []
 
-        data = self.get_object(id)
+        data = self.get_object(data_id)
         mapper = data["mapper"]
         actor = data["actor"]
         reader = data["reader"]
@@ -52,14 +58,13 @@ def applyTextures(self, id, textures):
 
         for index, value in enumerate(textures):
             texture_name = value["texture_name"]
-            texture_file_name = value["texture_file_name"]
-            print(f"{texture_name=} {texture_file_name=}", flush=True)
+            id_texture = value["id"]
+            print(f"{texture_name=} {id_texture=}", flush=True)
 
             new_texture = vtk.vtkTexture()
             image_reader = vtk.vtkXMLImageDataReader()
-            image_reader.SetFileName(
-                os.path.join(self.DATA_FOLDER_PATH, id, texture_file_name)
-            )
+            texture_path = self.get_data_file_path(data_id, id_texture)
+            image_reader.SetFileName(texture_path)
 
             shader_texture_name = f"VTK_TEXTURE_UNIT_{index}"
             polydata_mapper.MapDataArrayToMultiTextureAttribute(
@@ -87,83 +92,87 @@ def applyTextures(self, id, textures):
 
         self.render()
 
-    def SetVisibility(self, id, visibility):
-        actor = self.get_object(id)["actor"]
+    def SetVisibility(self, data_id: str, visibility: bool) -> None:
+        actor = self.get_object(data_id)["actor"]
         actor.SetVisibility(visibility)
         self.render()
 
-    def SetOpacity(self, id, opacity):
-        actor = self.get_object(id)["actor"]
+    def SetOpacity(self, data_id: str, opacity: float) -> None:
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetOpacity(opacity)
         self.render()
 
-    def SetColor(self, id, red, green, blue):
-        mapper = self.get_object(id)["mapper"]
+    def SetColor(self, data_id: str, red: int, green: int, blue: int) -> None:
+        mapper = self.get_object(data_id)["mapper"]
         mapper.ScalarVisibilityOff()
-        actor = self.get_object(id)["actor"]
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetEdgesVisibility(self, id, visibility):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetEdgesVisibility(self, data_id: str, visibility: bool) -> None:
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "edges":
-            self.SetVisibility(id, visibility)
+            self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
-    def SetEdgesWidth(self, id, width):
-        actor = self.get_object(id)["actor"]
+    def SetEdgesWidth(self, data_id: str, width: float) -> None:
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetEdgeWidth(width)
         self.render()
 
-    def SetEdgesColor(self, id, red, green, blue):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetEdgesColor(self, data_id: str, red: int, green: int, blue: int) -> None:
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "edges":
-            self.SetColor(id, red, green, blue)
+            self.SetColor(data_id, red, green, blue)
         else:
             actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetPointsVisibility(self, id, visibility):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetPointsVisibility(self, data_id: str, visibility: bool) -> None:
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "points":
-            self.SetVisibility(id, visibility)
+            self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetVertexVisibility(visibility)
         self.render()
 
-    def SetPointsSize(self, id, size):
-        actor = self.get_object(id)["actor"]
+    def SetPointsSize(self, data_id: str, size: float) -> None:
+        actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetPointSize(size)
         self.render()
 
-    def SetPointsColor(self, id, red, green, blue):
-        actor = self.get_object(id)["actor"]
-        max_dimension = self.get_object(id)["max_dimension"]
+    def SetPointsColor(self, data_id: str, red: int, green: int, blue: int) -> None:
+        actor = self.get_object(data_id)["actor"]
+        max_dimension = self.get_object(data_id)["max_dimension"]
         if max_dimension == "points":
-            self.SetColor(id, red, green, blue)
+            self.SetColor(data_id, red, green, blue)
         else:
             actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
         self.render()
 
-    def SetBlocksVisibility(self, id, block_ids, visibility):
-        mapper = self.get_object(id)["mapper"]
+    def SetBlocksVisibility(
+        self, data_id: str, block_ids: list[int], visibility: bool
+    ) -> None:
+        mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockVisibility(block_id, visibility)
         self.render()
 
-    def SetBlocksColor(self, id, block_ids, red, green, blue):
-        mapper = self.get_object(id)["mapper"]
+    def SetBlocksColor(
+        self, data_id: str, block_ids: list[int], red: int, green: int, blue: int
+    ) -> None:
+        mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])
         self.render()
 
-    def clearColors(self, id):
-        db = self.get_object(id)
+    def clearColors(self, data_id: str) -> None:
+        db = self.get_object(data_id)
         mapper = db["mapper"]
         reader = db["reader"]
         reader.GetOutput().GetPointData().SetActiveScalars("")

src/opengeodeweb_viewer/py.typed

@@ -1 +1 @@
-partial
+partial

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -27,20 +27,20 @@ def register(self, params):
             params, self.generic_schemas_dict["register"], self.generic_prefix
         )
         viewer_object = params["viewer_object"]
-        params.pop("viewer_object", None)
+        specific_params = {"id": params["id"]}
         if viewer_object == "mesh":
-            self.mesh_protocols.registerMesh(params)
+            self.mesh_protocols.registerMesh(specific_params)
         elif viewer_object == "model":
-            self.model_protocols.registerModel(params)
+            self.model_protocols.registerModel(specific_params)
 
     @exportRpc(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
     def deregister(self, params):
         validate_schema(
             params, self.generic_schemas_dict["deregister"], self.generic_prefix
         )
         viewer_object = params["viewer_object"]
-        params.pop("viewer_object", None)
+        specific_params = {"id": params["id"]}
         if viewer_object == "mesh":
-            self.mesh_protocols.deregisterMesh(params)
+            self.mesh_protocols.deregisterMesh(specific_params)
         elif viewer_object == "model":
-            self.model_protocols.deregisterModel(params)
+            self.model_protocols.deregisterModel(specific_params)

src/opengeodeweb_viewer/rpc/generic/schemas/register.json

@@ -13,16 +13,11 @@
     "id": {
       "type": "string",
       "minLength": 1
-    },
-    "file_name": {
-      "type": "string",
-      "minLength": 1
     }
   },
   "required": [
     "viewer_object",
-    "id",
-    "file_name"
+    "id"
   ],
   "additionalProperties": false
 }