OpenGeodeWeb-Back 6.14.1rc1__tar.gz → 6.14.2rc1__tar.gz

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.14.1rc1
+Version: 6.14.2rc1
 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
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: asgiref==3.*
 Requires-Dist: blinker==1.*
 Requires-Dist: click==8.*
+Requires-Dist: defusedxml==0.7.1
 Requires-Dist: flask[async]==3.*
 Requires-Dist: flask-cors==6.0.2
 Requires-Dist: geode-common==33.26.6
@@ -21,14 +22,15 @@ Requires-Dist: geode-viewables==3.5.2
 Requires-Dist: itsdangerous==2.*
 Requires-Dist: jinja2==3.*
 Requires-Dist: markupsafe==3.*
-Requires-Dist: opengeode-core==18.4.0
+Requires-Dist: opengeode-core==18.4.1
 Requires-Dist: opengeode-geosciences==9.8.1
 Requires-Dist: opengeode-geosciencesio==5.11.1
 Requires-Dist: opengeode-inspector==6.12.1
 Requires-Dist: opengeode-inspector-geosciences==1.2.1
 Requires-Dist: opengeode-io==7.10.0
+Requires-Dist: types-defusedxml==0.7.0.20260504
 Requires-Dist: werkzeug==3.1.8
-Requires-Dist: opengeodeweb-microservice==1.*,>=1.3.1
+Requires-Dist: opengeodeweb-microservice==1.*,>=1.3.2rc1
 Dynamic: license-file
 
 <h1 align="center">OpenGeodeWeb-Back<sup><i>by Geode-solutions</i></sup></h1>

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "6.14.1-rc.1"
+version = "6.14.2-rc.1"
 dynamic = ["dependencies"]
 authors = [{ name = "Geode-solutions", email = "team-web@geode-solutions.com" }]
 description = "OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem"

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/requirements.txt

@@ -10,6 +10,8 @@ blinker==1.*
     # via flask
 click==8.*
     # via flask
+defusedxml==0.7.1
+    # via -r requirements.in
 flask[async]==3.*
     # via
     #   -r requirements.in
@@ -31,7 +33,7 @@ markupsafe==3.*
     #   flask
     #   jinja2
     #   werkzeug
-opengeode-core==18.4.0
+opengeode-core==18.4.1
     # via
     #   -r requirements.in
     #   geode-common
@@ -60,10 +62,12 @@ opengeode-io==7.10.0
     #   -r requirements.in
     #   geode-viewables
     #   opengeode-geosciencesio
+types-defusedxml==0.7.0.20260504
+    # via -r requirements.in
 werkzeug==3.1.8
     # via
     #   -r requirements.in
     #   flask
     #   flask-cors
 
-opengeodeweb-microservice==1.*,>=1.3.1
+opengeodeweb-microservice==1.*,>=1.3.2rc1

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/src/OpenGeodeWeb_Back.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.14.1rc1
+Version: 6.14.2rc1
 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
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: asgiref==3.*
 Requires-Dist: blinker==1.*
 Requires-Dist: click==8.*
+Requires-Dist: defusedxml==0.7.1
 Requires-Dist: flask[async]==3.*
 Requires-Dist: flask-cors==6.0.2
 Requires-Dist: geode-common==33.26.6
@@ -21,14 +22,15 @@ Requires-Dist: geode-viewables==3.5.2
 Requires-Dist: itsdangerous==2.*
 Requires-Dist: jinja2==3.*
 Requires-Dist: markupsafe==3.*
-Requires-Dist: opengeode-core==18.4.0
+Requires-Dist: opengeode-core==18.4.1
 Requires-Dist: opengeode-geosciences==9.8.1
 Requires-Dist: opengeode-geosciencesio==5.11.1
 Requires-Dist: opengeode-inspector==6.12.1
 Requires-Dist: opengeode-inspector-geosciences==1.2.1
 Requires-Dist: opengeode-io==7.10.0
+Requires-Dist: types-defusedxml==0.7.0.20260504
 Requires-Dist: werkzeug==3.1.8
-Requires-Dist: opengeodeweb-microservice==1.*,>=1.3.1
+Requires-Dist: opengeodeweb-microservice==1.*,>=1.3.2rc1
 Dynamic: license-file
 
 <h1 align="center">OpenGeodeWeb-Back<sup><i>by Geode-solutions</i></sup></h1>

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -51,7 +51,9 @@ src/opengeodeweb_back/geode_objects/geode_tetrahedral_solid3d.py
 src/opengeodeweb_back/geode_objects/geode_triangulated_surface2d.py
 src/opengeodeweb_back/geode_objects/geode_triangulated_surface3d.py
 src/opengeodeweb_back/geode_objects/geode_vertex_set.py
+src/opengeodeweb_back/routes/__init__.py
 src/opengeodeweb_back/routes/blueprint_routes.py
+src/opengeodeweb_back/routes/create/__init__.py
 src/opengeodeweb_back/routes/create/blueprint_create.py
 src/opengeodeweb_back/routes/create/schemas/__init__.py
 src/opengeodeweb_back/routes/create/schemas/edged_curve.json

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/src/OpenGeodeWeb_Back.egg-info/requires.txt

@@ -1,6 +1,7 @@
 asgiref==3.*
 blinker==1.*
 click==8.*
+defusedxml==0.7.1
 flask[async]==3.*
 flask-cors==6.0.2
 geode-common==33.26.6
@@ -8,11 +9,12 @@ geode-viewables==3.5.2
 itsdangerous==2.*
 jinja2==3.*
 markupsafe==3.*
-opengeode-core==18.4.0
+opengeode-core==18.4.1
 opengeode-geosciences==9.8.1
 opengeode-geosciencesio==5.11.1
 opengeode-inspector==6.12.1
 opengeode-inspector-geosciences==1.2.1
 opengeode-io==7.10.0
+types-defusedxml==0.7.0.20260504
 werkzeug==3.1.8
-opengeodeweb-microservice==1.*,>=1.3.1
+opengeodeweb-microservice==1.*,>=1.3.2rc1

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/src/opengeodeweb_back/app.py

@@ -1,75 +1,82 @@
 """Packages"""
 
+from __future__ import annotations
+
 import argparse
-import os
-from threading import Timer
-from typing import Any
+import json
+import logging
+import queue
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
 import flask
-import flask_cors  # type: ignore
+import flask_cors  # type: ignore[import-untyped]
 from flask import Flask, Response
 from flask_cors import cross_origin
+from opengeodeweb_microservice.database import connection
 from werkzeug.exceptions import HTTPException
-from opengeodeweb_back import utils_functions, app_config
+
+from opengeodeweb_back import app_config, utils_functions
 from opengeodeweb_back.routes import blueprint_routes
 from opengeodeweb_back.routes.create import blueprint_create
-from opengeodeweb_microservice.database import connection
 
-import queue
-import threading
-import json
-from typing import Any, Dict, Generator, Tuple
+if TYPE_CHECKING:
+    from collections.abc import Generator
 
+logger = logging.getLogger(__name__)
 
-def create_app(name: str) -> flask.Flask:
-    app = flask.Flask(name)
 
+def _register_request_hooks(app: flask.Flask) -> None:
     @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"
-            )
+            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)
+
+
+def _register_event_stream(app: flask.Flask) -> None:
     def wants_event_stream() -> bool:
         accept = flask.request.headers.get("Accept", "")
         return "text/event-stream" in accept
 
     _event_queue: queue.Queue[tuple[str, dict[str, Any]]] = queue.Queue()
-    _lock = threading.Lock()
 
     def publish_event(event: str, data: dict[str, Any]) -> None:
         _event_queue.put((event, data))
 
-    def stream_events() -> Generator[str, None, None]:
+    def stream_events() -> Generator[str]:
         while True:
             event, data = _event_queue.get()
             yield f"event: {event}\ndata: {json.dumps(data)}\n\n"
 
     @app.after_request
     def after_request(response: flask.Response) -> flask.Response:
-        endpoint = (
-            flask.request.endpoint.replace(".", "/") if flask.request.endpoint else None
-        )
-        if endpoint == "events" or endpoint == None:
+        endpoint = flask.request.endpoint.replace(".", "/") if flask.request.endpoint else None
+        if endpoint in {"events", None}:
             return response
 
         if wants_event_stream():
             payload: dict[str, Any]
             try:
                 payload = response.get_json()
-            except Exception:
+            except ValueError:
                 payload = {"status": response.status_code}
             publish_event(endpoint, payload)
         return response
 
-    @app.teardown_request
-    def teardown_request(exception: BaseException | None) -> None:
-        utils_functions.teardown_request(flask.current_app, exception)
+    @app.route("/events")
+    def events() -> flask.Response:
+        return flask.Response(stream_events(), mimetype="text/event-stream")
 
+
+def _register_error_handlers(app: flask.Flask) -> None:
     @app.errorhandler(HTTPException)
     def errorhandler(exception: HTTPException) -> tuple[dict[str, Any], int] | Response:
         return utils_functions.handle_exception(exception)
@@ -78,16 +85,14 @@ def create_app(name: str) -> flask.Flask:
     def handle_generic_exception(exception: Exception) -> Response:
         return utils_functions.handle_unexpected_exception(exception)
 
-    @app.route("/events")
-    def events() -> flask.Response:
-        return flask.Response(stream_events(), mimetype="text/event-stream")
 
+def _register_base_routes(app: flask.Flask) -> None:
     @app.route(
         "/error",
         methods=["POST"],
     )
     def return_error() -> Response:
-        flask.abort(500, f"Test")
+        flask.abort(500, "Test")
         return flask.make_response({}, 500)
 
     @app.route(
@@ -104,6 +109,13 @@ def create_app(name: str) -> flask.Flask:
     def root() -> Response:
         return flask.make_response({}, 200)
 
+
+def create_app(name: str) -> flask.Flask:
+    app = flask.Flask(name)
+    _register_request_hooks(app)
+    _register_event_stream(app)
+    _register_error_handlers(app)
+    _register_base_routes(app)
     return app
 
 
@@ -127,8 +139,9 @@ def run_server(app: Flask) -> None:
     pre_args, _ = pre_parser.parse_known_args()
 
     if pre_args.project_folder_path is None:
-        raise ValueError("project_folder_path must be provided")
-    project_folder_path = os.path.abspath(pre_args.project_folder_path)
+        msg = "project_folder_path must be provided"
+        raise ValueError(msg)
+    project_folder_path = str(Path(pre_args.project_folder_path).resolve())
 
     if pre_args.debug:
         app.config.from_object(app_config.DevConfig(project_folder_path))
@@ -138,9 +151,7 @@ def run_server(app: Flask) -> None:
     parser = argparse.ArgumentParser(
         prog="OpenGeodeWeb-Back", description="Backend server for OpenGeodeWeb"
     )
-    parser.add_argument(
-        "--host", default=app.config.get("HOST"), type=str, help="Host to run on"
-    )
+    parser.add_argument("--host", default=app.config.get("HOST"), type=str, help="Host to run on")
     parser.add_argument(
         "-p",
         "--port",
@@ -192,9 +203,13 @@ def run_server(app: Flask) -> None:
     )
     args = parser.parse_args()
 
-    args.project_folder_path = os.path.abspath(args.project_folder_path)
+    args.project_folder_path = str(Path(args.project_folder_path).resolve())
 
-    print(f"{args=}", flush=True)
+    logging.basicConfig(
+        level=logging.DEBUG if args.debug else logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    )
+    logger.info("Arguments: %s", args)
 
     app.config.update(
         HOST=args.host,
@@ -209,16 +224,15 @@ def run_server(app: Flask) -> None:
 
     db_filename = app.config.get("DATABASE_FILENAME")
     if not isinstance(db_filename, str):
-        raise TypeError(
-            f"DATABASE_FILENAME config must be a string, got {db_filename!r}"
-        )
-    db_path = os.path.join(str(app.config.get("DATA_FOLDER_PATH")), db_filename)
-    os.makedirs(os.path.dirname(db_path), exist_ok=True)
+        msg = f"DATABASE_FILENAME config must be a string, got {db_filename!r}"
+        raise TypeError(msg)
+    db_path = Path(str(app.config.get("DATA_FOLDER_PATH"))) / db_filename
+    db_path.parent.mkdir(parents=True, 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)
+    logger.info("Database initialized at: %s", db_path)
 
     flask_cors.CORS(app, origins=args.allowed_origins)
     app.run(
@@ -233,7 +247,7 @@ def run_opengeodeweb_back() -> None:
     app = create_app(__name__)
     register_ogw_back_blueprints(app)
     run_server(app)
-    print("Server stopped", flush=True)
+    logger.info("Server stopped")
 
 
 # ''' Main '''

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/src/opengeodeweb_back/app_config.py

@@ -1,15 +1,17 @@
 # Standard library imports
-import os
 import time
+from pathlib import Path
 
 # Third party imports
+from flask.helpers import get_debug_flag
+
 # Local application imports
 
-base_dir = os.path.dirname(os.path.abspath(__file__))
+base_dir = Path(__file__).resolve().parent
 
 
-class Config(object):
-    FLASK_DEBUG = os.environ.get("FLASK_DEBUG", default=False)
+class Config:
+    FLASK_DEBUG = get_debug_flag()
     HOST = "localhost"
     PORT = "5000"
     CORS_HEADERS = "Content-Type"
@@ -18,11 +20,11 @@ class Config(object):
     LAST_PING_TIME = time.time()
     DATABASE_FILENAME = "project.db"
 
-    def __init__(self, project_folder_path: str):
+    def __init__(self, project_folder_path: str) -> None:
         self.PROJECT_FOLDER_PATH = project_folder_path
-        self.DATA_FOLDER_PATH = os.path.join(project_folder_path, "data")
-        self.EXTENSIONS_FOLDER_PATH = os.path.join(project_folder_path, "extensions")
-        self.UPLOAD_FOLDER_PATH = os.path.join(project_folder_path, "uploads")
+        self.DATA_FOLDER_PATH = str(Path(project_folder_path) / "data")
+        self.EXTENSIONS_FOLDER_PATH = str(Path(project_folder_path) / "extensions")
+        self.UPLOAD_FOLDER_PATH = str(Path(project_folder_path) / "uploads")
 
 
 class ProdConfig(Config):

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/src/opengeodeweb_back/geode_functions.py

@@ -1,9 +1,13 @@
+from __future__ import annotations
+
 # Standard library imports
-import os
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
 
 # Third party imports
-import werkzeug
 import flask
+import werkzeug
 from opengeodeweb_microservice.database.data import Data
 from opengeodeweb_microservice.database.data_types import (
     GeodeObjectType,
@@ -12,15 +16,20 @@ from opengeodeweb_microservice.database.data_types import (
 
 # Local application imports
 from .geode_objects import geode_objects
-from .geode_objects.geode_object import GeodeObject
+
+if TYPE_CHECKING:
+    from .geode_objects.geode_object import GeodeObject
+
+
+logger = logging.getLogger(__name__)
 
 
 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)
+    data_path = Path(data_folder_path) / data_id
     if filename is not None:
-        return os.path.join(data_path, filename)
-    return data_path
+        return str(data_path / filename)
+    return str(data_path)
 
 
 def geode_object_from_string(value: str) -> type[GeodeObject]:
@@ -33,8 +42,11 @@ def load_geode_object(data_id: str) -> GeodeObject:
         flask.abort(404, f"Data with id {data_id} not found")
 
     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))
+    logger.debug(
+        "Loading file: %s (exists: %s)",
+        file_absolute_path,
+        Path(file_absolute_path).exists(),
+    )
     return geode_object_from_string(data.geode_object).load(file_absolute_path)
 
 
@@ -48,7 +60,7 @@ def get_data_info(data_id: str) -> Data:
 def upload_file_path(filename: str) -> str:
     upload_folder = flask.current_app.config["UPLOAD_FOLDER_PATH"]
     secure_filename = werkzeug.utils.secure_filename(filename)
-    return os.path.abspath(os.path.join(upload_folder, secure_filename))
+    return str((Path(upload_folder) / secure_filename).resolve())
 
 
 def geode_object_output_extensions(
@@ -56,20 +68,16 @@ def geode_object_output_extensions(
 ) -> 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
-        )
+        output_extensions_method = getattr(mixin_geode_object, "output_extensions", None)
         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")
+        is_saveable_method = mixin_geode_object.is_saveable  # type: ignore[attr-defined]
         for output_extension in output_extensions:
-            bool_is_saveable = is_saveable_method(
-                geode_object, f"test.{output_extension}"
-            )
+            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

{opengeodeweb_back-6.14.1rc1 → opengeodeweb_back-6.14.2rc1}/src/opengeodeweb_back/geode_objects/__init__.py

@@ -1,37 +1,42 @@
 # Standard library imports
 from __future__ import annotations
 
-# Third party imports
-from opengeodeweb_microservice.database.data_types import GeodeObjectType
+from typing import TYPE_CHECKING
 
-# Local application imports
-from .geode_object import GeodeObject
+# Third party imports
 from .geode_brep import GeodeBRep
-from .geode_vertex_set import GeodeVertexSet
+from .geode_cross_section import GeodeCrossSection
+from .geode_edged_curve2d import GeodeEdgedCurve2D
+from .geode_edged_curve3d import GeodeEdgedCurve3D
 from .geode_graph import GeodeGraph
+from .geode_horizon_stack3d import GeodeHorizonStack3D
+from .geode_hybrid_solid3d import GeodeHybridSolid3D
+from .geode_implicit_cross_section import GeodeImplicitCrossSection
+from .geode_implicit_structural_model import GeodeImplicitStructuralModel
+from .geode_light_regular_grid2d import GeodeLightRegularGrid2D
+from .geode_light_regular_grid3d import GeodeLightRegularGrid3D
+
+# Local application imports
 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_raster_image2d import GeodeRasterImage2D
+from .geode_raster_image3d import GeodeRasterImage3D
+from .geode_regular_grid2d import GeodeRegularGrid2D
 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
-from .geode_horizon_stack3d import GeodeHorizonStack3D
+from .geode_tetrahedral_solid3d import GeodeTetrahedralSolid3D
+from .geode_triangulated_surface2d import GeodeTriangulatedSurface2D
+from .geode_triangulated_surface3d import GeodeTriangulatedSurface3D
+from .geode_vertex_set import GeodeVertexSet
+
+if TYPE_CHECKING:
+    from opengeodeweb_microservice.database.data_types import GeodeObjectType
+
+    from .geode_object import GeodeObject
 
 geode_objects: dict[GeodeObjectType, type[GeodeObject]] = {
     "VertexSet": GeodeVertexSet,