OpenGeodeWeb-Back 5.10.4__py3-none-any.whl → 5.14.1__py3-none-any.whl

opengeodeweb_back/app.py

@@ -2,32 +2,27 @@
 
 import argparse
 import os
-import time
 from typing import Any
-
 import flask
 import flask_cors  # type: ignore
 from flask import Flask, Response
 from flask_cors import cross_origin
 from werkzeug.exceptions import HTTPException
-
 from opengeodeweb_back import utils_functions, app_config
 from opengeodeweb_back.routes import blueprint_routes
 from opengeodeweb_back.routes.models import blueprint_models
+from opengeodeweb_back.routes.create import blueprint_create
 from opengeodeweb_microservice.database import connection
 
-
 """ Global config """
 app: Flask = flask.Flask(__name__)
 
 """ Config variables """
 FLASK_DEBUG = True if os.environ.get("FLASK_DEBUG", default=None) == "True" else False
-
 if FLASK_DEBUG == False:
     app.config.from_object(app_config.ProdConfig)
 else:
     app.config.from_object(app_config.DevConfig)
-
 DEFAULT_HOST: str = app.config.get("DEFAULT_HOST") or "localhost"
 DEFAULT_PORT: int = int(app.config.get("DEFAULT_PORT") or 5000)
 DEFAULT_DATA_FOLDER_PATH: str = app.config.get("DEFAULT_DATA_FOLDER_PATH") or "./data"
@@ -40,8 +35,13 @@ SECONDS_BETWEEN_SHUTDOWNS: float = float(
 
 
 @app.before_request
-def before_request() -> None:
+def before_request() -> flask.Response | None:
+    if flask.request.method == "OPTIONS":
+        response = flask.make_response()
+        response.headers["Access-Control-Allow-Methods"] = "GET,POST,PUT,DELETE,OPTIONS"
+        return response
     utils_functions.before_request(flask.current_app)
+    return None
 
 
 @app.teardown_request
@@ -54,12 +54,16 @@ app.register_blueprint(
     url_prefix="/opengeodeweb_back",
     name="opengeodeweb_back",
 )
-
 app.register_blueprint(
     blueprint_models.routes,
     url_prefix="/opengeodeweb_back/models",
     name="opengeodeweb_models",
 )
+app.register_blueprint(
+    blueprint_create.routes,
+    url_prefix="/opengeodeweb_back/create",
+    name="opengeodeweb_create",
+)
 
 if FLASK_DEBUG == False:
     utils_functions.set_interval(
@@ -68,8 +72,14 @@ if FLASK_DEBUG == False:
 
 
 @app.errorhandler(HTTPException)
-def errorhandler(e: HTTPException) -> tuple[dict[str, Any], int] | Response:
-    return utils_functions.handle_exception(e)
+def errorhandler(exception: HTTPException) -> tuple[dict[str, Any], int] | Response:
+    return utils_functions.handle_exception(exception)
+
+
+@app.errorhandler(Exception)
+def handle_generic_exception(exception: Exception) -> Response:
+    print("\033[91mError:\033[0m \033[91m" + str(exception) + "\033[0m", flush=True)
+    return flask.make_response({"description": str(exception)}, 500)
 
 
 @app.route(
@@ -136,13 +146,10 @@ def run_server() -> None:
         help="Number of minutes before the server times out",
     )
     args = parser.parse_args()
-
     app.config.update(DATA_FOLDER_PATH=args.data_folder_path)
     app.config.update(UPLOAD_FOLDER=args.upload_folder_path)
     app.config.update(MINUTES_BEFORE_TIMEOUT=args.timeout)
-
     flask_cors.CORS(app, origins=args.allowed_origins)
-
     print(
         f"Host: {args.host}, Port: {args.port}, Debug: {args.debug}, "
         f"Data folder path: {args.data_folder_path}, Timeout: {args.timeout}, "
@@ -158,7 +165,6 @@ def run_server() -> None:
 
     connection.init_database(db_path)
     print(f"Database initialized at: {db_path}", flush=True)
-
     app.run(debug=args.debug, host=args.host, port=args.port, ssl_context=SSL)
 
 

opengeodeweb_back/geode_functions.py

@@ -2,75 +2,47 @@
 import os
 
 # Third party imports
-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 .geode_objects import geode_objects
+from .geode_objects.types import (
+    GeodeObjectType,
+    geode_object_type,
+)
+from .geode_objects.geode_object import GeodeObject
 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 data_file_path(data_id: str, filename: str | None = None) -> str:
+    data_folder_path = flask.current_app.config["DATA_FOLDER_PATH"]
+    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(geode_object: str, file_absolute_path: str):
-    return geode_object_value(geode_object)["load"](file_absolute_path)
 
+def geode_object_from_string(value: str) -> type[GeodeObject]:
+    return geode_objects[geode_object_type(value)]
 
-def data_file_path(data_id: str, filename: str = "") -> 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)
 
-
-def load_data(data_id: str) -> Any:
-    data_entry = Data.get(data_id)
-    if not data_entry:
+def load_geode_object(data_id: str) -> GeodeObject:
+    data = Data.get(data_id)
+    if not data:
         flask.abort(404, f"Data with id {data_id} not found")
 
-    file_absolute_path = data_file_path(data_id, data_entry.native_file_name)
+    file_absolute_path = data_file_path(data_id, data.native_file)
     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_object_from_string(data.geode_object).load(file_absolute_path)
 
 
 def get_data_info(data_id: str) -> Data:
-    data_entry = Data.get(data_id)
-    if not data_entry:
+    data = Data.get(data_id)
+    if not data:
         flask.abort(404, f"Data with id {data_id} not found")
-    return data_entry
+    return data
 
 
 def upload_file_path(filename: str) -> str:
@@ -79,237 +51,26 @@ 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_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_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_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():
-        if key != None and key != "":
-            if key in value:
-                if type(value[key]) == bool:
-                    geode_objects_filtered_list.append(geode_object)
-                else:
-                    geode_objects_filtered_list.append(geode_object)
-        else:
-            geode_objects_filtered_list.append(geode_object)
-    geode_objects_filtered_list.sort()
-    return geode_objects_filtered_list
-
-
-def list_input_extensions(key: str = None):
-    extensions_list = []
-    geode_objects_filtered_list = filter_geode_objects(key)
-    for geode_object in geode_objects_filtered_list:
-        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):
-    return input_factory(geode_object).has_creator(extension)
-
-
-def list_geode_objects(
-    file_absolute_path: str,
-    key: str = None,
-):
-    return_dict = {}
-    file_extension = utils_functions.extension_from_filename(
-        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)
-            priority_score = object_priority(geode_object, file_absolute_path)
-            return_dict[geode_object] = {
-                "is_loadable": loadability_score,
-                "object_priority": priority_score,
-            }
-    return return_dict
-
-
-def geode_objects_output_extensions(geode_object: str, data):
-    geode_objects_output_extensions_dict = {}
-    output_extensions = geode_object_output_extensions(geode_object)
-    extensions_dict = {}
-    for output_extension in output_extensions:
-        bool_is_saveable = is_saveable(geode_object, data, f"test.{output_extension}")
-        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"]
-        geode_objects_output_extensions_dict.update(
-            geode_objects_output_extensions(parent_geode_object, data)
-        )
-    return geode_objects_output_extensions_dict
-
-
-def get_inspector_children(obj):
-    new_object = {}
-
-    if "inspection_type" in dir(obj):
-        new_object["title"] = obj.inspection_type()
-        new_object["nb_issues"] = 0
-        new_object["children"] = []
-        for child in dir(obj):
-            if not child.startswith("__") and not child in [
-                "inspection_type",
-                "string",
-            ]:
-                child_instance = obj.__getattribute__(child)
-                child_object = get_inspector_children(child_instance)
-                new_object["children"].append(child_object)
-                new_object["nb_issues"] += child_object["nb_issues"]
-    else:
-        new_object["title"] = obj.description()
-        nb_issues = obj.nb_issues()
-        new_object["nb_issues"] = nb_issues
-        if nb_issues > 0:
-            issues = obj.string().split("\n")
-            new_object["issues"] = issues
-    return new_object
-
-
-def geographic_coordinate_systems(geode_object: str):
-    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):
-    if is_3D(geode_object):
-        return og_gs.GeographicCoordinateSystemInfo3D(
-            crs["authority"], crs["code"], crs["name"]
+def geode_object_output_extensions(
+    geode_object: GeodeObject,
+) -> dict[GeodeObjectType, dict[str, bool]]:
+    results: dict[GeodeObjectType, dict[str, bool]] = {}
+    for mixin_geode_object in geode_objects[geode_object.geode_object_type()].__mro__:
+        output_extensions_method = getattr(
+            mixin_geode_object, "output_extensions", None
         )
-    else:
-        return og_gs.GeographicCoordinateSystemInfo2D(
-            crs["authority"], crs["code"], crs["name"]
-        )
-
-
-def coordinate_system(geode_object: str, coordinate_system):
-    return og.CoordinateSystem2D(
-        [
-            og.Vector2D(
-                og.Point2D(
-                    [coordinate_system["origin_x"], coordinate_system["origin_y"]]
-                ),
-                og.Point2D(
-                    [coordinate_system["point_1_x"], coordinate_system["point_1_y"]]
-                ),
-            ),
-            og.Vector2D(
-                og.Point2D(
-                    [coordinate_system["origin_x"], coordinate_system["origin_y"]]
-                ),
-                og.Point2D(
-                    [coordinate_system["point_2_x"], coordinate_system["point_2_y"]]
-                ),
-            ),
-        ],
-        og.Point2D([coordinate_system["origin_x"], coordinate_system["origin_y"]]),
-    )
-
-
-def assign_geographic_coordinate_system_info(geode_object: str, 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):
-    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
-):
-    input_coordiante_system = coordinate_system(geode_object, input_coordinate_points)
-    output_coordiante_system = coordinate_system(geode_object, output_coordinate_points)
-    create_crs(
-        geode_object, data, name, input_coordiante_system, output_coordiante_system
-    )
+        if output_extensions_method is None:
+            continue
+        output_extensions = output_extensions_method.__func__(mixin_geode_object)
+        if output_extensions is None:
+            continue
+        object_output_extensions: dict[str, bool] = {}
+        is_saveable_method = getattr(mixin_geode_object, "is_saveable")
+        for output_extension in output_extensions:
+            bool_is_saveable = is_saveable_method(
+                geode_object, f"test.{output_extension}"
+            )
+            object_output_extensions[output_extension] = bool_is_saveable
+        if hasattr(mixin_geode_object, "geode_object_type"):
+            results[mixin_geode_object.geode_object_type()] = object_output_extensions
+    return results

opengeodeweb_back/geode_objects/__init__.py

@@ -0,0 +1,61 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+
+# Local application imports
+from .types import GeodeObjectType
+from .geode_object import GeodeObject
+from .geode_brep import GeodeBRep
+from .geode_vertex_set import GeodeVertexSet
+from .geode_graph import GeodeGraph
+from .geode_point_set2d import GeodePointSet2D
+from .geode_point_set3d import GeodePointSet3D
+from .geode_edged_curve2d import GeodeEdgedCurve2D
+from .geode_edged_curve3d import GeodeEdgedCurve3D
+from .geode_raster_image2d import GeodeRasterImage2D
+from .geode_raster_image3d import GeodeRasterImage3D
+from .geode_polygonal_surface2d import GeodePolygonalSurface2D
+from .geode_polygonal_surface3d import GeodePolygonalSurface3D
+from .geode_triangulated_surface2d import GeodeTriangulatedSurface2D
+from .geode_triangulated_surface3d import GeodeTriangulatedSurface3D
+from .geode_regular_grid2d import GeodeRegularGrid2D
+from .geode_polyhedral_solid3d import GeodePolyhedralSolid3D
+from .geode_tetrahedral_solid3d import GeodeTetrahedralSolid3D
+from .geode_hybrid_solid3d import GeodeHybridSolid3D
+from .geode_regular_grid3d import GeodeRegularGrid3D
+from .geode_light_regular_grid2d import GeodeLightRegularGrid2D
+from .geode_light_regular_grid3d import GeodeLightRegularGrid3D
+from .geode_section import GeodeSection
+from .geode_structural_model import GeodeStructuralModel
+from .geode_cross_section import GeodeCrossSection
+from .geode_implicit_structural_model import GeodeImplicitStructuralModel
+from .geode_implicit_cross_section import GeodeImplicitCrossSection
+
+geode_objects: dict[GeodeObjectType, type[GeodeObject]] = {
+    "VertexSet": GeodeVertexSet,
+    "Graph": GeodeGraph,
+    "PointSet2D": GeodePointSet2D,
+    "PointSet3D": GeodePointSet3D,
+    "EdgedCurve2D": GeodeEdgedCurve2D,
+    "EdgedCurve3D": GeodeEdgedCurve3D,
+    "RasterImage2D": GeodeRasterImage2D,
+    "RasterImage3D": GeodeRasterImage3D,
+    "PolygonalSurface2D": GeodePolygonalSurface2D,
+    "PolygonalSurface3D": GeodePolygonalSurface3D,
+    "TriangulatedSurface2D": GeodeTriangulatedSurface2D,
+    "TriangulatedSurface3D": GeodeTriangulatedSurface3D,
+    "RegularGrid2D": GeodeRegularGrid2D,
+    "PolyhedralSolid3D": GeodePolyhedralSolid3D,
+    "TetrahedralSolid3D": GeodeTetrahedralSolid3D,
+    "HybridSolid3D": GeodeHybridSolid3D,
+    "RegularGrid3D": GeodeRegularGrid3D,
+    "LightRegularGrid2D": GeodeLightRegularGrid2D,
+    "LightRegularGrid3D": GeodeLightRegularGrid3D,
+    "BRep": GeodeBRep,
+    "Section": GeodeSection,
+    "StructuralModel": GeodeStructuralModel,
+    "CrossSection": GeodeCrossSection,
+    "ImplicitStructuralModel": GeodeImplicitStructuralModel,
+    "ImplicitCrossSection": GeodeImplicitCrossSection,
+}

opengeodeweb_back/geode_objects/geode_brep.py

@@ -0,0 +1,102 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_geosciences as og_geosciences
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeModelType
+from .geode_model import GeodeModel, ComponentRegistry
+
+
+class GeodeBRep(GeodeModel):
+    brep: og.BRep
+
+    def __init__(self, brep: og.BRep | None = None) -> None:
+        self.brep = brep if brep is not None else og.BRep()
+        super().__init__(self.brep)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeModelType:
+        return "BRep"
+
+    def native_extension(self) -> str:
+        return self.brep.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.BRepBuilder:
+        return og.BRepBuilder(self.brep)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeBRep:
+        return GeodeBRep(og.load_brep(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.brep_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_brep_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.BRepInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.BRepOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.brep_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_brep_saveable(self.brep, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_brep(self.brep, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_brep(self.brep, filename_without_extension)
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_brep(self.brep, filename_without_extension)
+
+    def mesh_components(self) -> ComponentRegistry:
+        return self.brep.mesh_components()
+
+    def inspect(self) -> og_inspector.BRepInspectionResult:
+        return og_inspector.inspect_brep(self.brep)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_brep_geographic_coordinate_system_info(
+            self.brep, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_brep_coordinate_reference_system(
+            self.brep, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_brep_coordinate_system(self.brep, builder, crs_name, input, output)