feat(list_geode_objects): test is_loadable

BREAKING CHANGE : arg extension -> file_absolute_path

Author: JulienChampagnol

src/opengeodeweb_back/geode_functions.py

@@ -34,6 +34,10 @@ def missing_files(geode_object: str, file_absolute_path: str):
     return geode_object_value(geode_object)["missing_files"](file_absolute_path)
 
 
+def is_loadable(geode_object: str, file_absolute_path: str):
+    return geode_object_value(geode_object)["is_loadable"](file_absolute_path)
+
+
 def load(geode_object: str, file_absolute_path: str):
     return geode_object_value(geode_object)["load"](file_absolute_path)
 
@@ -112,7 +116,7 @@ def geode_object_output_extensions(geode_object: str):
 def list_input_extensions(key: str = None):
     extensions_list = []
     for geode_object, value in geode_objects_dict().items():
-        if key != None:
+        if key != None and key != "":
             if key in value:
                 if type(value[key]) == bool:
                     if value[key] == True:
@@ -131,23 +135,28 @@ def has_creator(geode_object: str, extension: str):
     return input_factory(geode_object).has_creator(extension)
 
 
-def list_geode_objects(extension: str, key: str = None):
-    geode_objects_list = []
-    for geode_object, value in geode_objects_dict().items():
-        if key != None:
-            if key in value:
-                if type(value[key]) == bool:
-                    if value[key] == True:
-                        if has_creator(geode_object, extension):
-                            geode_objects_list.append(geode_object)
-                elif has_creator(geode_object, extension):
-                    geode_objects_list.append(geode_object)
-        else:
-            if has_creator(geode_object, extension):
-                geode_objects_list.append(geode_object)
+def list_geode_objects(
+    file_absolute_path: str,
+    key: str = None,
+):
+    return_dict = {}
+    file_extension = extension_from_filename(os.path.basename(file_absolute_path))
 
-    geode_objects_list.sort()
-    return geode_objects_list
+    for geode_object, value in geode_objects_dict().items():
+        if has_creator(geode_object, file_extension):
+            file_is_loadable = is_loadable(geode_object, file_absolute_path)
+            if key != None and key != "":
+                if key in value:
+                    if type(value[key]) == bool:
+                        if value[key] == True:
+                            return_dict[geode_object] = {
+                                "is_loadable": file_is_loadable
+                            }
+                    else:
+                        return_dict[geode_object] = {"is_loadable": file_is_loadable}
+            else:
+                return_dict[geode_object] = {"is_loadable": file_is_loadable}
+    return return_dict
 
 
 def geode_objects_output_extensions(geode_object: str, data):

src/opengeodeweb_back/geode_objects.py

@@ -12,6 +12,7 @@ def geode_objects_dict():
             "input_factory": og.BRepInputFactory,
             "output_factory": og.BRepOutputFactory,
             "missing_files": og.check_brep_missing_files,
+            "is_loadable": og.is_brep_loadable,
             "load": og.load_brep,
             "is_saveable": og.is_brep_saveable,
             "save": og.save_brep,
@@ -32,6 +33,7 @@ def geode_objects_dict():
             "input_factory": og_gs.CrossSectionInputFactory,
             "output_factory": og_gs.CrossSectionOutputFactory,
             "missing_files": og_gs.check_cross_section_missing_files,
+            "is_loadable": og_gs.is_cross_section_loadable,
             "load": og_gs.load_cross_section,
             "is_saveable": og_gs.is_cross_section_saveable,
             "save": og_gs.save_cross_section,
@@ -51,6 +53,7 @@ def geode_objects_dict():
             "input_factory": og.EdgedCurveInputFactory2D,
             "output_factory": og.EdgedCurveOutputFactory2D,
             "missing_files": og.check_edged_curve_missing_files2D,
+            "is_loadable": og.is_edged_curve_loadable2D,
             "load": og.load_edged_curve2D,
             "is_saveable": og.is_edged_curve_saveable2D,
             "save": og.save_edged_curve2D,
@@ -70,6 +73,7 @@ def geode_objects_dict():
             "input_factory": og.EdgedCurveInputFactory3D,
             "output_factory": og.EdgedCurveOutputFactory3D,
             "missing_files": og.check_edged_curve_missing_files3D,
+            "is_loadable": og.is_edged_curve_loadable3D,
             "load": og.load_edged_curve3D,
             "is_saveable": og.is_edged_curve_saveable3D,
             "save": og.save_edged_curve3D,
@@ -89,6 +93,7 @@ def geode_objects_dict():
             "input_factory": og.GraphInputFactory,
             "output_factory": og.GraphOutputFactory,
             "missing_files": og.check_graph_missing_files,
+            "is_loadable": og.is_graph_loadable,
             "load": og.load_graph,
             "is_saveable": og.is_graph_saveable,
             "save": og.save_graph,
@@ -101,6 +106,7 @@ def geode_objects_dict():
             "input_factory": og.HybridSolidInputFactory3D,
             "output_factory": og.HybridSolidOutputFactory3D,
             "missing_files": og.check_hybrid_solid_missing_files3D,
+            "is_loadable": og.is_hybrid_solid_loadable3D,
             "load": og.load_hybrid_solid3D,
             "is_saveable": og.is_hybrid_solid_saveable3D,
             "save": og.save_hybrid_solid3D,
@@ -120,6 +126,7 @@ def geode_objects_dict():
             "input_factory": og.PointSetInputFactory2D,
             "output_factory": og.PointSetOutputFactory2D,
             "missing_files": og.check_point_set_missing_files2D,
+            "is_loadable": og.is_point_set_loadable2D,
             "load": og.load_point_set2D,
             "is_saveable": og.is_point_set_saveable2D,
             "save": og.save_point_set2D,
@@ -139,6 +146,7 @@ def geode_objects_dict():
             "input_factory": og.PointSetInputFactory3D,
             "output_factory": og.PointSetOutputFactory3D,
             "missing_files": og.check_point_set_missing_files3D,
+            "is_loadable": og.is_point_set_loadable3D,
             "load": og.load_point_set3D,
             "is_saveable": og.is_point_set_saveable3D,
             "save": og.save_point_set3D,
@@ -158,6 +166,7 @@ def geode_objects_dict():
             "input_factory": og.PolygonalSurfaceInputFactory2D,
             "output_factory": og.PolygonalSurfaceOutputFactory2D,
             "missing_files": og.check_polygonal_surface_missing_files2D,
+            "is_loadable": og.is_polygonal_surface_loadable2D,
             "load": og.load_polygonal_surface2D,
             "is_saveable": og.is_polygonal_surface_saveable2D,
             "save": og.save_polygonal_surface2D,
@@ -177,6 +186,7 @@ def geode_objects_dict():
             "input_factory": og.PolygonalSurfaceInputFactory3D,
             "output_factory": og.PolygonalSurfaceOutputFactory3D,
             "missing_files": og.check_polygonal_surface_missing_files3D,
+            "is_loadable": og.is_polygonal_surface_loadable3D,
             "load": og.load_polygonal_surface3D,
             "is_saveable": og.is_polygonal_surface_saveable3D,
             "save": og.save_polygonal_surface3D,
@@ -196,6 +206,7 @@ def geode_objects_dict():
             "input_factory": og.PolyhedralSolidInputFactory3D,
             "output_factory": og.PolyhedralSolidOutputFactory3D,
             "missing_files": og.check_polyhedral_solid_missing_files3D,
+            "is_loadable": og.is_polyhedral_solid_loadable3D,
             "load": og.load_polyhedral_solid3D,
             "is_saveable": og.is_polyhedral_solid_saveable3D,
             "save": og.save_polyhedral_solid3D,
@@ -215,6 +226,7 @@ def geode_objects_dict():
             "input_factory": og.RasterImageInputFactory2D,
             "output_factory": og.RasterImageOutputFactory2D,
             "missing_files": og.check_raster_image_missing_files2D,
+            "is_loadable": og.is_raster_image_loadable2D,
             "load": og.load_raster_image2D,
             "is_saveable": og.is_raster_image_saveable2D,
             "save": og.save_raster_image2D,
@@ -227,6 +239,7 @@ def geode_objects_dict():
             "input_factory": og.RasterImageInputFactory3D,
             "output_factory": og.RasterImageOutputFactory3D,
             "missing_files": og.check_raster_image_missing_files3D,
+            "is_loadable": og.is_raster_image_loadable3D,
             "load": og.load_raster_image3D,
             "is_saveable": og.is_raster_image_saveable3D,
             "save": og.save_raster_image3D,
@@ -239,6 +252,7 @@ def geode_objects_dict():
             "input_factory": og.RegularGridInputFactory2D,
             "output_factory": og.RegularGridOutputFactory2D,
             "missing_files": og.check_regular_grid_missing_files2D,
+            "is_loadable": og.is_regular_grid_loadable2D,
             "load": og.load_regular_grid2D,
             "is_saveable": og.is_regular_grid_saveable2D,
             "save": og.save_regular_grid2D,
@@ -257,6 +271,7 @@ def geode_objects_dict():
             "input_factory": og.RegularGridInputFactory3D,
             "output_factory": og.RegularGridOutputFactory3D,
             "missing_files": og.check_regular_grid_missing_files3D,
+            "is_loadable": og.is_regular_grid_loadable3D,
             "load": og.load_regular_grid3D,
             "is_saveable": og.is_regular_grid_saveable3D,
             "save": og.save_regular_grid3D,
@@ -275,6 +290,7 @@ def geode_objects_dict():
             "input_factory": og.SectionInputFactory,
             "output_factory": og.SectionOutputFactory,
             "missing_files": og.check_section_missing_files,
+            "is_loadable": og.is_section_loadable,
             "load": og.load_section,
             "is_saveable": og.is_section_saveable,
             "save": og.save_section,
@@ -295,6 +311,7 @@ def geode_objects_dict():
             "input_factory": og_gs.StructuralModelInputFactory,
             "output_factory": og_gs.StructuralModelOutputFactory,
             "missing_files": og_gs.check_structural_model_missing_files,
+            "is_loadable": og_gs.is_structural_model_loadable,
             "load": og_gs.load_structural_model,
             "is_saveable": og_gs.is_structural_model_saveable,
             "save": og_gs.save_structural_model,
@@ -314,6 +331,7 @@ def geode_objects_dict():
             "input_factory": og.TetrahedralSolidInputFactory3D,
             "output_factory": og.TetrahedralSolidOutputFactory3D,
             "missing_files": og.check_tetrahedral_solid_missing_files3D,
+            "is_loadable": og.is_tetrahedral_solid_loadable3D,
             "load": og.load_tetrahedral_solid3D,
             "is_saveable": og.is_tetrahedral_solid_saveable3D,
             "save": og.save_tetrahedral_solid3D,
@@ -333,6 +351,7 @@ def geode_objects_dict():
             "input_factory": og.TriangulatedSurfaceInputFactory2D,
             "output_factory": og.TriangulatedSurfaceOutputFactory2D,
             "missing_files": og.check_triangulated_surface_missing_files2D,
+            "is_loadable": og.is_triangulated_surface_loadable2D,
             "load": og.load_triangulated_surface2D,
             "is_saveable": og.is_triangulated_surface_saveable2D,
             "save": og.save_triangulated_surface2D,
@@ -352,6 +371,7 @@ def geode_objects_dict():
             "input_factory": og.TriangulatedSurfaceInputFactory3D,
             "output_factory": og.TriangulatedSurfaceOutputFactory3D,
             "missing_files": og.check_triangulated_surface_missing_files3D,
+            "is_loadable": og.is_triangulated_surface_loadable3D,
             "load": og.load_triangulated_surface3D,
             "is_saveable": og.is_triangulated_surface_saveable3D,
             "save": og.save_triangulated_surface3D,
@@ -371,6 +391,7 @@ def geode_objects_dict():
             "input_factory": og.VertexSetInputFactory,
             "output_factory": og.VertexSetOutputFactory,
             "missing_files": og.check_vertex_set_missing_files,
+            "is_loadable": og.is_vertex_set_loadable,
             "load": og.load_vertex_set,
             "is_saveable": og.is_vertex_set_saveable,
             "save": og.save_vertex_set,

tests/test_functions.py

@@ -51,28 +51,33 @@ def test_missing_files():
             assert type(additional_files) is list
 
 
+def test_is_loadable():
+    for geode_object, value in geode_objects.geode_objects_dict().items():
+        input_extensions = geode_functions.geode_object_input_extensions(geode_object)
+        for input_extension in input_extensions:
+            file_absolute_path = os.path.abspath(f"tests/data/test.{input_extension}")
+            is_loadable = geode_functions.is_loadable(geode_object, file_absolute_path)
+            assert type(is_loadable) is bool
+
+
 def test_load():
     for geode_object, value in geode_objects.geode_objects_dict().items():
         print(f"\n{geode_object=}")
         input_extensions = geode_functions.geode_object_input_extensions(geode_object)
         for input_extension in input_extensions:
-            if geode_object != "RegularGrid3D" and input_extension != "vti":
-                print(f"\t{input_extension=}")
-                missing_files = geode_functions.missing_files(
-                    geode_object, f"tests/data/test.{input_extension}"
-                )
-                has_missing_files = missing_files.has_missing_files()
-                if has_missing_files:
-                    mandatory_files = missing_files.mandatory_files
-                    print(f"\t\t{mandatory_files=}")
-                    additional_files = missing_files.additional_files
-                    print(f"\t\t{additional_files=}")
-                file_apsolute_path = os.path.abspath(
-                    f"tests/data/test.{input_extension}"
-                )
-
+            print(f"\t{input_extension=}")
+            missing_files = geode_functions.missing_files(
+                geode_object, f"tests/data/test.{input_extension}"
+            )
+            has_missing_files = missing_files.has_missing_files()
+            if has_missing_files:
+                mandatory_files = missing_files.mandatory_files
+                print(f"\t\t{mandatory_files=}")
+                additional_files = missing_files.additional_files
+                print(f"\t\t{additional_files=}")
+            file_apsolute_path = os.path.abspath(f"tests/data/test.{input_extension}")
+            if geode_functions.is_loadable(geode_object, file_apsolute_path):
                 data = geode_functions.load(geode_object, file_apsolute_path)
-
                 if "save_viewable" in value:
                     uu_id = str(uuid.uuid4()).replace("-", "")
                     viewable_file_path = geode_functions.save_viewable(
@@ -143,22 +148,19 @@ def test_geode_object_output_extensions():
         print(f"\n{geode_object=}")
         input_extensions = geode_functions.geode_object_input_extensions(geode_object)
         for input_extension in input_extensions:
-            if geode_object != "RegularGrid3D" and input_extension != "vti":
-                print(f"\t{input_extension=}")
-                missing_files = geode_functions.missing_files(
-                    geode_object, f"tests/data/test.{input_extension}"
-                )
-                has_missing_files = missing_files.has_missing_files()
-                if has_missing_files:
-                    mandatory_files = missing_files.mandatory_files
-                    print(f"\t\t{mandatory_files=}")
-                    additional_files = missing_files.additional_files
-                    print(f"\t\t{additional_files=}")
-                file_apsolute_path = os.path.abspath(
-                    f"tests/data/test.{input_extension}"
-                )
-
-                data = geode_functions.load(geode_object, file_apsolute_path)
+            print(f"\t{input_extension=}")
+            missing_files = geode_functions.missing_files(
+                geode_object, f"tests/data/test.{input_extension}"
+            )
+            has_missing_files = missing_files.has_missing_files()
+            if has_missing_files:
+                mandatory_files = missing_files.mandatory_files
+                print(f"\t\t{mandatory_files=}")
+                additional_files = missing_files.additional_files
+                print(f"\t\t{additional_files=}")
+            file_absolute_path = os.path.abspath(f"tests/data/test.{input_extension}")
+            if geode_functions.is_loadable(geode_object, file_absolute_path):
+                data = geode_functions.load(geode_object, file_absolute_path)
                 geode_objets_and_output_extensions = (
                     geode_functions.geode_objects_output_extensions(geode_object, data)
                 )
@@ -215,27 +217,36 @@ def test_list_geode_objects():
         input_extensions = geode_functions.list_input_extensions(key)
         for geode_object, value in geode_objects.geode_objects_dict().items():
             for input_extension in input_extensions:
-                geode_objects_list = geode_functions.list_geode_objects(
-                    input_extension, key
+                file_absolute_path = os.path.abspath(
+                    f"tests/data/test.{input_extension}"
+                )
+                return_dict = geode_functions.list_geode_objects(
+                    file_absolute_path, key
                 )
-                assert type(geode_objects_list) is list
+                assert type(return_dict) is dict
 
                 if key != None:
-                    assert len(geode_objects_list) > 0
+                    assert len(return_dict.keys()) > 0
                     for invalid_geode_object in invalid_geode_objects:
-                        assert invalid_geode_object not in geode_objects_list
+                        assert invalid_geode_object not in return_dict.keys()
                 else:
-                    assert len(geode_objects_list) >= 1
+                    assert len(return_dict.keys()) >= 1
+                    for input_geode_object, input_extension_dict in return_dict.items():
+                        assert type(input_extension_dict) is dict
+                        for (
+                            input_extension,
+                            input_extension_value,
+                        ) in input_extension_dict.items():
+                            assert type(input_extension_value) is bool
 
 
 def test_geode_objects_output_extensions():
     for geode_object, value in geode_objects.geode_objects_dict().items():
         input_extensions = geode_functions.geode_object_input_extensions(geode_object)
         for input_extension in input_extensions:
-            if geode_object != "RegularGrid3D" and input_extension != "vti":
-                data = geode_functions.load(
-                    geode_object, f"tests/data/test.{input_extension}"
-                )
+            file_absolute_path = f"tests/data/test.{input_extension}"
+            if geode_functions.is_loadable(geode_object, file_absolute_path):
+                data = geode_functions.load(geode_object, file_absolute_path)
                 geode_objects_and_output_extensions = (
                     geode_functions.geode_objects_output_extensions(geode_object, data)
                 )