OpenGeodeWeb-Back 6.8.1rc1__tar.gz → 6.9.0__tar.gz

{opengeodeweb_back-6.8.1rc1/src/OpenGeodeWeb_Back.egg-info → opengeodeweb_back-6.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.8.1rc1
+Version: 6.9.0
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back

{opengeodeweb_back-6.8.1rc1 → opengeodeweb_back-6.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "6.8.1-rc.1"
+version = "6.9.0"
 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.8.1rc1 → opengeodeweb_back-6.9.0/src/OpenGeodeWeb_Back.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.8.1rc1
+Version: 6.9.0
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back

{opengeodeweb_back-6.8.1rc1 → opengeodeweb_back-6.9.0}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -83,6 +83,14 @@ src/opengeodeweb_back/routes/schemas/kill.json
 src/opengeodeweb_back/routes/schemas/kill.py
 src/opengeodeweb_back/routes/schemas/missing_files.json
 src/opengeodeweb_back/routes/schemas/missing_files.py
+src/opengeodeweb_back/routes/schemas/model_component_edge_attribute_names.json
+src/opengeodeweb_back/routes/schemas/model_component_edge_attribute_names.py
+src/opengeodeweb_back/routes/schemas/model_component_polygon_attribute_names.json
+src/opengeodeweb_back/routes/schemas/model_component_polygon_attribute_names.py
+src/opengeodeweb_back/routes/schemas/model_component_polyhedron_attribute_names.json
+src/opengeodeweb_back/routes/schemas/model_component_polyhedron_attribute_names.py
+src/opengeodeweb_back/routes/schemas/model_component_vertex_attribute_names.json
+src/opengeodeweb_back/routes/schemas/model_component_vertex_attribute_names.py
 src/opengeodeweb_back/routes/schemas/ping.json
 src/opengeodeweb_back/routes/schemas/ping.py
 src/opengeodeweb_back/routes/schemas/polygon_attribute_names.json

{opengeodeweb_back-6.8.1rc1 → opengeodeweb_back-6.9.0}/src/opengeodeweb_back/routes/blueprint_routes.py

@@ -3,7 +3,7 @@ import os
 import time
 import shutil
 import math
-from typing import Any
+from typing import Any, Union, get_args
 
 # Third party imports
 import flask
@@ -24,6 +24,7 @@ from opengeodeweb_back import geode_functions, utils_functions
 from opengeodeweb_back.routes import schemas
 from opengeodeweb_back.geode_objects import geode_objects
 from opengeodeweb_back.geode_objects.geode_mesh import GeodeMesh
+from opengeodeweb_back.geode_objects.geode_model import GeodeModel
 from opengeodeweb_back.geode_objects.geode_graph import GeodeGraph
 from opengeodeweb_back.geode_objects.geode_grid2d import GeodeGrid2D
 from opengeodeweb_back.geode_objects.geode_grid3d import GeodeGrid3D
@@ -31,6 +32,16 @@ from opengeodeweb_back.geode_objects.geode_surface_mesh2d import GeodeSurfaceMes
 from opengeodeweb_back.geode_objects.geode_surface_mesh3d import GeodeSurfaceMesh3D
 from opengeodeweb_back.geode_objects.geode_solid_mesh3d import GeodeSolidMesh3D
 
+ComponentMesh = Union[
+    og.Corner2D,
+    og.Corner3D,
+    og.Line2D,
+    og.Line3D,
+    og.Surface2D,
+    og.Surface3D,
+    og.Block3D,
+]
+
 routes = flask.Blueprint("routes", __name__, url_prefix="/opengeodeweb_back")
 
 schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
@@ -387,6 +398,104 @@ def edge_attribute_names() -> flask.Response:
     )
 
 
+@routes.route(
+    schemas_dict["model_component_vertex_attribute_names"]["route"],
+    methods=schemas_dict["model_component_vertex_attribute_names"]["methods"],
+)
+def model_component_vertex_attribute_names() -> flask.Response:
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["model_component_vertex_attribute_names"]
+    )
+    params = schemas.ModelComponentVertexAttributeNames.from_dict(json_data)
+    geode_object = geode_functions.load_geode_object(params.id)
+    if not isinstance(geode_object, GeodeModel):
+        flask.abort(400, f"{params.id} is not a GeodeModel")
+    component = geode_object.component(og.uuid(params.component_id))
+    if not isinstance(component, get_args(ComponentMesh)):
+        flask.abort(400, f"{params.component_id} is not a valid ComponentMesh")
+    mesh = component.mesh()
+    attribute_manager = mesh.vertex_attribute_manager()
+    return flask.make_response(
+        {"attributes": attributes_metadata(attribute_manager)},
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["model_component_edge_attribute_names"]["route"],
+    methods=schemas_dict["model_component_edge_attribute_names"]["methods"],
+)
+def model_component_edge_attribute_names() -> flask.Response:
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["model_component_edge_attribute_names"]
+    )
+    params = schemas.ModelComponentEdgeAttributeNames.from_dict(json_data)
+    geode_object = geode_functions.load_geode_object(params.id)
+    if not isinstance(geode_object, GeodeModel):
+        flask.abort(400, f"{params.id} is not a GeodeModel")
+    component = geode_object.component(og.uuid(params.component_id))
+    if not isinstance(component, get_args(ComponentMesh)):
+        flask.abort(400, f"{params.component_id} is not a valid ComponentMesh")
+    mesh = component.mesh()
+    if not hasattr(mesh, "edge_attribute_manager"):
+        flask.abort(400, "Component does not have edges")
+    attribute_manager = mesh.edge_attribute_manager()
+    return flask.make_response(
+        {"attributes": attributes_metadata(attribute_manager)},
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["model_component_polygon_attribute_names"]["route"],
+    methods=schemas_dict["model_component_polygon_attribute_names"]["methods"],
+)
+def model_component_polygon_attribute_names() -> flask.Response:
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["model_component_polygon_attribute_names"]
+    )
+    params = schemas.ModelComponentPolygonAttributeNames.from_dict(json_data)
+    geode_object = geode_functions.load_geode_object(params.id)
+    if not isinstance(geode_object, GeodeModel):
+        flask.abort(400, f"{params.id} is not a GeodeModel")
+    component = geode_object.component(og.uuid(params.component_id))
+    if not isinstance(component, get_args(ComponentMesh)):
+        flask.abort(400, f"{params.component_id} is not a valid ComponentMesh")
+    mesh = component.mesh()
+    if not hasattr(mesh, "polygon_attribute_manager"):
+        flask.abort(400, "Component does not have polygons")
+    attribute_manager = mesh.polygon_attribute_manager()
+    return flask.make_response(
+        {"attributes": attributes_metadata(attribute_manager)},
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["model_component_polyhedron_attribute_names"]["route"],
+    methods=schemas_dict["model_component_polyhedron_attribute_names"]["methods"],
+)
+def model_component_polyhedron_attribute_names() -> flask.Response:
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["model_component_polyhedron_attribute_names"]
+    )
+    params = schemas.ModelComponentPolyhedronAttributeNames.from_dict(json_data)
+    geode_object = geode_functions.load_geode_object(params.id)
+    if not isinstance(geode_object, GeodeModel):
+        flask.abort(400, f"{params.id} is not a GeodeModel")
+    component = geode_object.component(og.uuid(params.component_id))
+    if not isinstance(component, get_args(ComponentMesh)):
+        flask.abort(400, f"{params.component_id} is not a valid ComponentMesh")
+    mesh = component.mesh()
+    if not hasattr(mesh, "polyhedron_attribute_manager"):
+        flask.abort(400, "Component does not have polyhedra")
+    attribute_manager = mesh.polyhedron_attribute_manager()
+    return flask.make_response(
+        {"attributes": attributes_metadata(attribute_manager)},
+        200,
+    )
+
+
 @routes.route(
     schemas_dict["ping"]["route"],
     methods=schemas_dict["ping"]["methods"],

{opengeodeweb_back-6.8.1rc1 → opengeodeweb_back-6.9.0}/src/opengeodeweb_back/routes/schemas/__init__.py

@@ -5,6 +5,10 @@ from .save_viewable_file import *
 from .polyhedron_attribute_names import *
 from .polygon_attribute_names import *
 from .ping import *
+from .model_component_vertex_attribute_names import *
+from .model_component_polyhedron_attribute_names import *
+from .model_component_polygon_attribute_names import *
+from .model_component_edge_attribute_names import *
 from .missing_files import *
 from .kill import *
 from .inspect_file import *

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_edge_attribute_names.json

@@ -0,0 +1,17 @@
+{
+  "route": "/model_component_edge_attribute_names",
+  "methods": ["POST"],
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "component_id": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": ["id", "component_id"],
+  "additionalProperties": false
+}

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_edge_attribute_names.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelComponentEdgeAttributeNames(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    component_id: str
+    id: str

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_polygon_attribute_names.json

@@ -0,0 +1,17 @@
+{
+  "route": "/model_component_polygon_attribute_names",
+  "methods": ["POST"],
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "component_id": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": ["id", "component_id"],
+  "additionalProperties": false
+}

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_polygon_attribute_names.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelComponentPolygonAttributeNames(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    component_id: str
+    id: str

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_polyhedron_attribute_names.json

@@ -0,0 +1,17 @@
+{
+  "route": "/model_component_polyhedron_attribute_names",
+  "methods": ["POST"],
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "component_id": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": ["id", "component_id"],
+  "additionalProperties": false
+}

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_polyhedron_attribute_names.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelComponentPolyhedronAttributeNames(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    component_id: str
+    id: str

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_vertex_attribute_names.json

@@ -0,0 +1,17 @@
+{
+  "route": "/model_component_vertex_attribute_names",
+  "methods": ["POST"],
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "component_id": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": ["id", "component_id"],
+  "additionalProperties": false
+}

opengeodeweb_back-6.9.0/src/opengeodeweb_back/routes/schemas/model_component_vertex_attribute_names.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelComponentVertexAttributeNames(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    component_id: str
+    id: str

{opengeodeweb_back-6.8.1rc1 → opengeodeweb_back-6.9.0}/src/opengeodeweb_back/utils_functions.py

@@ -25,6 +25,7 @@ from . import geode_functions
 from .geode_objects import geode_objects
 from .geode_objects.geode_model import GeodeModel
 from .geode_objects.geode_object import GeodeObject
+from .geode_objects.geode_vertex_set import GeodeVertexSet
 
 
 def increment_request_counter(current_app: flask.Flask) -> None:
@@ -312,6 +313,8 @@ def save_all_viewables_and_return_info(
             "binary_light_viewable": binary_light_viewable.decode("utf-8"),
             "geode_object_type": data.geode_object,
         }
+        if isinstance(geode_object, GeodeVertexSet):
+            response["nb_vertices"] = geode_object.vertex_set.nb_vertices()
         if isinstance(geode_object, GeodeModel):
             response |= model_components(data.id, geode_object, data.viewable_file)
         return response

{opengeodeweb_back-6.8.1rc1 → opengeodeweb_back-6.9.0}/tests/test_routes.py

@@ -596,3 +596,94 @@ def test_save_viewable_workflow_from_object(client: FlaskClient) -> None:
     assert isinstance(data_id, str) and len(data_id) > 0
     assert response.get_json()["geode_object_type"] == "PointSet3D"
     assert response.get_json()["viewable_file"].endswith(".vtp")
+
+
+def _load_brep_components(client: FlaskClient) -> tuple[str, dict[str, list[str]]]:
+    """Load cube.og_brep and return (model_id, {component_type: [geode_id, ...]})."""
+    response = test_save_viewable_file(client, "BRep", "cube.og_brep")
+    assert response.status_code == 200
+    model_id: str = response.get_json()["id"]
+    mesh_components: list[dict] = response.get_json()["mesh_components"]
+    by_type: dict[str, list[str]] = {}
+    for mc in mesh_components:
+        component_type = mc["type"]
+        by_type.setdefault(component_type, []).append(mc["geode_id"])
+    return model_id, by_type
+
+
+def _assert_attributes_response(response) -> None:
+    assert response.status_code == 200
+    attributes = response.get_json()["attributes"]
+    assert isinstance(attributes, list)
+    for attribute in attributes:
+        assert "attribute_name" in attribute
+        assert "min_value" in attribute
+        assert "max_value" in attribute
+
+
+def test_model_component_vertex_attribute_names(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/model_component_vertex_attribute_names"
+    model_id, by_type = _load_brep_components(client)
+
+    corner_ids = by_type.get("Corner", [])
+    assert len(corner_ids) > 0, "cube.og_brep should have Corner components"
+    component_id = corner_ids[0]
+
+    response = client.post(route, json={"id": model_id, "component_id": component_id})
+    _assert_attributes_response(response)
+
+    def get_full_data() -> test_utils.JsonData:
+        return {"id": model_id, "component_id": component_id}
+
+    test_utils.test_route_wrong_params(client, route, get_full_data)
+
+
+def test_model_component_edge_attribute_names(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/model_component_edge_attribute_names"
+    model_id, by_type = _load_brep_components(client)
+
+    line_ids = by_type.get("Line", [])
+    assert len(line_ids) > 0, "cube.og_brep should have Line components"
+    component_id = line_ids[0]
+
+    response = client.post(route, json={"id": model_id, "component_id": component_id})
+    _assert_attributes_response(response)
+
+    def get_full_data() -> test_utils.JsonData:
+        return {"id": model_id, "component_id": component_id}
+
+    test_utils.test_route_wrong_params(client, route, get_full_data)
+
+
+def test_model_component_polygon_attribute_names(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/model_component_polygon_attribute_names"
+    model_id, by_type = _load_brep_components(client)
+
+    surface_ids = by_type.get("Surface", [])
+    assert len(surface_ids) > 0, "cube.og_brep should have Surface components"
+    component_id = surface_ids[0]
+
+    response = client.post(route, json={"id": model_id, "component_id": component_id})
+    _assert_attributes_response(response)
+
+    def get_full_data() -> test_utils.JsonData:
+        return {"id": model_id, "component_id": component_id}
+
+    test_utils.test_route_wrong_params(client, route, get_full_data)
+
+
+def test_model_component_polyhedron_attribute_names(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/model_component_polyhedron_attribute_names"
+    model_id, by_type = _load_brep_components(client)
+
+    block_ids = by_type.get("Block", [])
+    assert len(block_ids) > 0, "cube.og_brep should have Block components"
+    component_id = block_ids[0]
+
+    response = client.post(route, json={"id": model_id, "component_id": component_id})
+    _assert_attributes_response(response)
+
+    def get_full_data() -> test_utils.JsonData:
+        return {"id": model_id, "component_id": component_id}
+
+    test_utils.test_route_wrong_params(client, route, get_full_data)