feat(GeodeObject): new design using OpenGeode types

Author: BotellaA

requirements.in

@@ -1,4 +1,4 @@
-opengeode-core==15.30.3
+opengeode-core==15.30.4
 opengeode-io==7.4.6
 opengeode-inspector==6.8.6
 opengeode-geosciences==9.5.5

requirements.txt

@@ -31,7 +31,7 @@ markupsafe>=3
     #   flask
     #   jinja2
     #   werkzeug
-opengeode-core==15.30.3
+opengeode-core==15.30.4
     # via
     #   -r requirements.in
     #   geode-common

src/opengeodeweb_back/geode_functions.py

@@ -9,18 +9,12 @@
 from typing import Any
 
 # Local application imports
-from .geode_objects import geode_objects, geode_meshes, geode_models
+from .geode_objects import geode_objects
 from .geode_objects.types import (
     GeodeObjectType,
     geode_object_type,
-    GeodeMeshType,
-    geode_mesh_type,
-    GeodeModelType,
-    geode_model_type,
 )
 from .geode_objects.geode_object import GeodeObject
-from .geode_objects.geode_mesh import GeodeMesh
-from .geode_objects.geode_model import GeodeModel
 from . import utils_functions
 from opengeodeweb_microservice.database.data import Data
 from opengeodeweb_microservice.database.connection import get_session
@@ -38,15 +32,7 @@ def geode_object_from_string(value: str) -> type[GeodeObject]:
     return geode_objects[geode_object_type(value)]
 
 
-def geode_mesh_from_string(value: str) -> type[GeodeMesh]:
-    return geode_meshes[geode_mesh_type(value)]
-
-
-def geode_model_from_string(value: str) -> type[GeodeModel]:
-    return geode_models[geode_model_type(value)]
-
-
-def load_object_data(data_id: str) -> GeodeObject:
+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")
@@ -57,28 +43,6 @@ def load_object_data(data_id: str) -> GeodeObject:
     return geode_object_from_string(data.geode_object).load(file_absolute_path)
 
 
-def load_mesh_data(data_id: str) -> GeodeMesh:
-    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.native_file_name)
-    print("Loading file: ", file_absolute_path)
-    print("File exists: ", os.path.exists(file_absolute_path))
-    return geode_mesh_from_string(data.geode_object).load_mesh(file_absolute_path)
-
-
-def load_model_data(data_id: str) -> GeodeModel:
-    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.native_file_name)
-    print("Loading file: ", file_absolute_path)
-    print("File exists: ", os.path.exists(file_absolute_path))
-    return geode_model_from_string(data.geode_object).load_model(file_absolute_path)
-
-
 def get_data_info(data_id: str) -> Data:
     data = Data.get(data_id)
     if not data:

src/opengeodeweb_back/geode_objects/__init__.py

@@ -42,7 +42,7 @@
 from .geode_implicit_structural_model import GeodeImplicitStructuralModel
 from .geode_implicit_cross_section import GeodeImplicitCrossSection
 
-geode_meshes: dict[GeodeMeshType, type[GeodeMesh]] = {
+geode_objects: dict[GeodeObjectType, type[GeodeObject]] = {
     "VertexSet": GeodeVertexSet,
     "Graph": GeodeGraph,
     "PointSet2D": GeodePointSet2D,
@@ -62,17 +62,10 @@
     "RegularGrid3D": GeodeRegularGrid3D,
     "LightRegularGrid2D": GeodeLightRegularGrid2D,
     "LightRegularGrid3D": GeodeLightRegularGrid3D,
-}
-geode_models: dict[GeodeModelType, type[GeodeModel]] = {
     "BRep": GeodeBRep,
     "Section": GeodeSection,
     "StructuralModel": GeodeStructuralModel,
     "CrossSection": GeodeCrossSection,
     "ImplicitStructuralModel": GeodeImplicitStructuralModel,
     "ImplicitCrossSection": GeodeImplicitCrossSection,
 }
-
-GeodeObjectsDict = dict[GeodeObjectType, type[GeodeObject]]
-geode_objects: GeodeObjectsDict = {}
-geode_objects.update(cast(GeodeObjectsDict, geode_meshes))
-geode_objects.update(cast(GeodeObjectsDict, geode_models))

src/opengeodeweb_back/geode_objects/geode_brep.py

@@ -20,7 +20,7 @@ def __init__(self, brep: og.BRep | None = None) -> None:
         super().__init__(self.brep)
 
     @classmethod
-    def geode_model_type(cls) -> GeodeModelType:
+    def geode_object_type(cls) -> GeodeModelType:
         return "BRep"
 
     def native_extension(self) -> str:
@@ -38,7 +38,7 @@ def builder(self) -> og.BRepBuilder:
         return og.BRepBuilder(self.brep)
 
     @classmethod
-    def load_model(cls, filename: str) -> GeodeBRep:
+    def load(cls, filename: str) -> GeodeBRep:
         return GeodeBRep(og.load_brep(filename))
 
     @classmethod

src/opengeodeweb_back/geode_objects/geode_cross_section.py

@@ -25,7 +25,7 @@ def __init__(
         super().__init__(self.cross_section)
 
     @classmethod
-    def geode_model_type(cls) -> GeodeModelType:
+    def geode_object_type(cls) -> GeodeModelType:
         return "CrossSection"
 
     def native_extension(self) -> str:
@@ -35,7 +35,7 @@ def builder(self) -> og_geosciences.CrossSectionBuilder:
         return og_geosciences.CrossSectionBuilder(self.cross_section)
 
     @classmethod
-    def load_model(cls, filename: str) -> GeodeCrossSection:
+    def load(cls, filename: str) -> GeodeCrossSection:
         return GeodeCrossSection(og_geosciences.load_cross_section(filename))
 
     @classmethod

src/opengeodeweb_back/geode_objects/geode_edged_curve2d.py

@@ -16,11 +16,13 @@ class GeodeEdgedCurve2D(GeodeGraph):
     edged_curve: og.EdgedCurve2D
 
     def __init__(self, edged_curve: og.EdgedCurve2D | None = None) -> None:
-        self.edged_curve = edged_curve if edged_curve is not None else og.EdgedCurve2D()
+        self.edged_curve = (
+            edged_curve if edged_curve is not None else og.EdgedCurve2D.create()
+        )
         super().__init__(self.edged_curve)
 
     @classmethod
-    def geode_mesh_type(cls) -> GeodeMeshType:
+    def geode_object_type(cls) -> GeodeMeshType:
         return "EdgedCurve2D"
 
     def native_extension(self) -> str:
@@ -35,10 +37,10 @@ def is_viewable(cls) -> bool:
         return False
 
     def builder(self) -> og.EdgedCurveBuilder2D:
-        return og.EdgedCurveBuilder2D(self.edged_curve)
+        return og.EdgedCurveBuilder2D.create(self.edged_curve)
 
     @classmethod
-    def load_mesh(cls, filename: str) -> GeodeEdgedCurve2D:
+    def load(cls, filename: str) -> GeodeEdgedCurve2D:
         return GeodeEdgedCurve2D(og.load_edged_curve2D(filename))
 
     @classmethod

src/opengeodeweb_back/geode_objects/geode_edged_curve3d.py

@@ -16,11 +16,13 @@ class GeodeEdgedCurve3D(GeodeGraph):
     edged_curve: og.EdgedCurve3D
 
     def __init__(self, edged_curve: og.EdgedCurve3D | None = None) -> None:
-        self.edged_curve = edged_curve if edged_curve is not None else og.EdgedCurve3D()
+        self.edged_curve = (
+            edged_curve if edged_curve is not None else og.EdgedCurve3D.create()
+        )
         super().__init__(self.edged_curve)
 
     @classmethod
-    def geode_mesh_type(cls) -> GeodeMeshType:
+    def geode_object_type(cls) -> GeodeMeshType:
         return "EdgedCurve3D"
 
     def native_extension(self) -> str:
@@ -35,10 +37,10 @@ def is_viewable(cls) -> bool:
         return False
 
     def builder(self) -> og.EdgedCurveBuilder3D:
-        return og.EdgedCurveBuilder3D(self.edged_curve)
+        return og.EdgedCurveBuilder3D.create(self.edged_curve)
 
     @classmethod
-    def load_mesh(cls, filename: str) -> GeodeEdgedCurve3D:
+    def load(cls, filename: str) -> GeodeEdgedCurve3D:
         return GeodeEdgedCurve3D(og.load_edged_curve3D(filename))
 
     @classmethod

src/opengeodeweb_back/geode_objects/geode_graph.py

@@ -15,11 +15,11 @@ class GeodeGraph(GeodeVertexSet):
     graph: og.Graph
 
     def __init__(self, graph: og.Graph | None = None) -> None:
-        self.graph = graph if graph is not None else og.Graph()
+        self.graph = graph if graph is not None else og.Graph.create()
         super().__init__(self.graph)
 
     @classmethod
-    def geode_mesh_type(cls) -> GeodeMeshType:
+    def geode_object_type(cls) -> GeodeMeshType:
         return "Graph"
 
     def native_extension(self) -> str:
@@ -34,10 +34,10 @@ def is_viewable(cls) -> bool:
         return False
 
     def builder(self) -> og.GraphBuilder:
-        return og.GraphBuilder(self.graph)
+        return og.GraphBuilder.create(self.graph)
 
     @classmethod
-    def load_mesh(cls, filename: str) -> GeodeGraph:
+    def load(cls, filename: str) -> GeodeGraph:
         return GeodeGraph(og.load_graph(filename))
 
     @classmethod

src/opengeodeweb_back/geode_objects/geode_hybrid_solid3d.py

@@ -16,22 +16,22 @@ class GeodeHybridSolid3D(GeodeSolidMesh3D):
 
     def __init__(self, hybrid_solid: og.HybridSolid3D | None = None) -> None:
         self.hybrid_solid = (
-            hybrid_solid if hybrid_solid is not None else og.HybridSolid3D()
+            hybrid_solid if hybrid_solid is not None else og.HybridSolid3D.create()
         )
         super().__init__(self.hybrid_solid)
 
     @classmethod
-    def geode_mesh_type(cls) -> GeodeMeshType:
+    def geode_object_type(cls) -> GeodeMeshType:
         return "HybridSolid3D"
 
     def native_extension(self) -> str:
         return self.hybrid_solid.native_extension()
 
     def builder(self) -> og.HybridSolidBuilder3D:
-        return og.HybridSolidBuilder3D(self.hybrid_solid)
+        return og.HybridSolidBuilder3D.create(self.hybrid_solid)
 
     @classmethod
-    def load_mesh(cls, filename: str) -> GeodeHybridSolid3D:
+    def load(cls, filename: str) -> GeodeHybridSolid3D:
         return GeodeHybridSolid3D(og.load_hybrid_solid3D(filename))
 
     @classmethod