OpenGeodeWeb-Back 5.10.0rc22__py3-none-any.whl → 5.14.1__py3-none-any.whl

opengeodeweb_back/app.py

@@ -0,0 +1,173 @@
+"""Packages"""
+
+import argparse
+import os
+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"
+ORIGINS: Any = app.config.get("ORIGINS")
+TIMEOUT: int = int(app.config.get("MINUTES_BEFORE_TIMEOUT") or 30)
+SSL: Any = app.config.get("SSL")
+SECONDS_BETWEEN_SHUTDOWNS: float = float(
+    app.config.get("SECONDS_BETWEEN_SHUTDOWNS") or 60.0
+)
+
+
+@app.before_request
+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
+def teardown_request(exception: BaseException | None) -> None:
+    utils_functions.teardown_request(flask.current_app, exception)
+
+
+app.register_blueprint(
+    blueprint_routes.routes,
+    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(
+        utils_functions.kill_task, SECONDS_BETWEEN_SHUTDOWNS, app
+    )
+
+
+@app.errorhandler(HTTPException)
+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(
+    "/error",
+    methods=["POST"],
+)
+def return_error() -> Response:
+    flask.abort(500, f"Test")
+    return flask.make_response({}, 500)
+
+
+@app.route("/", methods=["POST"])
+@cross_origin()
+def root() -> Response:
+    return flask.make_response({}, 200)
+
+
+@app.route("/kill", methods=["POST"])
+@cross_origin()
+def kill() -> None:
+    print("Manual server kill, shutting down...", flush=True)
+    os._exit(0)
+
+
+def run_server() -> None:
+    parser = argparse.ArgumentParser(
+        prog="OpenGeodeWeb-Back", description="Backend server for OpenGeodeWeb"
+    )
+    parser.add_argument("--host", type=str, default=DEFAULT_HOST, help="Host to run on")
+    parser.add_argument(
+        "-p", "--port", type=int, default=DEFAULT_PORT, help="Port to listen on"
+    )
+    parser.add_argument(
+        "-d",
+        "--debug",
+        default=FLASK_DEBUG,
+        help="Whether to run in debug mode",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-dfp",
+        "--data_folder_path",
+        type=str,
+        default=DEFAULT_DATA_FOLDER_PATH,
+        help="Path to the folder where data is stored",
+    )
+    parser.add_argument(
+        "-ufp",
+        "--upload_folder_path",
+        type=str,
+        default=DEFAULT_DATA_FOLDER_PATH,
+        help="Path to the folder where uploads are stored",
+    )
+    parser.add_argument(
+        "-origins",
+        "--allowed_origins",
+        default=ORIGINS,
+        help="Origins that are allowed to connect to the server",
+    )
+    parser.add_argument(
+        "-t",
+        "--timeout",
+        default=TIMEOUT,
+        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}, "
+        f"Origins: {args.allowed_origins}",
+        flush=True,
+    )
+
+    db_filename: str = app.config.get("DATABASE_FILENAME") or "project.db"
+    db_path = os.path.join(args.data_folder_path, db_filename)
+    os.makedirs(os.path.dirname(db_path), exist_ok=True)
+    app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{db_path}"
+    app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+
+    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)
+
+
+# ''' Main '''
+if __name__ == "__main__":
+    run_server()

opengeodeweb_back/app_config.py

@@ -4,9 +4,6 @@ import time
 
 # Third party imports
 # Local application imports
-from opengeodeweb_microservice.database.connection import get_database
-
-DATABASE_FILENAME = "project.db"
 
 
 class Config(object):
@@ -18,7 +15,7 @@ class Config(object):
     REQUEST_COUNTER = 0
     LAST_REQUEST_TIME = time.time()
     LAST_PING_TIME = time.time()
-    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    DATABASE_FILENAME = "project.db"
 
 
 class ProdConfig(Config):
@@ -27,9 +24,6 @@ class ProdConfig(Config):
     MINUTES_BEFORE_TIMEOUT = "1"
     SECONDS_BETWEEN_SHUTDOWNS = "10"
     DATA_FOLDER_PATH = "/data"
-    SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.abspath(
-        os.path.join(DATA_FOLDER_PATH, DATABASE_FILENAME)
-        )}"
 
 
 class DevConfig(Config):
@@ -39,6 +33,3 @@ class DevConfig(Config):
     SECONDS_BETWEEN_SHUTDOWNS = "10"
     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,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,
+}