OpenGeodeWeb-Back 5.11.0__py3-none-any.whl → 5.11.1rc1__py3-none-any.whl

opengeodeweb_back/geode_functions.py

@@ -175,7 +175,7 @@ def filter_geode_objects(key: str = None):
     return geode_objects_filtered_list
 
 
-def list_input_extensions(key: str = None):
+def list_input_extensions(key: str | None = None) -> list[str]:
     extensions_list = []
     geode_objects_filtered_list = filter_geode_objects(key)
     for geode_object in geode_objects_filtered_list:
@@ -192,7 +192,7 @@ def has_creator(geode_object: str, extension: str):
 
 def list_geode_objects(
     file_absolute_path: str,
-    key: str = None,
+    key: str | None = None,
 ):
     return_dict = {}
     file_extension = utils_functions.extension_from_filename(

opengeodeweb_back/routes/blueprint_routes.py

@@ -1,18 +1,16 @@
 # Standard library imports
-import json
 import os
 import time
 
 # Third party imports
 import flask
-import opengeode
 import werkzeug
+from opengeodeweb_microservice.schemas import get_schemas_dict
 
 # Local application imports
-from .. import geode_functions, utils_functions
-from opengeodeweb_microservice.database.data import Data
-from opengeodeweb_microservice.database.connection import get_session
+from opengeodeweb_back import geode_functions, utils_functions
 from .models import blueprint_models
+from . import schemas
 
 routes = flask.Blueprint("routes", __name__, url_prefix="/opengeodeweb_back")
 
@@ -23,39 +21,25 @@ routes.register_blueprint(
     name=blueprint_models.routes.name,
 )
 
-schemas = os.path.join(os.path.dirname(__file__), "schemas")
-
-with open(
-    os.path.join(schemas, "allowed_files.json"),
-    "r",
-) as file:
-    allowed_files_json = json.load(file)
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
 
 
 @routes.route(
-    allowed_files_json["route"],
-    methods=allowed_files_json["methods"],
+    schemas_dict["allowed_files"]["route"],
+    methods=schemas_dict["allowed_files"]["methods"],
 )
-def allowed_files():
-    utils_functions.validate_request(flask.request, allowed_files_json)
-    extensions = geode_functions.list_input_extensions(
-        flask.request.get_json()["supported_feature"]
-    )
+def allowed_files() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["allowed_files"])
+    params = schemas.AllowedFiles.from_dict(flask.request.get_json())
+    extensions = geode_functions.list_input_extensions(params.supported_feature)
     return flask.make_response({"extensions": extensions}, 200)
 
 
-with open(
-    os.path.join(schemas, "upload_file.json"),
-    "r",
-) as file:
-    upload_file_json = json.load(file)
-
-
 @routes.route(
-    upload_file_json["route"],
-    methods=upload_file_json["methods"],
+    schemas_dict["upload_file"]["route"],
+    methods=schemas_dict["upload_file"]["methods"],
 )
-def upload_file():
+def upload_file() -> flask.Response:
     if flask.request.method == "OPTIONS":
         return flask.make_response({}, 200)
 
@@ -68,48 +52,34 @@ def upload_file():
     return flask.make_response({"message": "File uploaded"}, 201)
 
 
-with open(
-    os.path.join(schemas, "allowed_objects.json"),
-    "r",
-) as file:
-    allowed_objects_json = json.load(file)
-
-
 @routes.route(
-    allowed_objects_json["route"],
-    methods=allowed_objects_json["methods"],
+    schemas_dict["allowed_objects"]["route"],
+    methods=schemas_dict["allowed_objects"]["methods"],
 )
-def allowed_objects():
+def allowed_objects() -> flask.Response:
     if flask.request.method == "OPTIONS":
         return flask.make_response({}, 200)
 
-    utils_functions.validate_request(flask.request, allowed_objects_json)
-    file_absolute_path = geode_functions.upload_file_path(
-        flask.request.get_json()["filename"]
-    )
+    utils_functions.validate_request(flask.request, schemas_dict["allowed_objects"])
+    params = schemas.AllowedObjects.from_dict(flask.request.get_json())
+    file_absolute_path = geode_functions.upload_file_path(params.filename)
     allowed_objects = geode_functions.list_geode_objects(
-        file_absolute_path, flask.request.get_json()["supported_feature"]
+        file_absolute_path, params.supported_feature
     )
     return flask.make_response({"allowed_objects": allowed_objects}, 200)
 
 
-with open(
-    os.path.join(schemas, "missing_files.json"),
-    "r",
-) as file:
-    missing_files_json = json.load(file)
-
-
 @routes.route(
-    missing_files_json["route"],
-    methods=missing_files_json["methods"],
+    schemas_dict["missing_files"]["route"],
+    methods=schemas_dict["missing_files"]["methods"],
 )
-def missing_files():
-    utils_functions.validate_request(flask.request, missing_files_json)
-    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
+def missing_files() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["missing_files"])
+    params = schemas.MissingFiles.from_dict(flask.request.get_json())
+    file_path = geode_functions.upload_file_path(params.filename)
 
     additional_files = geode_functions.additional_files(
-        flask.request.get_json()["input_geode_object"],
+        params.input_geode_object,
         file_path,
     )
 
@@ -139,22 +109,16 @@ def missing_files():
     )
 
 
-with open(
-    os.path.join(schemas, "geographic_coordinate_systems.json"),
-    "r",
-) as file:
-    geographic_coordinate_systems_json = json.load(file)
-
-
 @routes.route(
-    geographic_coordinate_systems_json["route"],
-    methods=geographic_coordinate_systems_json["methods"],
+    schemas_dict["geographic_coordinate_systems"]["route"],
+    methods=schemas_dict["geographic_coordinate_systems"]["methods"],
 )
-def crs_converter_geographic_coordinate_systems():
-    utils_functions.validate_request(flask.request, geographic_coordinate_systems_json)
-    infos = geode_functions.geographic_coordinate_systems(
-        flask.request.get_json()["input_geode_object"]
+def crs_converter_geographic_coordinate_systems() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["geographic_coordinate_systems"]
     )
+    params = schemas.GeographicCoordinateSystems.from_dict(flask.request.get_json())
+    infos = geode_functions.geographic_coordinate_systems(params.input_geode_object)
     crs_list = []
     for info in infos:
         crs = {}
@@ -166,55 +130,36 @@ def crs_converter_geographic_coordinate_systems():
     return flask.make_response({"crs_list": crs_list}, 200)
 
 
-with open(
-    os.path.join(schemas, "inspect_file.json"),
-    "r",
-) as file:
-    inspect_file_json = json.load(file)
-
-
 @routes.route(
-    inspect_file_json["route"],
-    methods=inspect_file_json["methods"],
+    schemas_dict["inspect_file"]["route"],
+    methods=schemas_dict["inspect_file"]["methods"],
 )
-def inspect_file():
-    utils_functions.validate_request(flask.request, inspect_file_json)
-
-    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.get_json()["input_geode_object"], data
-    )
+def inspect_file() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["inspect_file"])
+    params = schemas.InspectFile.from_dict(flask.request.get_json())
+    file_path = geode_functions.upload_file_path(params.filename)
+    data = geode_functions.load(params.input_geode_object, file_path)
+    class_inspector = geode_functions.inspect(params.input_geode_object, data)
     inspection_result = geode_functions.get_inspector_children(class_inspector)
     return flask.make_response({"inspection_result": inspection_result}, 200)
 
 
-with open(
-    os.path.join(schemas, "geode_objects_and_output_extensions.json"),
-    "r",
-) as file:
-    geode_objects_and_output_extensions_json = json.load(file)
-
-
 @routes.route(
-    geode_objects_and_output_extensions_json["route"],
-    methods=geode_objects_and_output_extensions_json["methods"],
+    schemas_dict["geode_objects_and_output_extensions"]["route"],
+    methods=schemas_dict["geode_objects_and_output_extensions"]["methods"],
 )
-def geode_objects_and_output_extensions():
+def geode_objects_and_output_extensions() -> flask.Response:
     utils_functions.validate_request(
-        flask.request, geode_objects_and_output_extensions_json
+        flask.request, schemas_dict["geode_objects_and_output_extensions"]
     )
-    file_path = geode_functions.upload_file_path(flask.request.get_json()["filename"])
+    params = schemas.GeodeObjectsAndOutputExtensions.from_dict(flask.request.get_json())
+    file_path = geode_functions.upload_file_path(params.filename)
     data = geode_functions.load(
-        flask.request.get_json()["input_geode_object"],
+        params.input_geode_object,
         file_path,
     )
     geode_objects_and_output_extensions = (
-        geode_functions.geode_objects_output_extensions(
-            flask.request.get_json()["input_geode_object"], data
-        )
+        geode_functions.geode_objects_output_extensions(params.input_geode_object, data)
     )
     return flask.make_response(
         {"geode_objects_and_output_extensions": geode_objects_and_output_extensions},
@@ -222,57 +167,44 @@ def geode_objects_and_output_extensions():
     )
 
 
-with open(
-    os.path.join(schemas, "save_viewable_file.json"),
-    "r",
-) as file:
-    save_viewable_file_json = json.load(file)
-
-
 @routes.route(
-    save_viewable_file_json["route"],
-    methods=save_viewable_file_json["methods"],
+    schemas_dict["save_viewable_file"]["route"],
+    methods=schemas_dict["save_viewable_file"]["methods"],
 )
-def save_viewable_file():
-    utils_functions.validate_request(flask.request, save_viewable_file_json)
+def save_viewable_file() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["save_viewable_file"])
+    params = schemas.SaveViewableFile.from_dict(flask.request.get_json())
     return flask.make_response(
         utils_functions.generate_native_viewable_and_light_viewable_from_file(
-            geode_object=flask.request.get_json()["input_geode_object"],
-            input_filename=flask.request.get_json()["filename"],
+            geode_object=params.input_geode_object,
+            input_filename=params.filename,
         ),
         200,
     )
 
 
-with open(os.path.join(schemas, "texture_coordinates.json"), "r") as file:
-    texture_coordinates_json = json.load(file)
-
-
 @routes.route(
-    texture_coordinates_json["route"],
-    methods=texture_coordinates_json["methods"],
+    schemas_dict["texture_coordinates"]["route"],
+    methods=schemas_dict["texture_coordinates"]["methods"],
 )
-def texture_coordinates():
-    utils_functions.validate_request(flask.request, texture_coordinates_json)
-    data = geode_functions.load_data(flask.request.get_json().get("id"))
+def texture_coordinates() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["texture_coordinates"])
+    params = schemas.TextureCoordinates.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
     texture_coordinates = data.texture_manager().texture_names()
     return flask.make_response({"texture_coordinates": texture_coordinates}, 200)
 
 
-with open(
-    os.path.join(schemas, "vertex_attribute_names.json"),
-    "r",
-) as file:
-    vertex_attribute_names_json = json.load(file)
-
-
 @routes.route(
-    vertex_attribute_names_json["route"],
-    methods=vertex_attribute_names_json["methods"],
+    schemas_dict["vertex_attribute_names"]["route"],
+    methods=schemas_dict["vertex_attribute_names"]["methods"],
 )
-def vertex_attribute_names():
-    utils_functions.validate_request(flask.request, vertex_attribute_names_json)
-    data = geode_functions.load_data(flask.request.get_json().get("id"))
+def vertex_attribute_names() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["vertex_attribute_names"]
+    )
+    params = schemas.VertexAttributeNames.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
     vertex_attribute_names = data.vertex_attribute_manager().attribute_names()
     return flask.make_response(
         {
@@ -282,20 +214,16 @@ def vertex_attribute_names():
     )
 
 
-with open(
-    os.path.join(schemas, "polygon_attribute_names.json"),
-    "r",
-) as file:
-    polygon_attribute_names_json = json.load(file)
-
-
 @routes.route(
-    polygon_attribute_names_json["route"],
-    methods=polygon_attribute_names_json["methods"],
+    schemas_dict["polygon_attribute_names"]["route"],
+    methods=schemas_dict["polygon_attribute_names"]["methods"],
 )
-def polygon_attribute_names():
-    utils_functions.validate_request(flask.request, polygon_attribute_names_json)
-    data = geode_functions.load_data(flask.request.get_json().get("id"))
+def polygon_attribute_names() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["polygon_attribute_names"]
+    )
+    params = schemas.PolygonAttributeNames.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
     polygon_attribute_names = data.polygon_attribute_manager().attribute_names()
     return flask.make_response(
         {
@@ -305,20 +233,16 @@ def polygon_attribute_names():
     )
 
 
-with open(
-    os.path.join(schemas, "polyhedron_attribute_names.json"),
-    "r",
-) as file:
-    polyhedron_attribute_names_json = json.load(file)
-
-
 @routes.route(
-    polyhedron_attribute_names_json["route"],
-    methods=polyhedron_attribute_names_json["methods"],
+    schemas_dict["polyhedron_attribute_names"]["route"],
+    methods=schemas_dict["polyhedron_attribute_names"]["methods"],
 )
-def polyhedron_attribute_names():
-    utils_functions.validate_request(flask.request, polyhedron_attribute_names_json)
-    data = geode_functions.load_data(flask.request.get_json().get("id"))
+def polyhedron_attribute_names() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["polyhedron_attribute_names"]
+    )
+    params = schemas.PolyhedronAttributeNames.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
     polyhedron_attribute_names = data.polyhedron_attribute_manager().attribute_names()
     return flask.make_response(
         {
@@ -328,31 +252,17 @@ def polyhedron_attribute_names():
     )
 
 
-with open(
-    os.path.join(schemas, "ping.json"),
-    "r",
-) as file:
-    ping_json = json.load(file)
-
-
 @routes.route(
-    ping_json["route"],
-    methods=ping_json["methods"],
+    schemas_dict["ping"]["route"],
+    methods=schemas_dict["ping"]["methods"],
 )
-def ping():
-    utils_functions.validate_request(flask.request, ping_json)
+def ping() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["ping"])
     flask.current_app.config.update(LAST_PING_TIME=time.time())
     return flask.make_response({"message": "Flask server is running"}, 200)
 
 
-with open(
-    os.path.join(schemas, "kill.json"),
-    "r",
-) as file:
-    kill_json = json.load(file)
-
-
-@routes.route(kill_json["route"], methods=kill_json["methods"])
+@routes.route(schemas_dict["kill"]["route"], methods=schemas_dict["kill"]["methods"])
 def kill() -> flask.Response:
     print("Manual server kill, shutting down...", flush=True)
     os._exit(0)

opengeodeweb_back/routes/create/blueprint_create.py

@@ -1,117 +1,71 @@
 # Standard library imports
-import json
 import os
-from typing import Any, TypedDict
 
 # Third party imports
 import flask
 import opengeode
+from opengeodeweb_microservice.schemas import get_schemas_dict
 
 # Local application imports
 from opengeodeweb_back import geode_functions, utils_functions
+from . import schemas
 
 routes = flask.Blueprint("create", __name__, url_prefix="/create")
-schemas = os.path.join(os.path.dirname(__file__), "schemas")
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
 
-# --- Type definitions ---
-type SchemaDict = dict[str, Any]
 
-
-class PointDict(TypedDict):
-    x: float
-    y: float
-
-
-class CreatePointParams(TypedDict):
-    name: str
-    x: float
-    y: float
-    z: float
-
-
-class CreateAOIParams(TypedDict):
-    name: str
-    points: list[PointDict]
-    z: float
-
-
-# Load schemas
-with open(os.path.join(schemas, "create_point.json"), "r") as file:
-    create_point_json: SchemaDict = json.load(file)
-
-
-@routes.route(create_point_json["route"], methods=create_point_json["methods"])
+@routes.route(
+    schemas_dict["create_point"]["route"],
+    methods=schemas_dict["create_point"]["methods"],
+)
 def create_point() -> flask.Response:
     """Endpoint to create a single point in 3D space."""
     print(f"create_point : {flask.request=}", flush=True)
-    utils_functions.validate_request(flask.request, create_point_json)
-
-    # Extract and validate data from request
-    params: CreatePointParams = flask.request.get_json()
-    name = params["name"]
-    x = params["x"]
-    y = params["y"]
-    z = params["z"]
+    utils_functions.validate_request(flask.request, schemas_dict["create_point"])
+    params = schemas.CreatePoint.from_dict(flask.request.get_json())
 
     # Create the point
-    class_ = geode_functions.geode_object_class("PointSet3D")
-    pointset = class_.create()
+    pointset = geode_functions.geode_object_class("PointSet3D").create()
     builder = geode_functions.create_builder("PointSet3D", pointset)
-    builder.set_name(name)
-    builder.create_point(opengeode.Point3D([x, y, z]))
+    builder.set_name(params.name)
+    builder.create_point(opengeode.Point3D([params.x, params.y, params.z]))
 
     # Save and get info
     result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
         geode_object="PointSet3D",
         data=pointset,
     )
-    result["name"] = name
     return flask.make_response(result, 200)
 
 
-# Load schema for AOI creation
-with open(os.path.join(schemas, "create_aoi.json"), "r") as file:
-    create_aoi_json: SchemaDict = json.load(file)
-
-
-@routes.route(create_aoi_json["route"], methods=create_aoi_json["methods"])
+@routes.route(
+    schemas_dict["create_aoi"]["route"], methods=schemas_dict["create_aoi"]["methods"]
+)
 def create_aoi() -> flask.Response:
     """Endpoint to create an Area of Interest (AOI) as an EdgedCurve3D."""
     print(f"create_aoi : {flask.request=}", flush=True)
-    utils_functions.validate_request(flask.request, create_aoi_json)
-
-    # Extract and validate data from request
-    params: CreateAOIParams = flask.request.get_json()
-    name = params["name"]
-    points = params["points"]
-    z = params["z"]
+    utils_functions.validate_request(flask.request, schemas_dict["create_aoi"])
+    params = schemas.CreateAoi.from_dict(flask.request.get_json())
 
     # Create the edged curve
-    class_ = geode_functions.geode_object_class("EdgedCurve3D")
-    edged_curve = class_.create()
+    edged_curve = geode_functions.geode_object_class("EdgedCurve3D").create()
     builder = geode_functions.create_builder("EdgedCurve3D", edged_curve)
-    builder.set_name(name)
+    builder.set_name(params.name)
 
     # Create vertices first
-    vertex_indices: list[int] = []
-    for point in points:
-        vertex_id = builder.create_point(opengeode.Point3D([point["x"], point["y"], z]))
-        vertex_indices.append(vertex_id)
+    for point in params.points:
+        pp = opengeode.Point3D([point.x, point.y, params.z])
+        builder.create_point(opengeode.Point3D([point.x, point.y, params.z]))
 
     # Create edges between consecutive vertices and close the loop
-    num_vertices = len(vertex_indices)
+    num_vertices = len(params.points)
     for i in range(num_vertices):
         next_i = (i + 1) % num_vertices
-        edge_id = builder.create_edge()
-        builder.set_edge_vertex(opengeode.EdgeVertex(edge_id, 0), vertex_indices[i])
-        builder.set_edge_vertex(
-            opengeode.EdgeVertex(edge_id, 1), vertex_indices[next_i]
-        )
+        builder.create_edge_with_vertices(i, next_i)
 
     # Save and get info
     result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
         geode_object="EdgedCurve3D",
         data=edged_curve,
     )
-    result["name"] = name
     return flask.make_response(result, 200)

opengeodeweb_back/routes/create/schemas/__init__.py

@@ -0,0 +1,2 @@
+from .create_point import *
+from .create_aoi import *

opengeodeweb_back/routes/create/schemas/create_aoi.py

@@ -0,0 +1,19 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Point(DataClassJsonMixin):
+    x: float
+    y: float
+
+
+@dataclass
+class CreateAoi(DataClassJsonMixin):
+    name: str
+    """Name of the AOI"""
+
+    points: List[Point]
+    z: float
+    id: Optional[str] = None

opengeodeweb_back/routes/create/schemas/create_point.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class CreatePoint(DataClassJsonMixin):
+    name: str
+    x: float
+    y: float
+    z: float

opengeodeweb_back/routes/models/blueprint_models.py

@@ -1,29 +1,29 @@
-import json
 import os
 import xml.etree.ElementTree as ET
 import flask
-from ... import geode_functions, utils_functions
+from opengeodeweb_microservice.schemas import get_schemas_dict
 
-routes = flask.Blueprint("models", __name__, url_prefix="/models")
-
-
-schemas = os.path.join(os.path.dirname(__file__), "schemas")
+from opengeodeweb_back import geode_functions, utils_functions
+from . import schemas
 
-with open(os.path.join(schemas, "vtm_component_indices.json"), "r") as file:
-    vtm_component_indices_json = json.load(file)
+routes = flask.Blueprint("models", __name__, url_prefix="/models")
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
 
 
 @routes.route(
-    vtm_component_indices_json["route"], methods=vtm_component_indices_json["methods"]
+    schemas_dict["vtm_component_indices"]["route"],
+    methods=schemas_dict["vtm_component_indices"]["methods"],
 )
-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.get_json().get("id"), "viewable.vtm"
+def uuid_to_flat_index() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["vtm_component_indices"]
     )
+    params = schemas.VtmComponentIndices.from_dict(flask.request.get_json())
+    vtm_file_path = geode_functions.data_file_path(params.id, "viewable.vtm")
     tree = ET.parse(vtm_file_path)
     root = tree.find("vtkMultiBlockDataSet")
+    if root is None:
+        raise Exception("Failed to read viewable file")
     uuid_to_flat_index = {}
     current_index = 0
     for elem in root.iter():
@@ -33,22 +33,17 @@ def uuid_to_flat_index():
     return flask.make_response({"uuid_to_flat_index": uuid_to_flat_index}, 200)
 
 
-def extract_model_uuids(model):
+@routes.route(
+    schemas_dict["mesh_components"]["route"],
+    methods=schemas_dict["mesh_components"]["methods"],
+)
+def extract_uuids_endpoint() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["mesh_components"])
+    params = schemas.MeshComponents.from_dict(flask.request.get_json())
+    model = geode_functions.load_data(params.id)
     mesh_components = model.mesh_components()
     uuid_dict = {}
     for mesh_component, ids in mesh_components.items():
         component_name = mesh_component.get()
         uuid_dict[component_name] = [id.string() for id in ids]
-    return uuid_dict
-
-
-with open(os.path.join(schemas, "mesh_components.json"), "r") as file:
-    mesh_components_json = json.load(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.get_json().get("id"))
-    uuid_dict = extract_model_uuids(model)
     return flask.make_response({"uuid_dict": uuid_dict}, 200)

opengeodeweb_back/routes/models/schemas/__init__.py

@@ -0,0 +1,2 @@
+from .vtm_component_indices import *
+from .mesh_components import *

opengeodeweb_back/routes/models/schemas/mesh_components.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class MeshComponents(DataClassJsonMixin):
+    id: str

opengeodeweb_back/routes/models/schemas/vtm_component_indices.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class VtmComponentIndices(DataClassJsonMixin):
+    id: str

opengeodeweb_back/routes/schemas/__init__.py

@@ -0,0 +1,14 @@
+from .vertex_attribute_names import *
+from .upload_file import *
+from .texture_coordinates import *
+from .save_viewable_file import *
+from .polyhedron_attribute_names import *
+from .polygon_attribute_names import *
+from .ping import *
+from .missing_files import *
+from .kill import *
+from .inspect_file import *
+from .geographic_coordinate_systems import *
+from .geode_objects_and_output_extensions import *
+from .allowed_objects import *
+from .allowed_files import *

opengeodeweb_back/routes/schemas/allowed_files.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AllowedFiles(DataClassJsonMixin):
+    supported_feature: Optional[str] = None

opengeodeweb_back/routes/schemas/allowed_objects.py

@@ -0,0 +1,9 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AllowedObjects(DataClassJsonMixin):
+    filename: str
+    supported_feature: Optional[str] = None

opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class GeodeObjectsAndOutputExtensions(DataClassJsonMixin):
+    filename: str
+    input_geode_object: str

opengeodeweb_back/routes/schemas/geographic_coordinate_systems.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class GeographicCoordinateSystems(DataClassJsonMixin):
+    input_geode_object: str

opengeodeweb_back/routes/schemas/inspect_file.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class InspectFile(DataClassJsonMixin):
+    filename: str
+    input_geode_object: str

opengeodeweb_back/routes/schemas/kill.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Kill(DataClassJsonMixin):
+    pass

opengeodeweb_back/routes/schemas/missing_files.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class MissingFiles(DataClassJsonMixin):
+    filename: str
+    input_geode_object: str

opengeodeweb_back/routes/schemas/ping.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Ping(DataClassJsonMixin):
+    pass

opengeodeweb_back/routes/schemas/polygon_attribute_names.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class PolygonAttributeNames(DataClassJsonMixin):
+    id: str

opengeodeweb_back/routes/schemas/polyhedron_attribute_names.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class PolyhedronAttributeNames(DataClassJsonMixin):
+    id: str

opengeodeweb_back/routes/schemas/save_viewable_file.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class SaveViewableFile(DataClassJsonMixin):
+    filename: str
+    input_geode_object: str

opengeodeweb_back/routes/schemas/texture_coordinates.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class TextureCoordinates(DataClassJsonMixin):
+    id: str

opengeodeweb_back/routes/schemas/upload_file.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class UploadFile(DataClassJsonMixin):
+    filename: Optional[str] = None

opengeodeweb_back/routes/schemas/vertex_attribute_names.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class VertexAttributeNames(DataClassJsonMixin):
+    id: str

opengeodeweb_back/utils_functions.py

@@ -16,6 +16,7 @@ import werkzeug
 
 # Local application imports
 from . import geode_functions
+from opengeodeweb_microservice.schemas import SchemaDict
 from opengeodeweb_microservice.database.data import Data
 from opengeodeweb_microservice.database.connection import get_session
 
@@ -97,7 +98,7 @@ def versions(list_packages: list[str]) -> list[dict[str, str]]:
     return list_with_versions
 
 
-def validate_request(request: flask.Request, schema: dict[str, str]) -> None:
+def validate_request(request: flask.Request, schema: SchemaDict) -> None:
     json_data = request.get_json(force=True, silent=True)
 
     if json_data is None:
@@ -226,8 +227,6 @@ def generate_native_viewable_and_light_viewable_from_object(
     data_entry = Data.create(
         geode_object=geode_object,
         viewer_object=geode_functions.get_object_type(geode_object),
-        input_file="",
-        additional_files=[],
     )
     data_path = create_data_folder_from_id(data_entry.id)
     return save_all_viewables_and_return_info(geode_object, data, data_entry, data_path)
@@ -240,7 +239,6 @@ def generate_native_viewable_and_light_viewable_from_file(
         geode_object=geode_object,
         viewer_object=geode_functions.get_object_type(geode_object),
         input_file=input_filename,
-        additional_files=[],
     )
 
     data_path = create_data_folder_from_id(data_entry.id)

{opengeodeweb_back-5.11.0.dist-info → opengeodeweb_back-5.11.1rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 5.11.0
+Version: 5.11.1rc1
 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
@@ -27,7 +27,7 @@ Requires-Dist: opengeode-geosciencesio==5.8.1
 Requires-Dist: opengeode-inspector==6.8.2
 Requires-Dist: opengeode-io==7.4.2
 Requires-Dist: werkzeug==3.1.2
-Requires-Dist: opengeodeweb-microservice==1.*,>=1.0.5
+Requires-Dist: opengeodeweb-microservice==1.*,>=1.0.6rc1
 Dynamic: license-file
 
 <h1 align="center">OpenGeodeWeb-Back<sup><i>by Geode-solutions</i></sup></h1>

opengeodeweb_back-5.11.1rc1.dist-info/RECORD

@@ -0,0 +1,56 @@
+opengeodeweb_back/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opengeodeweb_back/app.py,sha256=SX7csXbWxlfeazrgSYuplJu9Z4LxupCd5T8O6bFN36g,5090
+opengeodeweb_back/app_config.py,sha256=z-omTiGj3-y0BZ1IchAM6EoTdC7vAX6B4OymEnuM0T4,843
+opengeodeweb_back/geode_functions.py,sha256=ot7JTJCdAIV9VIgVHElEevYJgltIySBvxt0ToMckqcU,10831
+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=lpsjkI1nN26t4yXPUHXTtYfjFZipHBLyqMgZD9Vy528,9348
+opengeodeweb_back/routes/blueprint_routes.py,sha256=ZnngJ-nm2a2ByzN1gC0dcf7CBhzCrerNIqKx1PH5ySo,9471
+opengeodeweb_back/routes/create/blueprint_create.py,sha256=QPqNW8pm5XdMdXODubMPt5v_fJ3g5yKhyanyMdBaFwo,2626
+opengeodeweb_back/routes/create/schemas/__init__.py,sha256=4IibXXKIb2Z0miuAuAbooCq3ALeVwl0Ogg0DuJe3uqo,54
+opengeodeweb_back/routes/create/schemas/create_aoi.json,sha256=bFL5ZqhKAKsBmGwIQANzdIp1vGeH5WAHnRpZYsUZ1tQ,999
+opengeodeweb_back/routes/create/schemas/create_aoi.py,sha256=cAquXr36qscsBJIZVstnh6MYNhbAAw-5hIT8cWC4DGw,345
+opengeodeweb_back/routes/create/schemas/create_point.json,sha256=ddfDzWKj4cMYhF6oJzvRh0bpTiQo1hqLFODK-vJjxHQ,484
+opengeodeweb_back/routes/create/schemas/create_point.py,sha256=WOBtyhRYd_QDtmQLOyQANoZxw7lx-271oL6RHn93Bus,187
+opengeodeweb_back/routes/models/blueprint_models.py,sha256=nSI-yorSfj3SCQbKNnz8AQglKDKFC21Es-VlFdU2C6A,1935
+opengeodeweb_back/routes/models/schemas/__init__.py,sha256=kNhYSdP7ti6BEalSO3fNfJJf_S7u0kEQDFRdBTDVNQY,68
+opengeodeweb_back/routes/models/schemas/mesh_components.json,sha256=JmQUvpy7HpGS6FlThZLx1YjHqiInRTqUZ_Ft5MfOzEE,239
+opengeodeweb_back/routes/models/schemas/mesh_components.py,sha256=qjbOb4yvIOTyzZ9GMufYs2b_jbU-Vh6F-cAPA8UMatk,149
+opengeodeweb_back/routes/models/schemas/vtm_component_indices.json,sha256=0XILVxhAxi0RhQFDZZoUeGcAnBMroWz3kNJS7-6_dKQ,239
+opengeodeweb_back/routes/models/schemas/vtm_component_indices.py,sha256=ky2OptukQp9ioMOgoQkXW_EWy5WAsY9aGXuMMT4BLZg,154
+opengeodeweb_back/routes/schemas/__init__.py,sha256=dj4cevHiakkiHR4bynqd4Mo75gwmBQwhfucVj6WdEL8,468
+opengeodeweb_back/routes/schemas/allowed_files.json,sha256=pRsGf39LiJpl3zEGLg4IqvRtm7iUx3Wq4Tb4tSFXGV0,234
+opengeodeweb_back/routes/schemas/allowed_files.py,sha256=tDOH58oBeTeeIS4CqHjgMd7TgSEIFXKtYElIuTEhSIA,207
+opengeodeweb_back/routes/schemas/allowed_objects.json,sha256=oy_YYpFzgDICx-keWqNIUpQM3zzB4eE3H6mPNxH9rWc,361
+opengeodeweb_back/routes/schemas/allowed_objects.py,sha256=Ov82leuMXKUCIJvvxO_Ms3Tf9tqsU1yJGIv4mBwG9QE,227
+opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.json,sha256=tp83tPQaxTltQrdL8D3TnG8pqY_2fgAaYVeTWPXO0qI,371
+opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.py,sha256=RFdr-thObKND33WJ7JI7JkBkozJ4C8aKO8ZlofeCJs4,200
+opengeodeweb_back/routes/schemas/geographic_coordinate_systems.json,sha256=lnPqevRRlUASF4ObmpG8ChH3c2LHNB99Si292S3OsLU,279
+opengeodeweb_back/routes/schemas/geographic_coordinate_systems.py,sha256=FLh9V1zK8ICttpEjnNO-5ND_b0FOp7WbjUue5ohnNEI,178
+opengeodeweb_back/routes/schemas/inspect_file.json,sha256=WoFF2hgZCUfqSDFJRq1sLpivjCQ6TCvSHPH8pKFY6KM,348
+opengeodeweb_back/routes/schemas/inspect_file.py,sha256=hU0HWhypidcLuOZFAs1jffEKxxZ5V-4YR4DuBQRuxgs,180
+opengeodeweb_back/routes/schemas/kill.json,sha256=tZEv4TuTNNthet2MsxUPLV3ivW6tIGjYTfxd6Jl9zaM,144
+opengeodeweb_back/routes/schemas/kill.py,sha256=H1Vgo6wN-TITi889SCijzw_JScwSZcVq81_UfvQyIwQ,136
+opengeodeweb_back/routes/schemas/missing_files.json,sha256=eOBAkiphA-2xG6e-OAy7wcJK2FeY0YFYXJlLdr8SNSc,349
+opengeodeweb_back/routes/schemas/missing_files.py,sha256=YZY9ONvd3OrEZA8ac68xLdualtzLMbukAhMaNCtzr9A,181
+opengeodeweb_back/routes/schemas/ping.json,sha256=MhI5jtrjMsAsfIKEzdY8p1HyV9xv4O3hYfESWw6tkyE,162
+opengeodeweb_back/routes/schemas/ping.py,sha256=J34dAqLmHdMKw-slfrrQD3Jh57XB-i6L_NrTfNy-KpI,136
+opengeodeweb_back/routes/schemas/polygon_attribute_names.json,sha256=1BrpfjcbRL1ZOL4azHIHirqXIc8tpu4xGnMRFEMEshU,241
+opengeodeweb_back/routes/schemas/polygon_attribute_names.py,sha256=e9CjlQ-kEj5Ilbm0xMdLVxONHBcDJi65IlkGhV48xSg,156
+opengeodeweb_back/routes/schemas/polyhedron_attribute_names.json,sha256=Tt6fWBGOWgxOVC-n76_JbOQcZ-Ss-foPghMrQOY-DIE,244
+opengeodeweb_back/routes/schemas/polyhedron_attribute_names.py,sha256=kKRdCTuse75leBA1WomAsl_3iC9kbaS4L-a9n2YfH-c,159
+opengeodeweb_back/routes/schemas/save_viewable_file.json,sha256=pvvEdaC7bNASPMrl3bXzlcA5blgflK0EYp2hBDf74qY,424
+opengeodeweb_back/routes/schemas/save_viewable_file.py,sha256=5KTdx7bPEHXWPFxrUSxe9MsM0NU0o9v3k4ZZMdl3b8I,185
+opengeodeweb_back/routes/schemas/texture_coordinates.json,sha256=2uQueIl1jOmxFG_gIi_vJETR4IurrwuSf8GAnzphk9g,237
+opengeodeweb_back/routes/schemas/texture_coordinates.py,sha256=OdN-yTmPzxU510Ll5ZNm_ebYzAgC8NsQBfBu-qlnaY0,153
+opengeodeweb_back/routes/schemas/upload_file.json,sha256=LJ3U3L5ApKuQDVFIpVT_y2alq4HW_suTvZ3HUucNbhg,219
+opengeodeweb_back/routes/schemas/upload_file.py,sha256=lCgK21UiXYk0BSNsW8BZil9O67gobwie6YdT1ahYuhs,196
+opengeodeweb_back/routes/schemas/vertex_attribute_names.json,sha256=ECIflohiqPZNsflAdkfEzksL4we0JvZhIxUd84Ubctg,240
+opengeodeweb_back/routes/schemas/vertex_attribute_names.py,sha256=aOVLsOuAxxzm-0B04wKZ-mCwoLv8uKGTB6sbuBNlX7g,155
+opengeodeweb_back-5.11.1rc1.dist-info/licenses/LICENSE,sha256=LoTB-aqQvzTGxoTRXNnhNV0LKiqdk2bQv6MB34l8zkI,1079
+opengeodeweb_back-5.11.1rc1.dist-info/METADATA,sha256=stYHREZ8qvyz_lHIm6lnGtFTYp9fsZqNlFaJBuSLmC8,2668
+opengeodeweb_back-5.11.1rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opengeodeweb_back-5.11.1rc1.dist-info/entry_points.txt,sha256=3W_t5GFc9ROHSIZ55IGvYU3DLHUFQmYOM4Bm9u3Z0cE,71
+opengeodeweb_back-5.11.1rc1.dist-info/top_level.txt,sha256=tN1FZeLIVBrdja2-pbmhg5-tK-JILmmT9OeIBnhlUrQ,18
+opengeodeweb_back-5.11.1rc1.dist-info/RECORD,,

opengeodeweb_back-5.11.0.dist-info/RECORD

@@ -1,35 +0,0 @@
-opengeodeweb_back/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opengeodeweb_back/app.py,sha256=SX7csXbWxlfeazrgSYuplJu9Z4LxupCd5T8O6bFN36g,5090
-opengeodeweb_back/app_config.py,sha256=z-omTiGj3-y0BZ1IchAM6EoTdC7vAX6B4OymEnuM0T4,843
-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=gGhNENDyx9ooO1Mb7KWLfgGCJ9F2DZMRpp9EXzEmb9A,9376
-opengeodeweb_back/routes/blueprint_routes.py,sha256=xOcC_Urp8C62zX1XJ4ILQPicObPhoYBI-38ObGYH-UA,10251
-opengeodeweb_back/routes/create/blueprint_create.py,sha256=rHZbpIJ0dhpWCe8agWMFJCg1uSFiTBGjCO9bnktYyUY,3557
-opengeodeweb_back/routes/create/schemas/create_aoi.json,sha256=bFL5ZqhKAKsBmGwIQANzdIp1vGeH5WAHnRpZYsUZ1tQ,999
-opengeodeweb_back/routes/create/schemas/create_point.json,sha256=ddfDzWKj4cMYhF6oJzvRh0bpTiQo1hqLFODK-vJjxHQ,484
-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
-opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.json,sha256=tp83tPQaxTltQrdL8D3TnG8pqY_2fgAaYVeTWPXO0qI,371
-opengeodeweb_back/routes/schemas/geographic_coordinate_systems.json,sha256=lnPqevRRlUASF4ObmpG8ChH3c2LHNB99Si292S3OsLU,279
-opengeodeweb_back/routes/schemas/inspect_file.json,sha256=WoFF2hgZCUfqSDFJRq1sLpivjCQ6TCvSHPH8pKFY6KM,348
-opengeodeweb_back/routes/schemas/kill.json,sha256=tZEv4TuTNNthet2MsxUPLV3ivW6tIGjYTfxd6Jl9zaM,144
-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=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=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=ECIflohiqPZNsflAdkfEzksL4we0JvZhIxUd84Ubctg,240
-opengeodeweb_back-5.11.0.dist-info/licenses/LICENSE,sha256=LoTB-aqQvzTGxoTRXNnhNV0LKiqdk2bQv6MB34l8zkI,1079
-opengeodeweb_back-5.11.0.dist-info/METADATA,sha256=na4X9UmOyw0MUsZKYjRBtyZCUp5qgtk-lVnedL501R4,2662
-opengeodeweb_back-5.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opengeodeweb_back-5.11.0.dist-info/entry_points.txt,sha256=3W_t5GFc9ROHSIZ55IGvYU3DLHUFQmYOM4Bm9u3Z0cE,71
-opengeodeweb_back-5.11.0.dist-info/top_level.txt,sha256=tN1FZeLIVBrdja2-pbmhg5-tK-JILmmT9OeIBnhlUrQ,18
-opengeodeweb_back-5.11.0.dist-info/RECORD,,