feat(geodeObjectInheritance): Blueprint to return a inheritance relaated objects list from geode_object string

Author: MaxNumerique

src/opengeodeweb_back/routes/blueprint_routes.py

@@ -608,3 +608,52 @@ def import_extension() -> flask.Response:
         },
         200,
     )
+
+
+@routes.route(
+    schemas_dict["geode_object_inheritance"]["route"],
+    methods=schemas_dict["geode_object_inheritance"]["methods"],
+)
+def geode_object_inheritance() -> flask.Response:
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["geode_object_inheritance"]
+    )
+    params = schemas.GeodeObjectInheritance.from_dict(json_data)
+    geode_object_type = params.geode_object_type
+    target_class = geode_functions.geode_object_from_string(geode_object_type)
+    print(f"Inheritance for {geode_object_type} ({target_class.__name__})")
+
+    def get_all_bases(geode_class: type) -> set[type]:
+        bases = set()
+        for base_class in geode_class.__bases__:
+            if base_class is not object:
+                bases.add(base_class)
+                bases.update(get_all_bases(base_class))
+        return bases
+
+    def get_all_subclasses(geode_class: type) -> set[type]:
+        subclasses = set()
+        for subclass_class in geode_class.__subclasses__():
+            subclasses.add(subclass_class)
+            subclasses.update(get_all_subclasses(subclass_class))
+        return subclasses
+
+    # Extract all related Geode classes (parents and children)
+    bases = get_all_bases(target_class)
+    subclasses = get_all_subclasses(target_class)
+    print(f"Bases found: {[base_class.__name__ for base_class in bases]}")
+    print(
+        f"Subclasses found: {[subclass_class.__name__ for subclass_class in subclasses]}"
+    )
+
+    all_related_classes = bases | subclasses
+    all_related_classes.add(target_class)
+
+    # Filter GeodeObjectType to only include registered related objects
+    geode_inheritances = []
+    for geode_object_type_str, geode_class in geode_objects.items():
+        if geode_class in all_related_classes:
+            geode_inheritances.append(geode_object_type_str)
+
+    print(f"Geode Object inheritances: {geode_inheritances}")
+    return flask.make_response({"geode_inheritances": geode_inheritances}, 200)

src/opengeodeweb_back/routes/schemas/__init__.py

@@ -11,6 +11,7 @@
 from .import_project import *
 from .import_extension import *
 from .geographic_coordinate_systems import *
+from .geode_object_inheritance import *
 from .geode_objects_and_output_extensions import *
 from .export_project import *
 from .edge_attribute_names import *

src/opengeodeweb_back/routes/schemas/geode_object_inheritance.json

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

src/opengeodeweb_back/routes/schemas/geode_object_inheritance.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class GeodeObjectInheritance(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    geode_object_type: str

tests/test_routes.py

@@ -379,3 +379,39 @@ def test_database_uri_path(client: FlaskClient) -> None:
         assert app.config["SQLALCHEMY_DATABASE_URI"] == expected_uri
 
         assert os.path.exists(expected_db_path)
+
+
+def test_geode_object_inheritance(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/geode_object_inheritance"
+    # Test BRep
+    response = client.post(route, json={"geode_object_type": "BRep"})
+    assert response.status_code == 200
+    geode_inheritances = response.get_json()["geode_inheritances"]
+    assert "BRep" in geode_inheritances
+    # Descendants
+    assert "StructuralModel" in geode_inheritances
+    assert "ImplicitStructuralModel" in geode_inheritances
+
+    # Test CrossSection
+    response = client.post(route, json={"geode_object_type": "CrossSection"})
+    assert response.status_code == 200
+    geode_inheritances = response.get_json()["geode_inheritances"]
+    assert "CrossSection" in geode_inheritances
+    # Parent
+    assert "Section" in geode_inheritances
+    # Descendant
+    assert "ImplicitCrossSection" in geode_inheritances
+
+    # Test PolyhedralSolid3D
+    response = client.post(route, json={"geode_object_type": "PolyhedralSolid3D"})
+    assert response.status_code == 200
+    geode_inheritances = response.get_json()["geode_inheritances"]
+    assert "PolyhedralSolid3D" in geode_inheritances
+    # Parent
+    assert "VertexSet" in geode_inheritances
+
+    # Test all params
+    def get_full_data() -> test_utils.JsonData:
+        return {"geode_object_type": "BRep"}
+
+    test_utils.test_route_wrong_params(client, route, get_full_data)