OpenGeodeWeb-Back 5.9.1__py3-none-any.whl → 5.10.0__py3-none-any.whl

opengeodeweb_back/app_config.py

@@ -4,6 +4,9 @@ import time
 
 # Third party imports
 # Local application imports
+from opengeodeweb_microservice.database.connection import get_database
+
+DATABASE_FILENAME = "project.db"
 
 
 class Config(object):
@@ -15,6 +18,7 @@ class Config(object):
     REQUEST_COUNTER = 0
     LAST_REQUEST_TIME = time.time()
     LAST_PING_TIME = time.time()
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
 
 
 class ProdConfig(Config):
@@ -22,7 +26,10 @@ class ProdConfig(Config):
     ORIGINS = ""
     MINUTES_BEFORE_TIMEOUT = "1"
     SECONDS_BETWEEN_SHUTDOWNS = "10"
-    DATA_FOLDER_PATH = "/data/"
+    DATA_FOLDER_PATH = "/data"
+    SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.abspath(
+        os.path.join(DATA_FOLDER_PATH, DATABASE_FILENAME)
+        )}"
 
 
 class DevConfig(Config):
@@ -30,4 +37,8 @@ class DevConfig(Config):
     ORIGINS = "*"
     MINUTES_BEFORE_TIMEOUT = "1"
     SECONDS_BETWEEN_SHUTDOWNS = "10"
-    DATA_FOLDER_PATH = "./data/"
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+    DATA_FOLDER_PATH = os.path.join(BASE_DIR, "data")
+    SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.join(
+        BASE_DIR, DATA_FOLDER_PATH, DATABASE_FILENAME
+        )}"

opengeodeweb_back/geode_functions.py

@@ -2,14 +2,17 @@
 import os
 
 # Third party imports
-import opengeode_geosciences as og_gs
-import opengeode as og
+import opengeode_geosciences as og_gs  # type: ignore
+import opengeode as og  # type: ignore
 import werkzeug
 import flask
+from typing import Any
 
 # Local application imports
 from .geode_objects import geode_objects_dict
 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):
@@ -37,25 +40,40 @@ def is_loadable(geode_object: str, file_absolute_path: str) -> float:
     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 = "") -> str:
     data_folder_path = flask.current_app.config["DATA_FOLDER_PATH"]
-    return os.path.join(
-        data_folder_path,
-        data_id,
-        werkzeug.utils.secure_filename(filename),
-    )
+    if filename:
+        return os.path.join(data_folder_path, data_id, filename)
+    return os.path.join(data_folder_path, data_id)
+
 
+def load_data(data_id: str) -> Any:
+    data_entry = Data.get(data_id)
+    if not data_entry:
+        flask.abort(404, f"Data with id {data_id} not found")
 
-def load_data(geode_object: str, data_id: str, filename: str):
-    file_absolute_path = data_file_path(data_id, filename)
-    return load(geode_object, file_absolute_path)
+    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)
 
 
-def upload_file_path(filename):
+def get_data_info(data_id: str) -> Data:
+    data_entry = Data.get(data_id)
+    if not data_entry:
+        flask.abort(404, f"Data with id {data_id} not found")
+    return data_entry
+
+
+def upload_file_path(filename: str) -> str:
     upload_folder = flask.current_app.config["UPLOAD_FOLDER"]
     secure_filename = werkzeug.utils.secure_filename(filename)
     return os.path.abspath(os.path.join(upload_folder, secure_filename))
@@ -181,11 +199,14 @@ def list_geode_objects(
         os.path.basename(file_absolute_path)
     )
     geode_objects_filtered_list = filter_geode_objects(key)
-
     for geode_object in geode_objects_filtered_list:
         if has_creator(geode_object, file_extension):
             loadability_score = is_loadable(geode_object, file_absolute_path)
-            return_dict[geode_object] = {"is_loadable": loadability_score}
+            priority_score = object_priority(geode_object, file_absolute_path)
+            return_dict[geode_object] = {
+                "is_loadable": loadability_score,
+                "object_priority": priority_score,
+            }
     return return_dict
 
 

opengeodeweb_back/geode_objects.py

@@ -1,12 +1,12 @@
 # Standard library imports
 
 # Third party imports
-import opengeode as og
-import opengeode_io as og_io
-import opengeode_inspector as og_inspector
-import opengeode_geosciences as og_gs
-import opengeode_geosciencesio as og_gs_io
-import geode_viewables as g_v
+import opengeode as og  # type: ignore
+import opengeode_io as og_io  # type: ignore
+import opengeode_inspector as og_inspector  # type: ignore
+import opengeode_geosciences as og_gs  # type: ignore
+import opengeode_geosciencesio as og_gs_io  # type: ignore
+import geode_viewables as g_v  # type: ignore
 
 # Local application imports
 
@@ -27,6 +27,7 @@ def geode_objects_dict():
             "output_factory": og.BRepOutputFactory,
             "additional_files": og.brep_additional_files,
             "is_loadable": og.is_brep_loadable,
+            "object_priority": og.brep_object_priority,
             "load": og.load_brep,
             "is_saveable": og.is_brep_saveable,
             "save": og.save_brep,
@@ -50,6 +51,7 @@ def geode_objects_dict():
             "output_factory": og_gs.CrossSectionOutputFactory,
             "additional_files": og_gs.cross_section_additional_files,
             "is_loadable": og_gs.is_cross_section_loadable,
+            "object_priority": og_gs.cross_section_object_priority,
             "load": og_gs.load_cross_section,
             "is_saveable": og_gs.is_cross_section_saveable,
             "save": og_gs.save_cross_section,
@@ -72,6 +74,7 @@ def geode_objects_dict():
             "output_factory": og.EdgedCurveOutputFactory2D,
             "additional_files": og.edged_curve_additional_files2D,
             "is_loadable": og.is_edged_curve_loadable2D,
+            "object_priority": og.edged_curve_object_priority2D,
             "load": og.load_edged_curve2D,
             "is_saveable": og.is_edged_curve_saveable2D,
             "save": og.save_edged_curve2D,
@@ -95,6 +98,7 @@ def geode_objects_dict():
             "output_factory": og.EdgedCurveOutputFactory3D,
             "additional_files": og.edged_curve_additional_files3D,
             "is_loadable": og.is_edged_curve_loadable3D,
+            "object_priority": og.edged_curve_object_priority3D,
             "load": og.load_edged_curve3D,
             "is_saveable": og.is_edged_curve_saveable3D,
             "save": og.save_edged_curve3D,
@@ -118,6 +122,7 @@ def geode_objects_dict():
             "output_factory": og.GraphOutputFactory,
             "additional_files": og.graph_additional_files,
             "is_loadable": og.is_graph_loadable,
+            "object_priority": og.graph_object_priority,
             "load": og.load_graph,
             "is_saveable": og.is_graph_saveable,
             "save": og.save_graph,
@@ -132,6 +137,7 @@ def geode_objects_dict():
             "output_factory": og.HybridSolidOutputFactory3D,
             "additional_files": og.hybrid_solid_additional_files3D,
             "is_loadable": og.is_hybrid_solid_loadable3D,
+            "object_priority": og.hybrid_solid_object_priority3D,
             "load": og.load_hybrid_solid3D,
             "is_saveable": og.is_hybrid_solid_saveable3D,
             "save": og.save_hybrid_solid3D,
@@ -156,6 +162,7 @@ def geode_objects_dict():
             "output_factory": og_gs.ImplicitCrossSectionOutputFactory,
             "additional_files": og_gs.implicit_cross_section_additional_files,
             "is_loadable": og_gs.is_implicit_cross_section_loadable,
+            "object_priority": og_gs.implicit_cross_section_object_priority,
             "load": og_gs.load_implicit_cross_section,
             "is_saveable": og_gs.is_implicit_cross_section_saveable,
             "save": og_gs.save_implicit_cross_section,
@@ -179,6 +186,7 @@ def geode_objects_dict():
             "output_factory": og_gs.ImplicitStructuralModelOutputFactory,
             "additional_files": og_gs.implicit_structural_model_additional_files,
             "is_loadable": og_gs.is_implicit_structural_model_loadable,
+            "object_priority": og_gs.implicit_structural_model_object_priority,
             "load": og_gs.load_implicit_structural_model,
             "is_saveable": og_gs.is_implicit_structural_model_saveable,
             "save": og_gs.save_implicit_structural_model,
@@ -201,6 +209,7 @@ def geode_objects_dict():
             "output_factory": og.LightRegularGridOutputFactory2D,
             "additional_files": og.light_regular_grid_additional_files2D,
             "is_loadable": og.is_light_regular_grid_loadable2D,
+            "object_priority": og.light_regular_grid_object_priority2D,
             "load": og.load_light_regular_grid2D,
             "is_saveable": og.is_light_regular_grid_saveable2D,
             "save": og.save_light_regular_grid2D,
@@ -208,7 +217,7 @@ def geode_objects_dict():
             "elements": [points, polygons],
             "is_3D": False,
             "is_viewable": True,
-            "save_viewable": g_v.save_light_viewable_light_regular_grid2D,
+            "save_viewable": g_v.save_viewable_light_regular_grid2D,
             "save_light_viewable": g_v.save_light_viewable_light_regular_grid2D,
         },
         "LightRegularGrid3D": {
@@ -217,6 +226,7 @@ def geode_objects_dict():
             "output_factory": og.LightRegularGridOutputFactory3D,
             "additional_files": og.light_regular_grid_additional_files3D,
             "is_loadable": og.is_light_regular_grid_loadable3D,
+            "object_priority": og.light_regular_grid_object_priority3D,
             "load": og.load_light_regular_grid3D,
             "is_saveable": og.is_light_regular_grid_saveable3D,
             "save": og.save_light_regular_grid3D,
@@ -233,6 +243,7 @@ def geode_objects_dict():
             "output_factory": og.PointSetOutputFactory2D,
             "additional_files": og.point_set_additional_files2D,
             "is_loadable": og.is_point_set_loadable2D,
+            "object_priority": og.point_set_object_priority2D,
             "load": og.load_point_set2D,
             "is_saveable": og.is_point_set_saveable2D,
             "save": og.save_point_set2D,
@@ -256,6 +267,7 @@ def geode_objects_dict():
             "output_factory": og.PointSetOutputFactory3D,
             "additional_files": og.point_set_additional_files3D,
             "is_loadable": og.is_point_set_loadable3D,
+            "object_priority": og.point_set_object_priority3D,
             "load": og.load_point_set3D,
             "is_saveable": og.is_point_set_saveable3D,
             "save": og.save_point_set3D,
@@ -279,6 +291,7 @@ def geode_objects_dict():
             "output_factory": og.PolygonalSurfaceOutputFactory2D,
             "additional_files": og.polygonal_surface_additional_files2D,
             "is_loadable": og.is_polygonal_surface_loadable2D,
+            "object_priority": og.polygonal_surface_object_priority2D,
             "load": og.load_polygonal_surface2D,
             "is_saveable": og.is_polygonal_surface_saveable2D,
             "save": og.save_polygonal_surface2D,
@@ -302,6 +315,7 @@ def geode_objects_dict():
             "output_factory": og.PolygonalSurfaceOutputFactory3D,
             "additional_files": og.polygonal_surface_additional_files3D,
             "is_loadable": og.is_polygonal_surface_loadable3D,
+            "object_priority": og.polygonal_surface_object_priority3D,
             "load": og.load_polygonal_surface3D,
             "is_saveable": og.is_polygonal_surface_saveable3D,
             "save": og.save_polygonal_surface3D,
@@ -325,6 +339,7 @@ def geode_objects_dict():
             "output_factory": og.PolyhedralSolidOutputFactory3D,
             "additional_files": og.polyhedral_solid_additional_files3D,
             "is_loadable": og.is_polyhedral_solid_loadable3D,
+            "object_priority": og.polyhedral_solid_object_priority3D,
             "load": og.load_polyhedral_solid3D,
             "is_saveable": og.is_polyhedral_solid_saveable3D,
             "save": og.save_polyhedral_solid3D,
@@ -348,6 +363,7 @@ def geode_objects_dict():
             "output_factory": og.RasterImageOutputFactory2D,
             "additional_files": og.raster_image_additional_files2D,
             "is_loadable": og.is_raster_image_loadable2D,
+            "object_priority": og.raster_image_object_priority2D,
             "load": og.load_raster_image2D,
             "is_saveable": og.is_raster_image_saveable2D,
             "save": og.save_raster_image2D,
@@ -362,6 +378,7 @@ def geode_objects_dict():
             "output_factory": og.RasterImageOutputFactory3D,
             "additional_files": og.raster_image_additional_files3D,
             "is_loadable": og.is_raster_image_loadable3D,
+            "object_priority": og.raster_image_object_priority3D,
             "load": og.load_raster_image3D,
             "is_saveable": og.is_raster_image_saveable3D,
             "save": og.save_raster_image3D,
@@ -376,6 +393,7 @@ def geode_objects_dict():
             "output_factory": og.RegularGridOutputFactory2D,
             "additional_files": og.regular_grid_additional_files2D,
             "is_loadable": og.is_regular_grid_loadable2D,
+            "object_priority": og.regular_grid_object_priority2D,
             "load": og.load_regular_grid2D,
             "is_saveable": og.is_regular_grid_saveable2D,
             "save": og.save_regular_grid2D,
@@ -398,6 +416,7 @@ def geode_objects_dict():
             "output_factory": og.RegularGridOutputFactory3D,
             "additional_files": og.regular_grid_additional_files3D,
             "is_loadable": og.is_regular_grid_loadable3D,
+            "object_priority": og.regular_grid_object_priority3D,
             "load": og.load_regular_grid3D,
             "is_saveable": og.is_regular_grid_saveable3D,
             "save": og.save_regular_grid3D,
@@ -420,6 +439,7 @@ def geode_objects_dict():
             "output_factory": og.SectionOutputFactory,
             "additional_files": og.section_additional_files,
             "is_loadable": og.is_section_loadable,
+            "object_priority": og.section_object_priority,
             "load": og.load_section,
             "is_saveable": og.is_section_saveable,
             "save": og.save_section,
@@ -443,6 +463,7 @@ def geode_objects_dict():
             "output_factory": og_gs.StructuralModelOutputFactory,
             "additional_files": og_gs.structural_model_additional_files,
             "is_loadable": og_gs.is_structural_model_loadable,
+            "object_priority": og_gs.structural_model_object_priority,
             "load": og_gs.load_structural_model,
             "is_saveable": og_gs.is_structural_model_saveable,
             "save": og_gs.save_structural_model,
@@ -465,6 +486,7 @@ def geode_objects_dict():
             "output_factory": og.TetrahedralSolidOutputFactory3D,
             "additional_files": og.tetrahedral_solid_additional_files3D,
             "is_loadable": og.is_tetrahedral_solid_loadable3D,
+            "object_priority": og.tetrahedral_solid_object_priority3D,
             "load": og.load_tetrahedral_solid3D,
             "is_saveable": og.is_tetrahedral_solid_saveable3D,
             "save": og.save_tetrahedral_solid3D,
@@ -488,6 +510,7 @@ def geode_objects_dict():
             "output_factory": og.TriangulatedSurfaceOutputFactory2D,
             "additional_files": og.triangulated_surface_additional_files2D,
             "is_loadable": og.is_triangulated_surface_loadable2D,
+            "object_priority": og.triangulated_surface_object_priority2D,
             "load": og.load_triangulated_surface2D,
             "is_saveable": og.is_triangulated_surface_saveable2D,
             "save": og.save_triangulated_surface2D,
@@ -511,6 +534,7 @@ def geode_objects_dict():
             "output_factory": og.TriangulatedSurfaceOutputFactory3D,
             "additional_files": og.triangulated_surface_additional_files3D,
             "is_loadable": og.is_triangulated_surface_loadable3D,
+            "object_priority": og.triangulated_surface_object_priority3D,
             "load": og.load_triangulated_surface3D,
             "is_saveable": og.is_triangulated_surface_saveable3D,
             "save": og.save_triangulated_surface3D,
@@ -534,6 +558,7 @@ def geode_objects_dict():
             "output_factory": og.VertexSetOutputFactory,
             "additional_files": og.vertex_set_additional_files,
             "is_loadable": og.is_vertex_set_loadable,
+            "object_priority": og.vertex_set_object_priority,
             "load": og.load_vertex_set,
             "is_saveable": og.is_vertex_set_saveable,
             "save": og.save_vertex_set,

opengeodeweb_back/py.typed

@@ -0,0 +1 @@
+partial

opengeodeweb_back/routes/blueprint_routes.py

@@ -53,7 +53,7 @@ with open(
 def allowed_files():
     utils_functions.validate_request(flask.request, allowed_files_json)
     extensions = geode_functions.list_input_extensions(
-        flask.request.json["supported_feature"]
+        flask.request.get_json()["supported_feature"]
     )
     return flask.make_response({"extensions": extensions}, 200)
 
@@ -99,10 +99,10 @@ def allowed_objects():
 
     utils_functions.validate_request(flask.request, allowed_objects_json)
     file_absolute_path = geode_functions.upload_file_path(
-        flask.request.json["filename"]
+        flask.request.get_json()["filename"]
     )
     allowed_objects = geode_functions.list_geode_objects(
-        file_absolute_path, flask.request.json["supported_feature"]
+        file_absolute_path, flask.request.get_json()["supported_feature"]
     )
     return flask.make_response({"allowed_objects": allowed_objects}, 200)
 
@@ -120,10 +120,10 @@ with open(
 )
 def missing_files():
     utils_functions.validate_request(flask.request, missing_files_json)
-    file_path = geode_functions.upload_file_path(flask.request.json["filename"])
+    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
 
     additional_files = geode_functions.additional_files(
-        flask.request.json["input_geode_object"],
+        flask.request.get_json()["input_geode_object"],
         file_path,
     )
 
@@ -167,7 +167,7 @@ with open(
 def crs_converter_geographic_coordinate_systems():
     utils_functions.validate_request(flask.request, geographic_coordinate_systems_json)
     infos = geode_functions.geographic_coordinate_systems(
-        flask.request.json["input_geode_object"]
+        flask.request.get_json()["input_geode_object"]
     )
     crs_list = []
     for info in infos:
@@ -194,10 +194,12 @@ with open(
 def inspect_file():
     utils_functions.validate_request(flask.request, inspect_file_json)
 
-    file_path = geode_functions.upload_file_path(flask.request.json["filename"])
-    data = geode_functions.load(flask.request.json["input_geode_object"], file_path)
+    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
+    data = geode_functions.load(
+        flask.request.get_json()["input_geode_object"], file_path
+    )
     class_inspector = geode_functions.inspect(
-        flask.request.json["input_geode_object"], data
+        flask.request.get_json()["input_geode_object"], data
     )
     inspection_result = geode_functions.get_inspector_children(class_inspector)
     return flask.make_response({"inspection_result": inspection_result}, 200)
@@ -218,14 +220,14 @@ def geode_objects_and_output_extensions():
     utils_functions.validate_request(
         flask.request, geode_objects_and_output_extensions_json
     )
-    file_path = geode_functions.upload_file_path(flask.request.json["filename"])
+    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
     data = geode_functions.load(
-        flask.request.json["input_geode_object"],
+        flask.request.get_json()["input_geode_object"],
         file_path,
     )
     geode_objects_and_output_extensions = (
         geode_functions.geode_objects_output_extensions(
-            flask.request.json["input_geode_object"], data
+            flask.request.get_json()["input_geode_object"], data
         )
     )
     return flask.make_response(
@@ -249,8 +251,8 @@ def save_viewable_file():
     utils_functions.validate_request(flask.request, save_viewable_file_json)
     return flask.make_response(
         utils_functions.generate_native_viewable_and_light_viewable_from_file(
-            geode_object=flask.request.json["input_geode_object"],
-            input_filename=flask.request.json["filename"],
+            geode_object=flask.request.get_json()["input_geode_object"],
+            input_filename=flask.request.get_json()["filename"],
         ),
         200,
     )
@@ -263,10 +265,10 @@ with open(os.path.join(schemas, "create_point.json"), "r") as file:
 @routes.route(create_point_json["route"], methods=create_point_json["methods"])
 def create_point():
     utils_functions.validate_request(flask.request, create_point_json)
-    title = flask.request.json["title"]
-    x = flask.request.json["x"]
-    y = flask.request.json["y"]
-    z = flask.request.json["z"]
+    title = flask.request.get_json()["title"]
+    x = flask.request.get_json()["x"]
+    y = flask.request.get_json()["y"]
+    z = flask.request.get_json()["z"]
     class_ = geode_functions.geode_object_class("PointSet3D")
     PointSet3D = class_.create()
     builder = geode_functions.create_builder("PointSet3D", PointSet3D)
@@ -290,14 +292,8 @@ with open(os.path.join(schemas, "texture_coordinates.json"), "r") as file:
 )
 def texture_coordinates():
     utils_functions.validate_request(flask.request, texture_coordinates_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     texture_coordinates = data.texture_manager().texture_names()
-
     return flask.make_response({"texture_coordinates": texture_coordinates}, 200)
 
 
@@ -314,14 +310,8 @@ with open(
 )
 def vertex_attribute_names():
     utils_functions.validate_request(flask.request, vertex_attribute_names_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     vertex_attribute_names = data.vertex_attribute_manager().attribute_names()
-
     return flask.make_response(
         {
             "vertex_attribute_names": vertex_attribute_names,
@@ -343,14 +333,8 @@ with open(
 )
 def polygon_attribute_names():
     utils_functions.validate_request(flask.request, polygon_attribute_names_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     polygon_attribute_names = data.polygon_attribute_manager().attribute_names()
-
     return flask.make_response(
         {
             "polygon_attribute_names": polygon_attribute_names,
@@ -372,14 +356,8 @@ with open(
 )
 def polyhedron_attribute_names():
     utils_functions.validate_request(flask.request, polyhedron_attribute_names_json)
-    data = geode_functions.load_data(
-        flask.request.json["input_geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    data = geode_functions.load_data(flask.request.get_json().get("id"))
     polyhedron_attribute_names = data.polyhedron_attribute_manager().attribute_names()
-
     return flask.make_response(
         {
             "polyhedron_attribute_names": polyhedron_attribute_names,

opengeodeweb_back/routes/models/blueprint_models.py

@@ -20,7 +20,7 @@ def uuid_to_flat_index():
     utils_functions.validate_request(flask.request, vtm_component_indices_json)
 
     vtm_file_path = geode_functions.data_file_path(
-        flask.request.json["id"], "viewable.vtm"
+        flask.request.get_json().get("id"), "viewable.vtm"
     )
     tree = ET.parse(vtm_file_path)
     root = tree.find("vtkMultiBlockDataSet")
@@ -49,12 +49,6 @@ with open(os.path.join(schemas, "mesh_components.json"), "r") as file:
 @routes.route(mesh_components_json["route"], methods=mesh_components_json["methods"])
 def extract_uuids_endpoint():
     utils_functions.validate_request(flask.request, mesh_components_json)
-
-    model = geode_functions.load_data(
-        flask.request.json["geode_object"],
-        flask.request.json["id"],
-        flask.request.json["filename"],
-    )
-
+    model = geode_functions.load_data(flask.request.get_json().get("id"))
     uuid_dict = extract_model_uuids(model)
     return flask.make_response({"uuid_dict": uuid_dict}, 200)

opengeodeweb_back/routes/models/schemas/mesh_components.json

@@ -8,20 +8,10 @@
     "id": {
       "type": "string",
       "minLength": 1      
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
-    "geode_object": {
-      "type": "string",
-      "minLength": 1
     }
   },
   "required": [
-    "id",
-    "filename",
-    "geode_object"
+    "id"
   ],
   "additionalProperties": false
 }

opengeodeweb_back/routes/schemas/polygon_attribute_names.json

@@ -5,22 +5,12 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "filename",
     "id"
   ],
   "additionalProperties": false

opengeodeweb_back/routes/schemas/polyhedron_attribute_names.json

@@ -5,22 +5,12 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "filename",
     "id"
   ],
   "additionalProperties": false

opengeodeweb_back/routes/schemas/texture_coordinates.json

@@ -5,23 +5,13 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "id",
-    "filename"
+    "id"
   ],
   "additionalProperties": false
 }

opengeodeweb_back/routes/schemas/vertex_attribute_names.json

@@ -5,22 +5,12 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
-      "type": "string",
-      "minLength": 1
-    },
-    "filename": {
-      "type": "string",
-      "minLength": 1
-    },
     "id": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object",
-    "filename",
     "id"
   ],
   "additionalProperties": false

opengeodeweb_back/utils_functions.py

@@ -2,54 +2,59 @@
 import os
 import threading
 import time
-import uuid
 import zipfile
+from collections.abc import Callable
+from typing import Any
+from concurrent.futures import ThreadPoolExecutor
 
 # Third party imports
 import flask
-import fastjsonschema
+import fastjsonschema  # type: ignore
 import importlib.metadata as metadata
 import shutil
+from werkzeug.exceptions import HTTPException
 import werkzeug
 
 # Local application imports
 from . import geode_functions
+from opengeodeweb_microservice.database.data import Data
+from opengeodeweb_microservice.database.connection import get_session
 
 
-def increment_request_counter(current_app):
+def increment_request_counter(current_app: flask.Flask) -> None:
     if "REQUEST_COUNTER" in current_app.config:
-        REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER"))
+        REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER", 0))
         REQUEST_COUNTER += 1
         current_app.config.update(REQUEST_COUNTER=REQUEST_COUNTER)
 
 
-def decrement_request_counter(current_app):
+def decrement_request_counter(current_app: flask.Flask) -> None:
     if "REQUEST_COUNTER" in current_app.config:
-        REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER"))
+        REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER", 0))
         REQUEST_COUNTER -= 1
         current_app.config.update(REQUEST_COUNTER=REQUEST_COUNTER)
 
 
-def update_last_request_time(current_app):
+def update_last_request_time(current_app: flask.Flask) -> None:
     if "LAST_REQUEST_TIME" in current_app.config:
         LAST_REQUEST_TIME = time.time()
         current_app.config.update(LAST_REQUEST_TIME=LAST_REQUEST_TIME)
 
 
-def before_request(current_app):
+def before_request(current_app: flask.Flask) -> None:
     increment_request_counter(current_app)
 
 
-def teardown_request(current_app):
+def teardown_request(current_app: flask.Flask) -> None:
     decrement_request_counter(current_app)
     update_last_request_time(current_app)
 
 
-def kill_task(current_app):
-    REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER"))
-    LAST_PING_TIME = float(current_app.config.get("LAST_PING_TIME"))
-    LAST_REQUEST_TIME = float(current_app.config.get("LAST_REQUEST_TIME"))
-    MINUTES_BEFORE_TIMEOUT = float(current_app.config.get("MINUTES_BEFORE_TIMEOUT"))
+def kill_task(current_app: flask.Flask) -> None:
+    REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER", 0))
+    LAST_PING_TIME = float(current_app.config.get("LAST_PING_TIME", 0))
+    LAST_REQUEST_TIME = float(current_app.config.get("LAST_REQUEST_TIME", 0))
+    MINUTES_BEFORE_TIMEOUT = float(current_app.config.get("MINUTES_BEFORE_TIMEOUT", 0))
     current_time = time.time()
     minutes_since_last_request = (current_time - LAST_REQUEST_TIME) / 60
     minutes_since_last_ping = (current_time - LAST_PING_TIME) / 60
@@ -64,12 +69,12 @@ def kill_task(current_app):
         kill_server()
 
 
-def kill_server():
+def kill_server() -> None:
     print("Server timed out due to inactivity, shutting down...", flush=True)
     os._exit(0)
 
 
-def versions(list_packages: list):
+def versions(list_packages: list[str]) -> list[dict[str, str]]:
     list_with_versions = []
     for package in list_packages:
         list_with_versions.append(
@@ -78,7 +83,7 @@ def versions(list_packages: list):
     return list_with_versions
 
 
-def validate_request(request, schema):
+def validate_request(request: flask.Request, schema: dict[str, str]) -> None:
     json_data = request.get_json(force=True, silent=True)
 
     if json_data is None:
@@ -92,22 +97,26 @@ def validate_request(request, schema):
         flask.abort(400, error_msg)
 
 
-def set_interval(func, sec, args=None):
-    def func_wrapper():
-        set_interval(func, sec, args)
-        func(args)
+def set_interval(
+    function: Callable[[Any], None], seconds: float, args: Any
+) -> threading.Timer:
+    def function_wrapper() -> None:
+        set_interval(function, seconds, args)
+        function(args)
 
-    t = threading.Timer(sec, func_wrapper)
-    t.daemon = True
-    t.start()
-    return t
+    timer = threading.Timer(seconds, function_wrapper)
+    timer.daemon = True
+    timer.start()
+    return timer
 
 
-def extension_from_filename(filename):
+def extension_from_filename(filename: str) -> str:
     return os.path.splitext(filename)[1][1:]
 
 
-def send_file(upload_folder, saved_files, new_file_name):
+def send_file(
+    upload_folder: str, saved_files: str, new_file_name: str
+) -> flask.Response:
     if len(saved_files) == 1:
         mimetype = "application/octet-binary"
     else:
@@ -132,66 +141,100 @@ def send_file(upload_folder, saved_files, new_file_name):
     return response
 
 
-def handle_exception(e):
-    response = e.get_response()
+def handle_exception(exception: HTTPException) -> flask.Response:
+    response = exception.get_response()
     response.data = flask.json.dumps(
         {
-            "code": e.code,
-            "name": e.name,
-            "description": e.description,
+            "code": exception.code,
+            "name": exception.name,
+            "description": exception.description,
         }
     )
     response.content_type = "application/json"
     return response
 
 
-def create_unique_data_folder() -> tuple[str, str]:
+def create_data_folder_from_id(data_id: str) -> str:
     base_data_folder = flask.current_app.config["DATA_FOLDER_PATH"]
-    generated_id = str(uuid.uuid4()).replace("-", "")
-    data_path = os.path.join(base_data_folder, generated_id)
+    data_path = os.path.join(base_data_folder, data_id)
     os.makedirs(data_path, exist_ok=True)
-    return generated_id, data_path
+    return data_path
 
 
 def save_all_viewables_and_return_info(
-    geode_object, data, generated_id, data_path, additional_files=None
-):
-    saved_native_file_path = geode_functions.save(
-        geode_object,
-        data,
-        data_path,
-        "native." + data.native_extension(),
-    )
-    saved_viewable_file_path = geode_functions.save_viewable(
-        geode_object, data, data_path, "viewable"
-    )
-    saved_light_viewable_file_path = geode_functions.save_light_viewable(
-        geode_object, data, data_path, "light_viewable"
-    )
-    with open(saved_light_viewable_file_path, "rb") as f:
-        binary_light_viewable = f.read()
-
-    return {
-        "name": data.name(),
-        "native_file_name": os.path.basename(saved_native_file_path[0]),
-        "viewable_file_name": os.path.basename(saved_viewable_file_path),
-        "id": generated_id,
-        "object_type": geode_functions.get_object_type(geode_object),
-        "binary_light_viewable": binary_light_viewable.decode("utf-8"),
-        "geode_object": geode_object,
-        "input_files": additional_files or [],
-    }
-
-
-def generate_native_viewable_and_light_viewable_from_object(geode_object, data):
-    generated_id, data_path = create_unique_data_folder()
-    return save_all_viewables_and_return_info(
-        geode_object, data, generated_id, data_path
+    geode_object: str,
+    data: Any,
+    input_file: str,
+    additional_files: list[str] | None = None,
+) -> dict[str, Any]:
+    if additional_files is None:
+        additional_files = []
+
+    data_entry = Data.create(
+        geode_object=geode_object,
+        input_file=input_file,
+        additional_files=additional_files,
     )
+    data_path = create_data_folder_from_id(data_entry.id)
+    with ThreadPoolExecutor() as executor:
+        native_future = executor.submit(
+            geode_functions.save,
+            geode_object,
+            data,
+            data_path,
+            "native." + data.native_extension(),
+        )
+        viewable_future = executor.submit(
+            geode_functions.save_viewable, geode_object, data, data_path, "viewable"
+        )
+        light_viewable_future = executor.submit(
+            geode_functions.save_light_viewable,
+            geode_object,
+            data,
+            data_path,
+            "light_viewable",
+        )
+        saved_light_viewable_file_path = light_viewable_future.result()
+        with open(saved_light_viewable_file_path, "rb") as f:
+            binary_light_viewable = f.read()
+        saved_native_file_path = native_future.result()
+        saved_viewable_file_path = viewable_future.result()
+        data_entry.native_file_name = os.path.basename(saved_native_file_path[0])
+        data_entry.viewable_file_name = os.path.basename(saved_viewable_file_path)
+        data_entry.light_viewable = os.path.basename(saved_light_viewable_file_path)
+
+        session = get_session()
+        if session:
+            session.commit()
+
+        return {
+            "native_file_name": data_entry.native_file_name,
+            "viewable_file_name": data_entry.viewable_file_name,
+            "id": data_entry.id,
+            "object_type": geode_functions.get_object_type(geode_object),
+            "binary_light_viewable": binary_light_viewable.decode("utf-8"),
+            "geode_object": data_entry.geode_object,
+            "input_files": data_entry.input_file,
+            "additional_files": data_entry.additional_files,
+        }
 
 
-def generate_native_viewable_and_light_viewable_from_file(geode_object, input_filename):
-    generated_id, data_path = create_unique_data_folder()
+def generate_native_viewable_and_light_viewable_from_object(
+    geode_object: str, data: Any
+) -> dict[str, Any]:
+    return save_all_viewables_and_return_info(geode_object, data, input_file="")
+
+
+def generate_native_viewable_and_light_viewable_from_file(
+    geode_object: str, input_filename: str
+) -> dict[str, Any]:
+    temp_data_entry = Data.create(
+        geode_object=geode_object,
+        input_file=input_filename,
+        additional_files=[],
+    )
+
+    data_path = create_data_folder_from_id(temp_data_entry.id)
 
     full_input_filename = geode_functions.upload_file_path(input_filename)
     copied_full_path = os.path.join(
@@ -199,7 +242,7 @@ def generate_native_viewable_and_light_viewable_from_file(geode_object, input_fi
     )
     shutil.copy2(full_input_filename, copied_full_path)
 
-    additional_files_copied = []
+    additional_files_copied: list[str] = []
     additional = geode_functions.additional_files(geode_object, full_input_filename)
     for additional_file in additional.mandatory_files + additional.optional_files:
         if additional_file.is_missing:
@@ -214,12 +257,20 @@ def generate_native_viewable_and_light_viewable_from_file(geode_object, input_fi
         shutil.copy2(source_path, dest_path)
         additional_files_copied.append(additional_file.filename)
 
-    data = geode_functions.load_data(geode_object, generated_id, input_filename)
+    data = geode_functions.load(geode_object, copied_full_path)
+
+    # Remplacer :
+    # database.session.delete(temp_data_entry)
+    # database.session.flush()
+    # Par :
+    session = get_session()
+    if session:
+        session.delete(temp_data_entry)
+        session.flush()
 
     return save_all_viewables_and_return_info(
         geode_object,
         data,
-        generated_id,
-        data_path,
+        input_file=input_filename,
         additional_files=additional_files_copied,
     )

{opengeodeweb_back-5.9.1.dist-info → opengeodeweb_back-5.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 5.9.1
+Version: 5.10.0
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back
@@ -11,22 +11,27 @@ Classifier: Operating System :: OS Independent
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: asgiref==3.9.1
-Requires-Dist: blinker==1.9.0
-Requires-Dist: click==8.2.1
-Requires-Dist: fastjsonschema==2.16.2
-Requires-Dist: flask[async]==3.0.3
-Requires-Dist: flask-cors==6.0.1
-Requires-Dist: geode-common==33.9.0
-Requires-Dist: geode-viewables==3.2.0
-Requires-Dist: itsdangerous==2.2.0
-Requires-Dist: jinja2==3.1.6
-Requires-Dist: markupsafe==3.0.2
-Requires-Dist: opengeode-core==15.24.2
-Requires-Dist: opengeode-geosciences==9.2.2
-Requires-Dist: opengeode-geosciencesio==5.7.2
-Requires-Dist: opengeode-inspector==6.7.0
-Requires-Dist: opengeode-io==7.3.2
+Requires-Dist: asgiref~=3.0
+Requires-Dist: blinker~=1.0
+Requires-Dist: click~=8.0
+Requires-Dist: fastjsonschema~=2.0
+Requires-Dist: flask[async]~=3.0
+Requires-Dist: flask-cors~=6.0
+Requires-Dist: flask-sqlalchemy~=3.0
+Requires-Dist: geode-common==33.11.0
+Requires-Dist: geode-viewables==3.3.0
+Requires-Dist: greenlet~=3.0
+Requires-Dist: itsdangerous~=2.0
+Requires-Dist: jinja2~=3.0
+Requires-Dist: markupsafe~=3.0
+Requires-Dist: opengeode-core==15.27.4
+Requires-Dist: opengeode-geosciences==9.4.1
+Requires-Dist: opengeode-geosciencesio==5.8.0
+Requires-Dist: opengeode-inspector==6.8.1
+Requires-Dist: opengeode-io==7.4.0
+Requires-Dist: opengeodeweb-microservice~=1.0
+Requires-Dist: sqlalchemy~=2.0
+Requires-Dist: typing-extensions~=4.0
 Requires-Dist: werkzeug==3.0.3
 Dynamic: license-file
 

{opengeodeweb_back-5.9.1.dist-info → opengeodeweb_back-5.10.0.dist-info}/RECORD

@@ -1,12 +1,13 @@
 opengeodeweb_back/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opengeodeweb_back/app_config.py,sha256=gJfYxDJOa_PYLqjqgdXacp3W3F109uujE9LGPvzHOkc,728
-opengeodeweb_back/geode_functions.py,sha256=4zxr8FJK9gNCzAvRqWSuGc8TwIZr0BU4dM5ITgiw_OQ,9859
-opengeodeweb_back/geode_objects.py,sha256=GrC1NltKKSCr0QSgcMy2ES8SLW_RkndCdrokeBOymrA,25995
+opengeodeweb_back/app_config.py,sha256=WH0f-J-cXgIU23wAhn-lujwqN2-htUw9nSWkrgyW5xc,1207
+opengeodeweb_back/geode_functions.py,sha256=NzELy9s6AETDnm7tyA_uM2N89zrfeLdblRhzYrBONmw,10804
+opengeodeweb_back/geode_objects.py,sha256=_NclGPa024kCwUHdORkFuXYtiZBmQpgq6sO3LRkBhe8,27776
+opengeodeweb_back/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
 opengeodeweb_back/test_utils.py,sha256=18AbRW9-tfKkPcmRGilTTHXI7S3armYyV7Vdy5UvUKM,794
-opengeodeweb_back/utils_functions.py,sha256=j9swpKiA7Wo4rSX4_Vy_Vi6OmiqUTkQqZShawgs14DA,7099
-opengeodeweb_back/routes/blueprint_routes.py,sha256=3fxMR9fs0BqnOiYhKFacGdxWm7JFLz5i5PvUqYgB5z4,11308
-opengeodeweb_back/routes/models/blueprint_models.py,sha256=PAyHSKjsvVm5gGfjUyWAnODmE0BJMsIWc1AWl0F3bO0,1955
-opengeodeweb_back/routes/models/schemas/mesh_components.json,sha256=3OQvI4pUCe77WGC46tEr37rEWigQ6n2nsfGUTZRY074,419
+opengeodeweb_back/utils_functions.py,sha256=k8FpsHruaqnqyYgfwRC2JVvzoQrV5JgY7z5JJ7dhMgs,9180
+opengeodeweb_back/routes/blueprint_routes.py,sha256=h_yfFC3ljH0KqFr5Ab_-IQYNB7VVRENwAMQk4NDsh18,11042
+opengeodeweb_back/routes/models/blueprint_models.py,sha256=Jo9pUDeu1nO3_IbBiuHGk57cc4_fhwxjM0EKNyv1FT0,1874
+opengeodeweb_back/routes/models/schemas/mesh_components.json,sha256=JmQUvpy7HpGS6FlThZLx1YjHqiInRTqUZ_Ft5MfOzEE,239
 opengeodeweb_back/routes/models/schemas/vtm_component_indices.json,sha256=0XILVxhAxi0RhQFDZZoUeGcAnBMroWz3kNJS7-6_dKQ,239
 opengeodeweb_back/routes/schemas/allowed_files.json,sha256=pRsGf39LiJpl3zEGLg4IqvRtm7iUx3Wq4Tb4tSFXGV0,234
 opengeodeweb_back/routes/schemas/allowed_objects.json,sha256=oy_YYpFzgDICx-keWqNIUpQM3zzB4eE3H6mPNxH9rWc,361
@@ -16,14 +17,14 @@ opengeodeweb_back/routes/schemas/geographic_coordinate_systems.json,sha256=lnPqe
 opengeodeweb_back/routes/schemas/inspect_file.json,sha256=WoFF2hgZCUfqSDFJRq1sLpivjCQ6TCvSHPH8pKFY6KM,348
 opengeodeweb_back/routes/schemas/missing_files.json,sha256=eOBAkiphA-2xG6e-OAy7wcJK2FeY0YFYXJlLdr8SNSc,349
 opengeodeweb_back/routes/schemas/ping.json,sha256=MhI5jtrjMsAsfIKEzdY8p1HyV9xv4O3hYfESWw6tkyE,162
-opengeodeweb_back/routes/schemas/polygon_attribute_names.json,sha256=HJ_zVLJNdVL1snoK2mSo5Rb0XOIgiPVq1VLaDTORe54,433
-opengeodeweb_back/routes/schemas/polyhedron_attribute_names.json,sha256=Fw6rcYxuHaiEAc_AcVzPy5ibajcr4wW3jyb2r7T0m-c,436
+opengeodeweb_back/routes/schemas/polygon_attribute_names.json,sha256=1BrpfjcbRL1ZOL4azHIHirqXIc8tpu4xGnMRFEMEshU,241
+opengeodeweb_back/routes/schemas/polyhedron_attribute_names.json,sha256=Tt6fWBGOWgxOVC-n76_JbOQcZ-Ss-foPghMrQOY-DIE,244
 opengeodeweb_back/routes/schemas/save_viewable_file.json,sha256=pvvEdaC7bNASPMrl3bXzlcA5blgflK0EYp2hBDf74qY,424
-opengeodeweb_back/routes/schemas/texture_coordinates.json,sha256=oW84Vh34KfleK935fmMXnqJXy-vaLDd7g87O_PtSzfY,429
+opengeodeweb_back/routes/schemas/texture_coordinates.json,sha256=2uQueIl1jOmxFG_gIi_vJETR4IurrwuSf8GAnzphk9g,237
 opengeodeweb_back/routes/schemas/upload_file.json,sha256=LJ3U3L5ApKuQDVFIpVT_y2alq4HW_suTvZ3HUucNbhg,219
-opengeodeweb_back/routes/schemas/vertex_attribute_names.json,sha256=bmXG0pzVHMUTZY_0iu6ruX7eMUVk8wr2H1o4eEtBlg0,432
-opengeodeweb_back-5.9.1.dist-info/licenses/LICENSE,sha256=LoTB-aqQvzTGxoTRXNnhNV0LKiqdk2bQv6MB34l8zkI,1079
-opengeodeweb_back-5.9.1.dist-info/METADATA,sha256=iSaDnlq8pdPVE0PKx1f-CdRPmUZ4uCiJXfjwDnul2F8,2672
-opengeodeweb_back-5.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opengeodeweb_back-5.9.1.dist-info/top_level.txt,sha256=tN1FZeLIVBrdja2-pbmhg5-tK-JILmmT9OeIBnhlUrQ,18
-opengeodeweb_back-5.9.1.dist-info/RECORD,,
+opengeodeweb_back/routes/schemas/vertex_attribute_names.json,sha256=ECIflohiqPZNsflAdkfEzksL4we0JvZhIxUd84Ubctg,240
+opengeodeweb_back-5.10.0.dist-info/licenses/LICENSE,sha256=LoTB-aqQvzTGxoTRXNnhNV0LKiqdk2bQv6MB34l8zkI,1079
+opengeodeweb_back-5.10.0.dist-info/METADATA,sha256=mP_Wll4jLDiW3TFxMjs4RBl_ArkFnYOYcM5_CcofQqs,2836
+opengeodeweb_back-5.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opengeodeweb_back-5.10.0.dist-info/top_level.txt,sha256=tN1FZeLIVBrdja2-pbmhg5-tK-JILmmT9OeIBnhlUrQ,18
+opengeodeweb_back-5.10.0.dist-info/RECORD,,