wip

Author: BotellaA

.vscode/settings.json

@@ -8,6 +8,6 @@
         "--config-file=mypy.ini"
     ],
     "mypy-type-checker.interpreter": [
-        "${workspaceFolder}/venv/bin/python"
+        "${workspaceFolder}/../../.venv/bin/python"
     ]
 }

src/opengeodeweb_back/geode_functions.py

@@ -2,68 +2,35 @@
 import os
 
 # Third party imports
-import opengeode_geosciences as og_gs  # type: ignore
-import opengeode as og  # type: ignore
+import opengeode_geosciences as og_gs
+import opengeode as og 
 import werkzeug
 import flask
 from typing import Any
 
 # Local application imports
-from .geode_objects import geode_objects_dict
+from .geode_objects import geode_objects,GeodeType, GeodeObject, to_geode_type
 from . import utils_functions
 from opengeodeweb_microservice.database.data import Data
 from opengeodeweb_microservice.database.connection import get_session
 
-
-def geode_object_value(geode_object: str):
-    return geode_objects_dict()[geode_object]
-
-
-def geode_object_class(geode_object: str):
-    return geode_object_value(geode_object)["class"]
-
-
-def input_factory(geode_object: str):
-    return geode_object_value(geode_object)["input_factory"]
-
-
-def output_factory(geode_object: str):
-    return geode_object_value(geode_object)["output_factory"]
-
-
-def additional_files(geode_object: str, file_absolute_path: str):
-    return geode_object_value(geode_object)["additional_files"](file_absolute_path)
-
-
-def is_loadable(geode_object: str, file_absolute_path: str) -> float:
-    percentage = geode_object_value(geode_object)["is_loadable"](file_absolute_path)
-    return percentage.value()
-
-
-def object_priority(geode_object: str, file_absolute_path: str) -> int:
-    return geode_object_value(geode_object)["object_priority"](file_absolute_path)
-
-
-def load(geode_object: str, file_absolute_path: str):
-    return geode_object_value(geode_object)["load"](file_absolute_path)
-
-
-def data_file_path(data_id: str, filename: str = "") -> str:
+def data_file_path(data_id: str, filename: str | None) -> str:
     data_folder_path = flask.current_app.config["DATA_FOLDER_PATH"]
-    if filename:
-        return os.path.join(data_folder_path, data_id, filename)
-    return os.path.join(data_folder_path, data_id)
+    data_path = os.path.join(data_folder_path, data_id)
+    if filename is not None:
+        return os.path.join(data_path, filename)
+    return data_path
 
 
-def load_data(data_id: str) -> Any:
+def load_data(data_id: str) -> GeodeObject:
     data_entry = Data.get(data_id)
     if not data_entry:
         flask.abort(404, f"Data with id {data_id} not found")
 
     file_absolute_path = data_file_path(data_id, data_entry.native_file_name)
     print("Loading file: ", file_absolute_path)
     print("File exists: ", os.path.exists(file_absolute_path))
-    return load(data_entry.geode_object, file_absolute_path)
+    return geode_objects[to_geode_type(data_entry.geode_object)].load(file_absolute_path)
 
 
 def get_data_info(data_id: str) -> Data:
@@ -79,114 +46,54 @@ def upload_file_path(filename: str) -> str:
     return os.path.abspath(os.path.join(upload_folder, secure_filename))
 
 
-def is_saveable(geode_object: str, data, filename: str):
-    return geode_object_value(geode_object)["is_saveable"](data, filename)
-
-
-def save(geode_object: str, data, folder_absolute_path: str, filename: str):
-    return geode_object_value(geode_object)["save"](
-        data, os.path.join(folder_absolute_path, filename)
-    )
-
-
-def create_builder(geode_object: str, data):
-    return geode_object_value(geode_object)["builder"](data)
+# def assign_crs(geode_type: GeodeType, data, crs_name: str, info):
+#     builder = create_builder(geode_object, data)
+#     geode_objects[geode_type].["crs"]["assign"](data, builder, crs_name, info)
 
 
-def assign_crs(geode_object: str, data, crs_name: str, info):
-    builder = create_builder(geode_object, data)
-    geode_object_value(geode_object)["crs"]["assign"](data, builder, crs_name, info)
+# def convert_crs(geode_type: GeodeType, data, crs_name: str, info):
+#     builder = create_builder(geode_object, data)
+#     geode_objects[geode_type].["crs"]["convert"](data, builder, crs_name, info)
 
 
-def convert_crs(geode_object: str, data, crs_name: str, info):
-    builder = create_builder(geode_object, data)
-    geode_object_value(geode_object)["crs"]["convert"](data, builder, crs_name, info)
+# def create_crs(
+#     geode_type: GeodeType,
+#     data,
+#     name: str,
+#     input_coordiante_system,
+#     output_coordiante_system,
+# ):
+#     builder = create_builder(geode_object, data)
+#     geode_objects[geode_type].["crs"]["create"](
+#         data, builder, name, input_coordiante_system, output_coordiante_system
+#     )
 
 
-def create_crs(
-    geode_object: str,
-    data,
-    name: str,
-    input_coordiante_system,
-    output_coordiante_system,
-):
-    builder = create_builder(geode_object, data)
-    geode_object_value(geode_object)["crs"]["create"](
-        data, builder, name, input_coordiante_system, output_coordiante_system
-    )
-
-
-def get_object_type(geode_object: str):
-    return geode_object_value(geode_object)["object_type"]
-
-
-def get_elements(geode_object: str):
-    return geode_object_value(geode_object)["elements"]
-
-
-def is_3D(geode_object: str):
-    return geode_object_value(geode_object)["is_3D"]
-
-
-def is_viewable(geode_object: str):
-    return geode_object_value(geode_object)["is_viewable"]
-
-
-def inspect(geode_object: str, data):
-    return geode_object_value(geode_object)["inspector"](data)
-
-
-def save_viewable(geode_object: str, data, folder_absolute_path: str, id: str):
-    return geode_object_value(geode_object)["save_viewable"](
-        data, os.path.join(folder_absolute_path, id)
-    )
-
-
-def save_light_viewable(geode_object: str, data, folder_absolute_path: str, id: str):
-    return geode_object_value(geode_object)["save_light_viewable"](
-        data, os.path.join(folder_absolute_path, id)
-    )
-
-
-def geode_object_input_extensions(geode_object: str):
-    geode_object_input_list_creators = input_factory(geode_object).list_creators()
-    geode_object_input_list_creators.sort()
-    return geode_object_input_list_creators
-
-
-def geode_object_output_extensions(geode_object: str):
-    geode_object_output_list_creators = output_factory(geode_object).list_creators()
-    geode_object_output_list_creators.sort()
-    return geode_object_output_list_creators
-
-
-def filter_geode_objects(key: str = None):
-    geode_objects_filtered_list = []
-    for geode_object, value in geode_objects_dict().items():
+def filter_geode_objects(key: str | None = None)-> list[GeodeType]:
+    filtered_geode_objects = []
+    for geode_object, value in geode_objects.items():
         if key != None and key != "":
             if key in value:
                 if type(value[key]) == bool:
-                    geode_objects_filtered_list.append(geode_object)
+                    filtered_geode_objects.append(geode_object)
                 else:
-                    geode_objects_filtered_list.append(geode_object)
+                    filtered_geode_objects.append(geode_object)
         else:
-            geode_objects_filtered_list.append(geode_object)
-    geode_objects_filtered_list.sort()
-    return geode_objects_filtered_list
+            filtered_geode_objects.append(geode_object)
+    filtered_geode_objects.sort()
+    return filtered_geode_objects
 
 
 def list_input_extensions(key: str | None = None) -> list[str]:
     extensions_list = []
-    geode_objects_filtered_list = filter_geode_objects(key)
-    for geode_object in geode_objects_filtered_list:
+    for geode_object in filter_geode_objects(key):
         extensions_list += geode_object_input_extensions(geode_object)
-
     extensions_list = list(set(extensions_list))
     extensions_list.sort()
     return extensions_list
 
 
-def has_creator(geode_object: str, extension: str):
+def has_creator(geode_type: GeodeType, extension: str):
     return input_factory(geode_object).has_creator(extension)
 
 
@@ -210,7 +117,7 @@ def list_geode_objects(
     return return_dict
 
 
-def geode_objects_output_extensions(geode_object: str, data):
+def geode_objects_output_extensions(geode_type: GeodeType, data):
     geode_objects_output_extensions_dict = {}
     output_extensions = geode_object_output_extensions(geode_object)
     extensions_dict = {}
@@ -219,8 +126,8 @@ def geode_objects_output_extensions(geode_object: str, data):
         extensions_dict[output_extension] = {"is_saveable": bool_is_saveable}
     geode_objects_output_extensions_dict[geode_object] = extensions_dict
 
-    if "parent" in geode_object_value(geode_object).keys():
-        parent_geode_object = geode_object_value(geode_object)["parent"]
+    if "parent" in geode_objects[geode_type]..keys():
+        parent_geode_object = geode_objects[geode_type].["parent"]
         geode_objects_output_extensions_dict.update(
             geode_objects_output_extensions(parent_geode_object, data)
         )
@@ -253,14 +160,14 @@ def get_inspector_children(obj):
     return new_object
 
 
-def geographic_coordinate_systems(geode_object: str):
+def geographic_coordinate_systems(geode_type: GeodeType):
     if is_3D(geode_object):
         return og_gs.GeographicCoordinateSystem3D.geographic_coordinate_systems()
     else:
         return og_gs.GeographicCoordinateSystem2D.geographic_coordinate_systems()
 
 
-def geographic_coordinate_systems_info(geode_object: str, crs):
+def geographic_coordinate_systems_info(geode_type: GeodeType, crs):
     if is_3D(geode_object):
         return og_gs.GeographicCoordinateSystemInfo3D(
             crs["authority"], crs["code"], crs["name"]
@@ -271,7 +178,7 @@ def geographic_coordinate_systems_info(geode_object: str, crs):
         )
 
 
-def coordinate_system(geode_object: str, coordinate_system):
+def coordinate_system(geode_type: GeodeType, coordinate_system):
     return og.CoordinateSystem2D(
         [
             og.Vector2D(
@@ -295,18 +202,18 @@ def coordinate_system(geode_object: str, coordinate_system):
     )
 
 
-def assign_geographic_coordinate_system_info(geode_object: str, data, input_crs):
+def assign_geographic_coordinate_system_info(geode_type: GeodeType, data, input_crs):
     info = geographic_coordinate_systems_info(geode_object, input_crs)
     assign_crs(geode_object, data, input_crs["name"], info)
 
 
-def convert_geographic_coordinate_system_info(geode_object: str, data, output_crs):
+def convert_geographic_coordinate_system_info(geode_type: GeodeType, data, output_crs):
     info = geographic_coordinate_systems_info(geode_object, output_crs)
     convert_crs(geode_object, data, output_crs["name"], info)
 
 
 def create_coordinate_system(
-    geode_object: str, data, name, input_coordinate_points, output_coordinate_points
+    geode_type: GeodeType, data, name, input_coordinate_points, output_coordinate_points
 ):
     input_coordiante_system = coordinate_system(geode_object, input_coordinate_points)
     output_coordiante_system = coordinate_system(geode_object, output_coordinate_points)