OpenGeodeWeb-Back 5.11.0__tar.gz → 5.11.2__tar.gz

{opengeodeweb_back-5.11.0/src/OpenGeodeWeb_Back.egg-info → opengeodeweb_back-5.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 5.11.0
+Version: 5.11.2
 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
@@ -27,7 +27,7 @@ Requires-Dist: opengeode-geosciencesio==5.8.1
 Requires-Dist: opengeode-inspector==6.8.2
 Requires-Dist: opengeode-io==7.4.2
 Requires-Dist: werkzeug==3.1.2
-Requires-Dist: opengeodeweb-microservice==1.*,>=1.0.5
+Requires-Dist: opengeodeweb-microservice==1.*,>=1.0.7rc1
 Dynamic: license-file
 
 <h1 align="center">OpenGeodeWeb-Back<sup><i>by Geode-solutions</i></sup></h1>

{opengeodeweb_back-5.11.0 → opengeodeweb_back-5.11.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "5.11.0"
+version = "5.11.2"
 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-5.11.0 → opengeodeweb_back-5.11.2}/requirements.txt

@@ -60,4 +60,4 @@ werkzeug==3.1.2
     #   flask
     #   flask-cors
 
-opengeodeweb-microservice==1.*,>=1.0.5
+opengeodeweb-microservice==1.*,>=1.0.7rc1

{opengeodeweb_back-5.11.0 → opengeodeweb_back-5.11.2/src/OpenGeodeWeb_Back.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 5.11.0
+Version: 5.11.2
 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
@@ -27,7 +27,7 @@ Requires-Dist: opengeode-geosciencesio==5.8.1
 Requires-Dist: opengeode-inspector==6.8.2
 Requires-Dist: opengeode-io==7.4.2
 Requires-Dist: werkzeug==3.1.2
-Requires-Dist: opengeodeweb-microservice==1.*,>=1.0.5
+Requires-Dist: opengeodeweb-microservice==1.*,>=1.0.7rc1
 Dynamic: license-file
 
 <h1 align="center">OpenGeodeWeb-Back<sup><i>by Geode-solutions</i></sup></h1>

{opengeodeweb_back-5.11.0 → opengeodeweb_back-5.11.2}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -18,25 +18,46 @@ src/opengeodeweb_back/test_utils.py
 src/opengeodeweb_back/utils_functions.py
 src/opengeodeweb_back/routes/blueprint_routes.py
 src/opengeodeweb_back/routes/create/blueprint_create.py
+src/opengeodeweb_back/routes/create/schemas/__init__.py
 src/opengeodeweb_back/routes/create/schemas/create_aoi.json
+src/opengeodeweb_back/routes/create/schemas/create_aoi.py
 src/opengeodeweb_back/routes/create/schemas/create_point.json
+src/opengeodeweb_back/routes/create/schemas/create_point.py
 src/opengeodeweb_back/routes/models/blueprint_models.py
+src/opengeodeweb_back/routes/models/schemas/__init__.py
 src/opengeodeweb_back/routes/models/schemas/mesh_components.json
+src/opengeodeweb_back/routes/models/schemas/mesh_components.py
 src/opengeodeweb_back/routes/models/schemas/vtm_component_indices.json
+src/opengeodeweb_back/routes/models/schemas/vtm_component_indices.py
+src/opengeodeweb_back/routes/schemas/__init__.py
 src/opengeodeweb_back/routes/schemas/allowed_files.json
+src/opengeodeweb_back/routes/schemas/allowed_files.py
 src/opengeodeweb_back/routes/schemas/allowed_objects.json
+src/opengeodeweb_back/routes/schemas/allowed_objects.py
 src/opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.json
+src/opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.py
 src/opengeodeweb_back/routes/schemas/geographic_coordinate_systems.json
+src/opengeodeweb_back/routes/schemas/geographic_coordinate_systems.py
 src/opengeodeweb_back/routes/schemas/inspect_file.json
+src/opengeodeweb_back/routes/schemas/inspect_file.py
 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/ping.json
+src/opengeodeweb_back/routes/schemas/ping.py
 src/opengeodeweb_back/routes/schemas/polygon_attribute_names.json
+src/opengeodeweb_back/routes/schemas/polygon_attribute_names.py
 src/opengeodeweb_back/routes/schemas/polyhedron_attribute_names.json
+src/opengeodeweb_back/routes/schemas/polyhedron_attribute_names.py
 src/opengeodeweb_back/routes/schemas/save_viewable_file.json
+src/opengeodeweb_back/routes/schemas/save_viewable_file.py
 src/opengeodeweb_back/routes/schemas/texture_coordinates.json
+src/opengeodeweb_back/routes/schemas/texture_coordinates.py
 src/opengeodeweb_back/routes/schemas/upload_file.json
+src/opengeodeweb_back/routes/schemas/upload_file.py
 src/opengeodeweb_back/routes/schemas/vertex_attribute_names.json
+src/opengeodeweb_back/routes/schemas/vertex_attribute_names.py
 tests/test_create_routes.py
 tests/test_geode_functions.py
 tests/test_models_routes.py

{opengeodeweb_back-5.11.0 → opengeodeweb_back-5.11.2}/src/OpenGeodeWeb_Back.egg-info/requires.txt

@@ -14,4 +14,4 @@ opengeode-geosciencesio==5.8.1
 opengeode-inspector==6.8.2
 opengeode-io==7.4.2
 werkzeug==3.1.2
-opengeodeweb-microservice==1.*,>=1.0.5
+opengeodeweb-microservice==1.*,>=1.0.7rc1

{opengeodeweb_back-5.11.0 → opengeodeweb_back-5.11.2}/src/opengeodeweb_back/geode_functions.py

@@ -175,7 +175,7 @@ def filter_geode_objects(key: str = None):
     return geode_objects_filtered_list
 
 
-def list_input_extensions(key: str = None):
+def list_input_extensions(key: str | None = None) -> list[str]:
     extensions_list = []
     geode_objects_filtered_list = filter_geode_objects(key)
     for geode_object in geode_objects_filtered_list:
@@ -192,7 +192,7 @@ def has_creator(geode_object: str, extension: str):
 
 def list_geode_objects(
     file_absolute_path: str,
-    key: str = None,
+    key: str | None = None,
 ):
     return_dict = {}
     file_extension = utils_functions.extension_from_filename(

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/blueprint_routes.py

@@ -0,0 +1,270 @@
+# Standard library imports
+import os
+import time
+
+# Third party imports
+import flask
+import werkzeug
+from opengeodeweb_microservice.schemas import get_schemas_dict
+
+# Local application imports
+from opengeodeweb_back import geode_functions, utils_functions
+from .models import blueprint_models
+from . import schemas
+
+routes = flask.Blueprint("routes", __name__, url_prefix="/opengeodeweb_back")
+
+
+routes.register_blueprint(
+    blueprint_models.routes,
+    url_prefix=blueprint_models.routes.url_prefix,
+    name=blueprint_models.routes.name,
+)
+
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+
+@routes.route(
+    schemas_dict["allowed_files"]["route"],
+    methods=schemas_dict["allowed_files"]["methods"],
+)
+def allowed_files() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["allowed_files"])
+    params = schemas.AllowedFiles.from_dict(flask.request.get_json())
+    extensions = geode_functions.list_input_extensions(params.supported_feature)
+    return flask.make_response({"extensions": extensions}, 200)
+
+
+@routes.route(
+    schemas_dict["upload_file"]["route"],
+    methods=schemas_dict["upload_file"]["methods"],
+)
+def upload_file() -> flask.Response:
+    if flask.request.method == "OPTIONS":
+        return flask.make_response({}, 200)
+
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    if not os.path.exists(UPLOAD_FOLDER):
+        os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+    file = flask.request.files["file"]
+    filename = werkzeug.utils.secure_filename(os.path.basename(file.filename))
+    file.save(os.path.join(UPLOAD_FOLDER, filename))
+    return flask.make_response({"message": "File uploaded"}, 201)
+
+
+@routes.route(
+    schemas_dict["allowed_objects"]["route"],
+    methods=schemas_dict["allowed_objects"]["methods"],
+)
+def allowed_objects() -> flask.Response:
+    if flask.request.method == "OPTIONS":
+        return flask.make_response({}, 200)
+
+    utils_functions.validate_request(flask.request, schemas_dict["allowed_objects"])
+    params = schemas.AllowedObjects.from_dict(flask.request.get_json())
+    file_absolute_path = geode_functions.upload_file_path(params.filename)
+    allowed_objects = geode_functions.list_geode_objects(
+        file_absolute_path, params.supported_feature
+    )
+    return flask.make_response({"allowed_objects": allowed_objects}, 200)
+
+
+@routes.route(
+    schemas_dict["missing_files"]["route"],
+    methods=schemas_dict["missing_files"]["methods"],
+)
+def missing_files() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["missing_files"])
+    params = schemas.MissingFiles.from_dict(flask.request.get_json())
+    file_path = geode_functions.upload_file_path(params.filename)
+
+    additional_files = geode_functions.additional_files(
+        params.input_geode_object,
+        file_path,
+    )
+
+    has_missing_files = any(
+        file.is_missing
+        for file in additional_files.mandatory_files + additional_files.optional_files
+    )
+
+    mandatory_files = [
+        os.path.basename(file.filename)
+        for file in additional_files.mandatory_files
+        if file.is_missing
+    ]
+    additional_files = [
+        os.path.basename(file.filename)
+        for file in additional_files.optional_files
+        if file.is_missing
+    ]
+
+    return flask.make_response(
+        {
+            "has_missing_files": has_missing_files,
+            "mandatory_files": mandatory_files,
+            "additional_files": additional_files,
+        },
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["geographic_coordinate_systems"]["route"],
+    methods=schemas_dict["geographic_coordinate_systems"]["methods"],
+)
+def crs_converter_geographic_coordinate_systems() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["geographic_coordinate_systems"]
+    )
+    params = schemas.GeographicCoordinateSystems.from_dict(flask.request.get_json())
+    infos = geode_functions.geographic_coordinate_systems(params.input_geode_object)
+    crs_list = []
+    for info in infos:
+        crs = {}
+        crs["name"] = info.name
+        crs["code"] = info.code
+        crs["authority"] = info.authority
+        crs_list.append(crs)
+
+    return flask.make_response({"crs_list": crs_list}, 200)
+
+
+@routes.route(
+    schemas_dict["inspect_file"]["route"],
+    methods=schemas_dict["inspect_file"]["methods"],
+)
+def inspect_file() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["inspect_file"])
+    params = schemas.InspectFile.from_dict(flask.request.get_json())
+    file_path = geode_functions.upload_file_path(params.filename)
+    data = geode_functions.load(params.input_geode_object, file_path)
+    class_inspector = geode_functions.inspect(params.input_geode_object, data)
+    inspection_result = geode_functions.get_inspector_children(class_inspector)
+    return flask.make_response({"inspection_result": inspection_result}, 200)
+
+
+@routes.route(
+    schemas_dict["geode_objects_and_output_extensions"]["route"],
+    methods=schemas_dict["geode_objects_and_output_extensions"]["methods"],
+)
+def geode_objects_and_output_extensions() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["geode_objects_and_output_extensions"]
+    )
+    params = schemas.GeodeObjectsAndOutputExtensions.from_dict(flask.request.get_json())
+    file_path = geode_functions.upload_file_path(params.filename)
+    data = geode_functions.load(
+        params.input_geode_object,
+        file_path,
+    )
+    geode_objects_and_output_extensions = (
+        geode_functions.geode_objects_output_extensions(params.input_geode_object, data)
+    )
+    return flask.make_response(
+        {"geode_objects_and_output_extensions": geode_objects_and_output_extensions},
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["save_viewable_file"]["route"],
+    methods=schemas_dict["save_viewable_file"]["methods"],
+)
+def save_viewable_file() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["save_viewable_file"])
+    params = schemas.SaveViewableFile.from_dict(flask.request.get_json())
+    return flask.make_response(
+        utils_functions.generate_native_viewable_and_light_viewable_from_file(
+            geode_object=params.input_geode_object,
+            input_filename=params.filename,
+        ),
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["texture_coordinates"]["route"],
+    methods=schemas_dict["texture_coordinates"]["methods"],
+)
+def texture_coordinates() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["texture_coordinates"])
+    params = schemas.TextureCoordinates.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
+    texture_coordinates = data.texture_manager().texture_names()
+    return flask.make_response({"texture_coordinates": texture_coordinates}, 200)
+
+
+@routes.route(
+    schemas_dict["vertex_attribute_names"]["route"],
+    methods=schemas_dict["vertex_attribute_names"]["methods"],
+)
+def vertex_attribute_names() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["vertex_attribute_names"]
+    )
+    params = schemas.VertexAttributeNames.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
+    vertex_attribute_names = data.vertex_attribute_manager().attribute_names()
+    return flask.make_response(
+        {
+            "vertex_attribute_names": vertex_attribute_names,
+        },
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["polygon_attribute_names"]["route"],
+    methods=schemas_dict["polygon_attribute_names"]["methods"],
+)
+def polygon_attribute_names() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["polygon_attribute_names"]
+    )
+    params = schemas.PolygonAttributeNames.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
+    polygon_attribute_names = data.polygon_attribute_manager().attribute_names()
+    return flask.make_response(
+        {
+            "polygon_attribute_names": polygon_attribute_names,
+        },
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["polyhedron_attribute_names"]["route"],
+    methods=schemas_dict["polyhedron_attribute_names"]["methods"],
+)
+def polyhedron_attribute_names() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["polyhedron_attribute_names"]
+    )
+    params = schemas.PolyhedronAttributeNames.from_dict(flask.request.get_json())
+    data = geode_functions.load_data(params.id)
+    polyhedron_attribute_names = data.polyhedron_attribute_manager().attribute_names()
+    return flask.make_response(
+        {
+            "polyhedron_attribute_names": polyhedron_attribute_names,
+        },
+        200,
+    )
+
+
+@routes.route(
+    schemas_dict["ping"]["route"],
+    methods=schemas_dict["ping"]["methods"],
+)
+def ping() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["ping"])
+    flask.current_app.config.update(LAST_PING_TIME=time.time())
+    return flask.make_response({"message": "Flask server is running"}, 200)
+
+
+@routes.route(schemas_dict["kill"]["route"], methods=schemas_dict["kill"]["methods"])
+def kill() -> flask.Response:
+    print("Manual server kill, shutting down...", flush=True)
+    os._exit(0)
+    return flask.make_response({"message": "Flask server is dead"}, 200)

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/create/blueprint_create.py

@@ -0,0 +1,71 @@
+# Standard library imports
+import os
+
+# Third party imports
+import flask
+import opengeode
+from opengeodeweb_microservice.schemas import get_schemas_dict
+
+# Local application imports
+from opengeodeweb_back import geode_functions, utils_functions
+from . import schemas
+
+routes = flask.Blueprint("create", __name__, url_prefix="/create")
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+
+@routes.route(
+    schemas_dict["create_point"]["route"],
+    methods=schemas_dict["create_point"]["methods"],
+)
+def create_point() -> flask.Response:
+    """Endpoint to create a single point in 3D space."""
+    print(f"create_point : {flask.request=}", flush=True)
+    utils_functions.validate_request(flask.request, schemas_dict["create_point"])
+    params = schemas.CreatePoint.from_dict(flask.request.get_json())
+
+    # Create the point
+    pointset = geode_functions.geode_object_class("PointSet3D").create()
+    builder = geode_functions.create_builder("PointSet3D", pointset)
+    builder.set_name(params.name)
+    builder.create_point(opengeode.Point3D([params.x, params.y, params.z]))
+
+    # Save and get info
+    result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
+        geode_object="PointSet3D",
+        data=pointset,
+    )
+    return flask.make_response(result, 200)
+
+
+@routes.route(
+    schemas_dict["create_aoi"]["route"], methods=schemas_dict["create_aoi"]["methods"]
+)
+def create_aoi() -> flask.Response:
+    """Endpoint to create an Area of Interest (AOI) as an EdgedCurve3D."""
+    print(f"create_aoi : {flask.request=}", flush=True)
+    utils_functions.validate_request(flask.request, schemas_dict["create_aoi"])
+    params = schemas.CreateAoi.from_dict(flask.request.get_json())
+
+    # Create the edged curve
+    edged_curve = geode_functions.geode_object_class("EdgedCurve3D").create()
+    builder = geode_functions.create_builder("EdgedCurve3D", edged_curve)
+    builder.set_name(params.name)
+
+    # Create vertices first
+    for point in params.points:
+        pp = opengeode.Point3D([point.x, point.y, params.z])
+        builder.create_point(opengeode.Point3D([point.x, point.y, params.z]))
+
+    # Create edges between consecutive vertices and close the loop
+    num_vertices = len(params.points)
+    for i in range(num_vertices):
+        next_i = (i + 1) % num_vertices
+        builder.create_edge_with_vertices(i, next_i)
+
+    # Save and get info
+    result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
+        geode_object="EdgedCurve3D",
+        data=edged_curve,
+    )
+    return flask.make_response(result, 200)

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/create/schemas/__init__.py

@@ -0,0 +1,2 @@
+from .create_point import *
+from .create_aoi import *

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/create/schemas/create_aoi.py

@@ -0,0 +1,19 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Point(DataClassJsonMixin):
+    x: float
+    y: float
+
+
+@dataclass
+class CreateAoi(DataClassJsonMixin):
+    name: str
+    """Name of the AOI"""
+
+    points: List[Point]
+    z: float
+    id: Optional[str] = None

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/create/schemas/create_point.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class CreatePoint(DataClassJsonMixin):
+    name: str
+    x: float
+    y: float
+    z: float

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/models/blueprint_models.py

@@ -0,0 +1,49 @@
+import os
+import xml.etree.ElementTree as ET
+import flask
+from opengeodeweb_microservice.schemas import get_schemas_dict
+
+from opengeodeweb_back import geode_functions, utils_functions
+from . import schemas
+
+routes = flask.Blueprint("models", __name__, url_prefix="/models")
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+
+@routes.route(
+    schemas_dict["vtm_component_indices"]["route"],
+    methods=schemas_dict["vtm_component_indices"]["methods"],
+)
+def uuid_to_flat_index() -> flask.Response:
+    utils_functions.validate_request(
+        flask.request, schemas_dict["vtm_component_indices"]
+    )
+    params = schemas.VtmComponentIndices.from_dict(flask.request.get_json())
+    vtm_file_path = geode_functions.data_file_path(params.id, "viewable.vtm")
+    tree = ET.parse(vtm_file_path)
+    root = tree.find("vtkMultiBlockDataSet")
+    if root is None:
+        raise Exception("Failed to read viewable file")
+    uuid_to_flat_index = {}
+    current_index = 0
+    for elem in root.iter():
+        if "uuid" in elem.attrib and elem.tag == "DataSet":
+            uuid_to_flat_index[elem.attrib["uuid"]] = current_index
+        current_index += 1
+    return flask.make_response({"uuid_to_flat_index": uuid_to_flat_index}, 200)
+
+
+@routes.route(
+    schemas_dict["mesh_components"]["route"],
+    methods=schemas_dict["mesh_components"]["methods"],
+)
+def extract_uuids_endpoint() -> flask.Response:
+    utils_functions.validate_request(flask.request, schemas_dict["mesh_components"])
+    params = schemas.MeshComponents.from_dict(flask.request.get_json())
+    model = geode_functions.load_data(params.id)
+    mesh_components = model.mesh_components()
+    uuid_dict = {}
+    for mesh_component, ids in mesh_components.items():
+        component_name = mesh_component.get()
+        uuid_dict[component_name] = [id.string() for id in ids]
+    return flask.make_response({"uuid_dict": uuid_dict}, 200)

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/models/schemas/__init__.py

@@ -0,0 +1,2 @@
+from .vtm_component_indices import *
+from .mesh_components import *

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/models/schemas/mesh_components.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class MeshComponents(DataClassJsonMixin):
+    id: str

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/models/schemas/vtm_component_indices.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class VtmComponentIndices(DataClassJsonMixin):
+    id: str

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/__init__.py

@@ -0,0 +1,14 @@
+from .vertex_attribute_names import *
+from .upload_file import *
+from .texture_coordinates import *
+from .save_viewable_file import *
+from .polyhedron_attribute_names import *
+from .polygon_attribute_names import *
+from .ping import *
+from .missing_files import *
+from .kill import *
+from .inspect_file import *
+from .geographic_coordinate_systems import *
+from .geode_objects_and_output_extensions import *
+from .allowed_objects import *
+from .allowed_files import *

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/allowed_files.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AllowedFiles(DataClassJsonMixin):
+    supported_feature: Optional[str] = None

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/allowed_objects.py

@@ -0,0 +1,9 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AllowedObjects(DataClassJsonMixin):
+    filename: str
+    supported_feature: Optional[str] = None

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class GeodeObjectsAndOutputExtensions(DataClassJsonMixin):
+    filename: str
+    input_geode_object: str

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/geographic_coordinate_systems.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class GeographicCoordinateSystems(DataClassJsonMixin):
+    input_geode_object: str

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/inspect_file.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class InspectFile(DataClassJsonMixin):
+    filename: str
+    input_geode_object: str

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/kill.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Kill(DataClassJsonMixin):
+    pass

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/missing_files.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class MissingFiles(DataClassJsonMixin):
+    filename: str
+    input_geode_object: str

opengeodeweb_back-5.11.2/src/opengeodeweb_back/routes/schemas/ping.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Ping(DataClassJsonMixin):
+    pass