OpenGeodeWeb-Back 0.0.1__tar.gz

opengeodeweb_back-0.0.1/.github/workflows/Branch-protection.yml

@@ -0,0 +1,11 @@
+name: Check branch origin
+
+on:
+  pull_request:
+
+jobs:
+  check-branch-protection:
+    uses: Geode-solutions/actions/.github/workflows/branch-protection.yml@master
+    with:
+      branch_from: 'next'
+      branch_to: 'master'

opengeodeweb_back-0.0.1/.github/workflows/CD.yml

@@ -0,0 +1,26 @@
+name: CD
+
+on:
+  push:
+    branches: [ master, next ] 
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+    - name: Build
+      run: |
+        python3 -m pip install --upgrade build
+        python3 -m build
+        ls
+        ls dist
+    - name: Publish on PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        skip-existing: true
+        verbose: true
+        user: __token__
+        password: ${{ secrets.PYPI_TOKEN }}
+        packages-dir: "dist"

opengeodeweb_back-0.0.1/.gitignore

@@ -0,0 +1,2 @@
+.pytest_cache
+dist

opengeodeweb_back-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Geode-solutions
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

opengeodeweb_back-0.0.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.1
+Name: OpenGeodeWeb-Back
+Version: 0.0.1
+Summary: Open source library of python functions and OpenGeode wrappers
+Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back
+Project-URL: Bug Tracker, https://github.com/Geode-solutions/OpenGeodeWeb-Back/issues
+Author-email: Geode-solutions <contact@geode-solutions.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+
+<h1 align="center">OpenGeodeWeb-Back<sup><i>by Geode-solutions</i></sup></h1>
+<h3 align="center">OpenSource Python framework based on OpenGeode</h3>
+
+<p align="center">
+  <img src="https://github.com/Geode-solutions/OpenGeodeWeb-Back/workflows/CI/badge.svg" alt="Build Status">
+  <img src="https://github.com/Geode-solutions/OpenGeodeWeb-Back/workflows/CD/badge.svg" alt="Deploy Status">
+  <img src="https://codecov.io/gh/Geode-solutions/OpenGeodeWeb-Back/branch/master/graph/badge.svg" alt="Coverage Status">
+  <img src="https://img.shields.io/github/release/Geode-solutions/OpenGeodeWeb-Back.svg" alt="Version">
+  <img src="https://img.shields.io/pypi/v/opengeode-core" alt="PyPI" >
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/C%2B%2B-11-blue.svg" alt="Language">
+  <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License">
+  <img src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg" alt="Semantic-release">
+</p>
+
+---
+
+## Introduction
+
+OpenGeodeWeb-Back is an open source framework that proposes handy functions and wrappers for the OpenGeode ecosystem
+
+
+## Changelog
+Detailed changes for each release are documented in the [release notes](https://github.com/Geode-solutions/OpenGeodeWeb-Back/releases).
+
+
+## License
+[MIT](https://opensource.org/licenses/MIT)
+
+Copyright (c) 2019 - 2023, Geode-solutions

opengeodeweb_back-0.0.1/README.md

@@ -0,0 +1,33 @@
+
+<h1 align="center">OpenGeodeWeb-Back<sup><i>by Geode-solutions</i></sup></h1>
+<h3 align="center">OpenSource Python framework based on OpenGeode</h3>
+
+<p align="center">
+  <img src="https://github.com/Geode-solutions/OpenGeodeWeb-Back/workflows/CI/badge.svg" alt="Build Status">
+  <img src="https://github.com/Geode-solutions/OpenGeodeWeb-Back/workflows/CD/badge.svg" alt="Deploy Status">
+  <img src="https://codecov.io/gh/Geode-solutions/OpenGeodeWeb-Back/branch/master/graph/badge.svg" alt="Coverage Status">
+  <img src="https://img.shields.io/github/release/Geode-solutions/OpenGeodeWeb-Back.svg" alt="Version">
+  <img src="https://img.shields.io/pypi/v/opengeode-core" alt="PyPI" >
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/C%2B%2B-11-blue.svg" alt="Language">
+  <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License">
+  <img src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg" alt="Semantic-release">
+</p>
+
+---
+
+## Introduction
+
+OpenGeodeWeb-Back is an open source framework that proposes handy functions and wrappers for the OpenGeode ecosystem
+
+
+## Changelog
+Detailed changes for each release are documented in the [release notes](https://github.com/Geode-solutions/OpenGeodeWeb-Back/releases).
+
+
+## License
+[MIT](https://opensource.org/licenses/MIT)
+
+Copyright (c) 2019 - 2023, Geode-solutions

opengeodeweb_back-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["OpenGeode-core", "OpenGeode-IO", "OpenGeode-Geosciences", "OpenGeode-GeosciencesIO", "Geode-Viewables", "hatchling"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "OpenGeodeWeb-Back"
+version = "0.0.1"
+authors = [
+  { name="Geode-solutions", email="contact@geode-solutions.com" },
+]
+description = "Open source library of python functions and OpenGeode wrappers"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/Geode-solutions/OpenGeodeWeb-Back"
+"Bug Tracker" = "https://github.com/Geode-solutions/OpenGeodeWeb-Back/issues"

opengeodeweb_back-0.0.1/requirements.in

@@ -0,0 +1,5 @@
+OpenGeode-core
+OpenGeode-IO
+OpenGeode-Geosciences
+OpenGeode-GeosciencesIO
+Geode-Viewables

opengeodeweb_back-0.0.1/requirements.txt

@@ -0,0 +1,29 @@
+#
+# This file is autogenerated by pip-compile with Python 3.9
+# by the following command:
+#
+#    pip-compile --resolver=backtracking requirements.in
+#
+geode-common==26.1.3
+    # via geode-viewables
+geode-viewables==2.0.3
+    # via -r requirements.in
+opengeode-core==14.4.1
+    # via
+    #   -r requirements.in
+    #   geode-common
+    #   geode-viewables
+    #   opengeode-geosciences
+    #   opengeode-geosciencesio
+    #   opengeode-io
+opengeode-geosciences==7.1.1
+    # via
+    #   -r requirements.in
+    #   geode-viewables
+    #   opengeode-geosciencesio
+opengeode-geosciencesio==4.1.6
+    # via -r requirements.in
+opengeode-io==6.0.10
+    # via
+    #   -r requirements.in
+    #   geode-viewables

opengeodeweb_back-0.0.1/src/OpenGeodeWeb-Back/geode_functions.py

@@ -0,0 +1,234 @@
+import base64
+import geode_objects
+import os
+import pkg_resources
+import werkzeug
+import flask
+import uuid
+
+import opengeode_geosciences as og_gs
+import opengeode as og
+
+
+def list_objects_input_extensions(
+    is_viewable: bool = True,
+    geode_object: str = "",
+):
+    """
+    Purpose:
+        Function that returns a list of all input extensions
+    Returns:
+        An ordered list of input file extensions
+    """
+    return_list = []
+    objects_list = geode_objects.objects_list()
+
+    for object_ in objects_list.values():
+        if object_["is_viewable"] == is_viewable or geode_object == object_:
+            values = object_["input"]
+            for value in values:
+                list_creators = value.list_creators()
+                for creator in list_creators:
+                    if creator not in return_list:
+                        return_list.append(creator)
+    return_list.sort()
+    return return_list
+
+
+def list_objects(extension: str, is_viewable: bool = True):
+    """
+    Purpose:
+        Function that returns a list of objects that can handle a file, given his extension
+    Args:
+        extension -- The extension of the file
+    Returns:
+        An ordered list of object's names
+    """
+    return_list = []
+    objects_list = geode_objects.objects_list()
+
+    for object_, values in objects_list.items():
+        if values["is_viewable"] == is_viewable:
+            list_values = values["input"]
+            for value in list_values:
+                if value.has_creator(extension):
+                    if object_ not in return_list:
+                        return_list.append(object_)
+    return_list.sort()
+    return return_list
+
+
+def list_output_file_extensions(object: str):
+    """
+    Purpose:
+        Function that returns a list of output file extensions that can be handled by an object
+    Args:
+        object -- The name of the object
+    Returns:
+        An ordered list of file extensions
+    """
+    List = []
+    objects_list = geode_objects.objects_list()
+
+    values = objects_list[object]["output"]
+    for value in values:
+        list_creators = value.list_creators()
+        for creator in list_creators:
+            if creator not in List:
+                List.append(creator)
+    List.sort()
+    return List
+
+
+def get_versions(list_packages: list):
+    list_with_versions = []
+    for package in list_packages:
+        list_with_versions.append(
+            {
+                "package": package,
+                "version": pkg_resources.get_distribution(package).version,
+            }
+        )
+    return list_with_versions
+
+
+def upload_file(file: str, file_name: str, upload_folder: str, file_size: int):
+    if not os.path.exists(upload_folder):
+        os.mkdir(upload_folder)
+    file_decoded = base64.b64decode(file.split(",")[-1])
+    secure_file_name = werkzeug.utils.secure_filename(file_name)
+    file_path = os.path.join(upload_folder, secure_file_name)
+    f = open(file_path, "wb")
+    f.write(file_decoded)
+    f.close()
+
+    final_size = os.path.getsize(file_path)
+    return int(file_size) == int(final_size)
+
+
+def create_lock_file():
+    LOCK_FOLDER = flask.current_app.config["LOCK_FOLDER"]
+    if not os.path.exists(LOCK_FOLDER):
+        os.mkdir(LOCK_FOLDER)
+    flask.g.UUID = uuid.uuid4()
+    file_path = f"{LOCK_FOLDER}/{str(flask.g.UUID)}.txt"
+    f = open(file_path, "a")
+    f.close()
+
+
+def remove_lock_file():
+    LOCK_FOLDER = flask.current_app.config["LOCK_FOLDER"]
+    os.remove(f"{LOCK_FOLDER}/{str(flask.g.UUID)}.txt")
+
+
+def set_interval(func, sec):
+    def func_wrapper():
+        set_interval(func, sec)
+        func()
+
+    t = threading.Timer(sec, func_wrapper)
+    t.daemon = True
+    t.start()
+    return t
+
+
+def is_model(geode_object):
+    return geode_objects.objects_list()[geode_object]["is_model"]
+
+
+def is_3D(geode_object):
+    return geode_objects.objects_list()[geode_object]["is_3D"]
+
+
+def get_builder(geode_object, data):
+    return geode_objects.objects_list()[geode_object]["builder"](data)
+
+
+def load(file_path):
+    return geode_objects.objects_list()[geode_object]["load"](file_path)
+
+
+def save(data, geode_object, id, filename):
+    geode_objects.objects_list()[geode_object]["save"](
+        data, os.path.join(UPLOAD_FOLDER, filename)
+    )
+
+
+def save_viewable(data, geode_object, id):
+    geode_objects.objects_list()[geode_object]["save_viewable"](
+        data, os.path.join(UPLOAD_FOLDER, id)
+    )
+
+
+def get_geographic_coordinate_systems(geode_object):
+    if is_3D(geode_object):
+        return og_gs.GeographicCoordinateSystem3D.geographic_coordinate_systems()
+    else:
+        return og_gs.GeographicCoordinateSystem2D.geographic_coordinate_systems()
+
+
+def get_geographic_coordinate_systems_info(geode_object, crs):
+    if is_3D(geode_object):
+        return og_gs.GeographicCoordinateSystemInfo3D(
+            crs["authority"], crs["code"], crs["name"]
+        )
+    else:
+        return og_gs.GeographicCoordinateSystemInfo2D(
+            crs["authority"], crs["code"], crs["name"]
+        )
+
+
+def get_coordinate_system(geode_object, coordinate_system):
+    return og.CoordinateSystem2D(
+        [
+            og.Vector2D(
+                og.Point2D(
+                    [coordinate_system["origin_x"], coordinate_system["origin_y"]]
+                ),
+                og.Point2D(
+                    [coordinate_system["point_1_x"], coordinate_system["point_1_y"]]
+                ),
+            ),
+            og.Vector2D(
+                og.Point2D(
+                    [coordinate_system["origin_x"], coordinate_system["origin_y"]]
+                ),
+                og.Point2D(
+                    [coordinate_system["point_2_x"], coordinate_system["point_2_y"]]
+                ),
+            ),
+        ],
+        og.Point2D([coordinate_system["origin_x"], coordinate_system["origin_y"]]),
+    )
+
+
+def assign_geographic_coordinate_system_info(geode_object, data, input_crs):
+    builder = get_builder(geode_object, data)
+    info = get_geographic_coordinate_systems_info(geode_object, input_crs)
+    geode_objects.objects_list()[geode_object]["crs"]["assign"](
+        data, builder, input_crs["name"], info
+    )
+
+
+def convert_geographic_coordinate_system_info(geode_object, data, output_crs):
+    builder = get_builder(geode_object, data)
+    info = get_geographic_coordinate_systems_info(geode_object, output_crs)
+    geode_objects.objects_list()[geode_object]["crs"]["convert"](
+        data, builder, output_crs["name"], info
+    )
+
+
+def create_coordinate_system(
+    geode_object, data, name, input_coordinate_points, output_coordinate_points
+):
+    builder = get_builder(geode_object, data)
+
+    input_coordiante_system = get_coordinate_system(
+        geode_object, input_coordinate_points
+    )
+    output_coordiante_system = get_coordinate_system(
+        geode_object, output_coordinate_points
+    )
+    geode_objects.objects_list()[geode_object]["crs"]["create"](
+        data, builder, name, input_coordiante_system, output_coordiante_system
+    )

opengeodeweb_back-0.0.1/src/OpenGeodeWeb-Back/geode_objects.py

@@ -0,0 +1,324 @@
+import opengeode as og
+import opengeode_io as og_io
+import opengeode_geosciences as og_gs
+import opengeode_geosciencesio as og_gs_io
+import geode_viewables as g_v
+
+
+def objects_list():
+    return {
+        "BRep": {
+            "input": [og.BRepInputFactory],
+            "output": [og.BRepOutputFactory],
+            "load": og.load_brep,
+            "save": og.save_brep,
+            "builder": og.BRepBuilder,
+            "crs": {
+                "assign": og_gs.assign_brep_geographic_coordinate_system_info,
+                "convert": og_gs.convert_brep_coordinate_reference_system,
+                "create": og.create_brep_coordinate_system,
+            },
+            "is_model": True,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_brep,
+        },
+        "CrossSection": {
+            "input": [og_gs.CrossSectionInputFactory],
+            "output": [og.SectionOutputFactory, og_gs.CrossSectionOutputFactory],
+            "load": og_gs.load_cross_section,
+            "save": og_gs.save_cross_section,
+            "builder": og_gs.CrossSectionBuilder,
+            "crs": {
+                "assign": og_gs.assign_section_geographic_coordinate_system_info,
+                "convert": og_gs.convert_section_coordinate_reference_system,
+                "create": og.create_section_coordinate_system,
+            },
+            "is_model": True,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_cross_section,
+        },
+        "EdgedCurve2D": {
+            "input": [og.EdgedCurveInputFactory2D],
+            "output": [og.EdgedCurveOutputFactory2D],
+            "load": og.load_edged_curve2D,
+            "save": og.save_edged_curve2D,
+            "builder": og.EdgedCurveBuilder2D.create,
+            "crs": {
+                "assign": og_gs.assign_edged_curve_geographic_coordinate_system_info2D,
+                "convert": og_gs.convert_edged_curve_coordinate_reference_system2D,
+                "create": og.create_edged_curve_coordinate_system2D,
+            },
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_edged_curve2D,
+        },
+        "EdgedCurve3D": {
+            "input": [og.EdgedCurveInputFactory3D],
+            "output": [og.EdgedCurveOutputFactory3D],
+            "load": og.load_edged_curve3D,
+            "save": og.save_edged_curve3D,
+            "builder": og.EdgedCurveBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_edged_curve_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_edged_curve_coordinate_reference_system3D,
+                "create": og.create_edged_curve_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_edged_curve3D,
+        },
+        "Graph": {
+            "input": [og.GraphInputFactory],
+            "output": [og.GraphOutputFactory],
+            "load": og.load_graph,
+            "save": og.save_graph,
+            "builder": og.GraphBuilder.create,
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": "",
+        },
+        "HybridSolid3D": {
+            "input": [og.HybridSolidInputFactory3D],
+            "output": [og.HybridSolidOutputFactory3D],
+            "load": og.load_hybrid_solid3D,
+            "save": og.save_hybrid_solid3D,
+            "builder": og.HybridSolidBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_solid_mesh_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_solid_mesh_coordinate_reference_system3D,
+                "create": og.create_solid_mesh_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_hybrid_solid3D,
+        },
+        "PointSet2D": {
+            "input": [og.PointSetInputFactory2D],
+            "output": [og.PointSetOutputFactory2D],
+            "load": og.load_point_set2D,
+            "save": og.save_point_set2D,
+            "builder": og.PointSetBuilder2D.create,
+            "crs": {
+                "assign": og_gs.assign_point_set_geographic_coordinate_system_info2D,
+                "convert": og_gs.convert_point_set_coordinate_reference_system2D,
+                "create": og.create_point_set_coordinate_system2D,
+            },
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_point_set2D,
+        },
+        "PointSet3D": {
+            "input": [og.PointSetInputFactory3D],
+            "output": [og.PointSetOutputFactory3D],
+            "load": og.load_point_set3D,
+            "save": og.save_point_set3D,
+            "builder": og.PointSetBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_point_set_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_point_set_coordinate_reference_system3D,
+                "create": og.create_point_set_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_point_set3D,
+        },
+        "PolygonalSurface2D": {
+            "input": [og.PolygonalSurfaceInputFactory2D],
+            "output": [og.PolygonalSurfaceOutputFactory2D],
+            "load": og.load_polygonal_surface2D,
+            "save": og.save_polygonal_surface2D,
+            "builder": og.PolygonalSurfaceBuilder2D.create,
+            "crs": {
+                "assign": og_gs.assign_surface_mesh_geographic_coordinate_system_info2D,
+                "convert": og_gs.convert_surface_mesh_coordinate_reference_system2D,
+                "create": og.create_surface_mesh_coordinate_system2D,
+            },
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_polygonal_surface2D,
+        },
+        "PolygonalSurface3D": {
+            "input": [og.PolygonalSurfaceInputFactory3D],
+            "output": [og.PolygonalSurfaceOutputFactory3D],
+            "load": og.load_polygonal_surface3D,
+            "save": og.save_polygonal_surface3D,
+            "builder": og.PolygonalSurfaceBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_surface_mesh_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_surface_mesh_coordinate_reference_system3D,
+                "create": og.create_surface_mesh_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_polygonal_surface3D,
+        },
+        "PolyhedralSolid3D": {
+            "input": [og.PolyhedralSolidInputFactory3D],
+            "output": [og.PolyhedralSolidOutputFactory3D],
+            "load": og.load_polyhedral_solid3D,
+            "save": og.save_polyhedral_solid3D,
+            "builder": og.PolyhedralSolidBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_solid_mesh_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_solid_mesh_coordinate_reference_system3D,
+                "create": og.create_solid_mesh_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_polyhedral_solid3D,
+        },
+        "RasterImage2D": {
+            "input": [og.RasterImageInputFactory2D],
+            "output": [og.RasterImageOutputFactory2D],
+            "load": og.load_raster_image2D,
+            "save": og.save_raster_image2D,
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": False,
+            "save_viewable": g_v.save_viewable_raster_image2D,
+        },
+        "RasterImage3D": {
+            "input": [og.RasterImageInputFactory3D],
+            "output": [og.RasterImageOutputFactory3D],
+            "load": og.load_raster_image3D,
+            "save": og.save_raster_image3D,
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": False,
+            "save_viewable": g_v.save_viewable_raster_image3D,
+        },
+        "RegularGrid2D": {
+            "input": [og.RegularGridInputFactory2D],
+            "output": [og.RegularGridOutputFactory2D],
+            "load": og.load_regular_grid2D,
+            "save": og.save_regular_grid2D,
+            "builder": og.RegularGridBuilder2D.create,
+            "crs": {
+                "assign": og_gs.assign_surface_mesh_geographic_coordinate_system_info2D,
+                "convert": og_gs.convert_surface_mesh_coordinate_reference_system2D,
+                "create": og.create_surface_mesh_coordinate_system2D,
+            },
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_regular_grid2D,
+        },
+        "RegularGrid3D": {
+            "input": [og.RegularGridInputFactory3D],
+            "output": [og.RegularGridOutputFactory3D],
+            "load": og.load_regular_grid3D,
+            "save": og.save_regular_grid3D,
+            "builder": og.RegularGridBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_solid_mesh_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_solid_mesh_coordinate_reference_system3D,
+                "create": og.create_surface_mesh_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_regular_grid3D,
+        },
+        "Section": {
+            "input": [og.SectionInputFactory],
+            "output": [og.SectionOutputFactory],
+            "load": og.load_section,
+            "save": og.save_section,
+            "builder": og.SectionBuilder,
+            "crs": {
+                "assign": og_gs.assign_section_geographic_coordinate_system_info,
+                "convert": og_gs.convert_section_coordinate_reference_system,
+                "create": og.create_section_coordinate_system,
+            },
+            "is_model": True,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_section,
+        },
+        "StructuralModel": {
+            "input": [og_gs.StructuralModelInputFactory],
+            "output": [og.BRepOutputFactory, og_gs.StructuralModelOutputFactory],
+            "load": og_gs.load_structural_model,
+            "save": og_gs.save_structural_model,
+            "builder": og_gs.StructuralModelBuilder,
+            "crs": {
+                "assign": og_gs.assign_brep_geographic_coordinate_system_info,
+                "convert": og_gs.convert_brep_coordinate_reference_system,
+                "create": og.create_brep_coordinate_system,
+            },
+            "is_model": True,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_structural_model,
+        },
+        "TetrahedralSolid3D": {
+            "input": [og.TetrahedralSolidInputFactory3D],
+            "output": [og.TetrahedralSolidOutputFactory3D],
+            "load": og.load_tetrahedral_solid3D,
+            "save": og.save_tetrahedral_solid3D,
+            "builder": og.TetrahedralSolidBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_solid_mesh_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_solid_mesh_coordinate_reference_system3D,
+                "create": og.create_solid_mesh_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_tetrahedral_solid3D,
+        },
+        "TriangulatedSurface2D": {
+            "input": [og.TriangulatedSurfaceInputFactory2D],
+            "output": [og.TriangulatedSurfaceOutputFactory2D],
+            "load": og.load_triangulated_surface2D,
+            "save": og.save_triangulated_surface2D,
+            "builder": og.TriangulatedSurfaceBuilder2D.create,
+            "crs": {
+                "assign": og_gs.assign_surface_mesh_geographic_coordinate_system_info2D,
+                "convert": og_gs.convert_surface_mesh_coordinate_reference_system2D,
+                "create": og.create_surface_mesh_coordinate_system2D,
+            },
+            "is_model": False,
+            "is_3D": False,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_triangulated_surface2D,
+        },
+        "TriangulatedSurface3D": {
+            "input": [og.TriangulatedSurfaceInputFactory3D],
+            "output": [og.TriangulatedSurfaceOutputFactory3D],
+            "load": og.load_triangulated_surface3D,
+            "save": og.save_triangulated_surface3D,
+            "builder": og.TriangulatedSurfaceBuilder3D.create,
+            "crs": {
+                "assign": og_gs.assign_surface_mesh_geographic_coordinate_system_info3D,
+                "convert": og_gs.convert_surface_mesh_coordinate_reference_system3D,
+                "create": og.create_surface_mesh_coordinate_system3D,
+            },
+            "is_model": False,
+            "is_3D": True,
+            "is_viewable": True,
+            "save_viewable": g_v.save_viewable_triangulated_surface3D,
+        },
+        "VertexSet": {
+            "input": [og.VertexSetInputFactory],
+            "output": [og.VertexSetOutputFactory],
+            "load": og.load_vertex_set,
+            "save": og.save_vertex_set,
+            "builder": og.VertexSetBuilder.create,
+            "is_model": True,
+            "is_3D": False,
+            "is_viewable": False,
+            "save_viewable": "",
+        },
+    }