OpenGeodeWeb-Back 3.1.0__tar.gz → 3.2.0rc2__tar.gz

{OpenGeodeWeb-Back-3.1.0/src/OpenGeodeWeb_Back.egg-info → OpenGeodeWeb-Back-3.2.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OpenGeodeWeb-Back
-Version: 3.1.0
+Version: 3.2.0rc2
 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
@@ -17,6 +17,7 @@ Requires-Dist: blinker==1.7.0
 Requires-Dist: click==8.1.7
 Requires-Dist: colorama==0.4.6
 Requires-Dist: flask[async]==3.0.0
+Requires-Dist: flask-cors==4.0.0
 Requires-Dist: geode-background==7.4.9
 Requires-Dist: geode-common==30.0.5
 Requires-Dist: geode-conversion==5.1.7

{OpenGeodeWeb-Back-3.1.0 → OpenGeodeWeb-Back-3.2.0rc2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "3.1.0"
+version = "3.2.0-rc.2"
 dynamic = ["dependencies"]
 authors = [
   { name="Geode-solutions", email="team-web@geode-solutions.com" },
@@ -26,6 +26,9 @@ classifiers = [
 [tool.setuptools.dynamic]
 dependencies = {file = ["requirements.txt"]}
 
+[tool.setuptools.package-data]
+'src' = ['src/*.json']
+
 [tool.semantic_release]
 version_toml = [
     "pyproject.toml:project.version",

{OpenGeodeWeb-Back-3.1.0 → OpenGeodeWeb-Back-3.2.0rc2}/requirements.txt

@@ -17,6 +17,10 @@ click==8.1.7
 colorama==0.4.6
     # via click
 flask[async]==3.0.0
+    # via
+    #   -r requirements.in
+    #   flask-cors
+flask-cors==4.0.0
     # via -r requirements.in
 geode-background==7.4.9
     # via

{OpenGeodeWeb-Back-3.1.0 → OpenGeodeWeb-Back-3.2.0rc2/src/OpenGeodeWeb_Back.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OpenGeodeWeb-Back
-Version: 3.1.0
+Version: 3.2.0rc2
 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
@@ -17,6 +17,7 @@ Requires-Dist: blinker==1.7.0
 Requires-Dist: click==8.1.7
 Requires-Dist: colorama==0.4.6
 Requires-Dist: flask[async]==3.0.0
+Requires-Dist: flask-cors==4.0.0
 Requires-Dist: geode-background==7.4.9
 Requires-Dist: geode-common==30.0.5
 Requires-Dist: geode-conversion==5.1.7

{OpenGeodeWeb-Back-3.1.0 → OpenGeodeWeb-Back-3.2.0rc2}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -11,4 +11,6 @@ src/opengeodeweb_back/__init__.py
 src/opengeodeweb_back/geode_functions.py
 src/opengeodeweb_back/geode_objects.py
 src/opengeodeweb_back/inspector_functions.py
-tests/test_functions.py
+src/opengeodeweb_back/routes/blueprint_routes.py
+tests/test_functions.py
+tests/test_routes.py

{OpenGeodeWeb-Back-3.1.0 → OpenGeodeWeb-Back-3.2.0rc2}/src/OpenGeodeWeb_Back.egg-info/requires.txt

@@ -4,6 +4,7 @@ blinker==1.7.0
 click==8.1.7
 colorama==0.4.6
 flask[async]==3.0.0
+flask-cors==4.0.0
 geode-background==7.4.9
 geode-common==30.0.5
 geode-conversion==5.1.7

{OpenGeodeWeb-Back-3.1.0 → OpenGeodeWeb-Back-3.2.0rc2}/src/opengeodeweb_back/geode_functions.py

@@ -1,16 +1,15 @@
 # Standard library imports
-import base64
 import os
 import time
 import threading
 import uuid
+import zipfile
 
 # Third party imports
 import flask
 import opengeode_geosciences as og_gs
 import opengeode as og
 import pkg_resources
-import werkzeug
 from jsonschema import validate
 from jsonschema.exceptions import ValidationError
 
@@ -311,7 +310,7 @@ def send_file(upload_folder, saved_files, new_file_name):
         mimetype = "application/octet-binary"
     else:
         mimetype = "application/zip"
-        new_file_name = strict_file_name + ".zip"
+        new_file_name = os.path.splitext(new_file_name)[0] + ".zip"
         with zipfile.ZipFile(os.path.join(upload_folder, new_file_name), "w") as zipObj:
             for saved_file_path in saved_files:
                 zipObj.write(

OpenGeodeWeb-Back-3.2.0rc2/src/opengeodeweb_back/routes/blueprint_routes.py

@@ -0,0 +1,178 @@
+# Standard library imports
+import json
+import os
+
+# Third party imports
+import flask
+import flask_cors
+from .. import geode_functions
+import werkzeug
+
+
+routes = flask.Blueprint("routes", __name__)
+flask_cors.CORS(routes)
+
+
+schemas = os.path.join(os.path.dirname(__file__), "schemas")
+
+with open(
+    os.path.join(schemas, "allowed_files.json"),
+    "r",
+) as file:
+    allowed_files_json = json.load(file)
+
+
+@routes.route(
+    allowed_files_json["route"],
+    methods=allowed_files_json["methods"],
+)
+def allowed_files():
+    geode_functions.validate_request(flask.request, allowed_files_json)
+    extensions = geode_functions.list_input_extensions(flask.request.json["key"])
+    return {"status": 200, "extensions": extensions}
+
+
+with open(
+    os.path.join(schemas, "upload_file.json"),
+    "r",
+) as file:
+    upload_file_json = json.load(file)
+
+
+@routes.route(
+    upload_file_json["route"],
+    methods=upload_file_json["methods"],
+)
+def upload_file():
+    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.mkdir(UPLOAD_FOLDER)
+    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)
+
+
+with open(
+    os.path.join(schemas, "allowed_objects.json"),
+    "r",
+) as file:
+    allowed_objects_json = json.load(file)
+
+
+@routes.route(
+    allowed_objects_json["route"],
+    methods=allowed_objects_json["methods"],
+)
+def allowed_objects():
+    if flask.request.method == "OPTIONS":
+        return flask.make_response({}, 200)
+
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    geode_functions.validate_request(flask.request, allowed_objects_json)
+    file_absolute_path = os.path.join(UPLOAD_FOLDER, flask.request.json["filename"])
+    allowed_objects = geode_functions.list_geode_objects(
+        file_absolute_path, flask.request.json["key"]
+    )
+    return flask.make_response({"allowed_objects": allowed_objects}, 200)
+
+
+with open(
+    os.path.join(schemas, "missing_files.json"),
+    "r",
+) as file:
+    missing_files_json = json.load(file)
+
+
+@routes.route(
+    missing_files_json["route"],
+    methods=missing_files_json["methods"],
+)
+def missing_files():
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    geode_functions.validate_request(flask.request, missing_files_json)
+
+    missing_files = geode_functions.missing_files(
+        flask.request.json["input_geode_object"],
+        os.path.join(UPLOAD_FOLDER, flask.request.json["filename"]),
+    )
+    has_missing_files = missing_files.has_missing_files()
+
+    mandatory_files = []
+    for mandatory_file in missing_files.mandatory_files:
+        mandatory_files.append(os.path.basename(mandatory_file))
+
+    additional_files = []
+    for additional_file in missing_files.additional_files:
+        additional_files.append(os.path.basename(additional_file))
+
+    return flask.make_response(
+        {
+            "has_missing_files": has_missing_files,
+            "mandatory_files": mandatory_files,
+            "additional_files": additional_files,
+        },
+        200,
+    )
+
+
+with open(
+    os.path.join(schemas, "geographic_coordinate_systems.json"),
+    "r",
+) as file:
+    geographic_coordinate_systems_json = json.load(file)
+
+
+@routes.route(
+    geographic_coordinate_systems_json["route"],
+    methods=geographic_coordinate_systems_json["methods"],
+)
+def crs_converter_geographic_coordinate_systems():
+    geode_functions.validate_request(flask.request, geographic_coordinate_systems_json)
+    infos = geode_functions.geographic_coordinate_systems(
+        flask.request.json["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)
+
+
+with open(
+    os.path.join(schemas, "geode_objects_and_output_extensions.json"),
+    "r",
+) as file:
+    geode_objects_and_output_extensions_json = json.load(file)
+
+
+@routes.route(
+    geode_objects_and_output_extensions_json["route"],
+    methods=geode_objects_and_output_extensions_json["methods"],
+)
+def geode_objects_and_output_extensions():
+    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
+    geode_functions.validate_request(
+        flask.request, geode_objects_and_output_extensions_json
+    )
+    data = geode_functions.load(
+        flask.request.json["input_geode_object"],
+        os.path.join(UPLOAD_FOLDER, flask.request.json["filename"]),
+    )
+    geode_objects_and_output_extensions = (
+        geode_functions.geode_objects_output_extensions(
+            flask.request.json["input_geode_object"], data
+        )
+    )
+    return flask.make_response(
+        {"geode_objects_and_output_extensions": geode_objects_and_output_extensions},
+        200,
+    )

{OpenGeodeWeb-Back-3.1.0 → OpenGeodeWeb-Back-3.2.0rc2}/tests/test_functions.py

@@ -83,7 +83,7 @@ def test_load():
                     viewable_file_path = geode_functions.save_viewable(
                         geode_object,
                         data,
-                        os.path.abspath(f"/output"),
+                        os.path.abspath(f"./output"),
                         uu_id,
                     )
                     os.remove(viewable_file_path)
@@ -109,7 +109,7 @@ def test_load():
                             saved_files = geode_functions.save(
                                 output_geode_object,
                                 data,
-                                os.path.abspath(f"/output"),
+                                os.path.abspath(f"./output"),
                                 filename,
                             )
                             assert type(saved_files) is list

OpenGeodeWeb-Back-3.2.0rc2/tests/test_routes.py

@@ -0,0 +1,131 @@
+import os
+import base64
+from werkzeug.datastructures import FileStorage
+
+
+def test_allowed_files(client):
+    route = f"/allowed_files"
+    response = client.post(route, json={"key": None})
+    assert response.status_code == 200
+    extensions = response.json["extensions"]
+    assert type(extensions) is list
+    for extension in extensions:
+        assert type(extension) is str
+
+
+def test_allowed_objects(client):
+    route = f"/allowed_objects"
+
+    def get_full_data():
+        return {
+            "filename": "corbi.og_brep",
+            "key": None,
+        }
+
+    # Normal test with filename 'corbi.og_brep'
+    response = client.post(route, json=get_full_data())
+    assert response.status_code == 200
+    allowed_objects = response.json["allowed_objects"]
+    assert type(allowed_objects) is dict
+    for allowed_object in allowed_objects:
+        assert type(allowed_object) is str
+
+    for key, value in get_full_data().items():
+        json = get_full_data()
+        json.pop(key)
+        response = client.post(route, json=json)
+        assert response.status_code == 400
+        error_description = response.json["description"]
+        assert error_description == f"Validation error: '{key}' is a required property"
+
+
+def test_upload_file(client):
+    response = client.put(
+        f"/upload_file",
+        data={"file": FileStorage(open("./tests/corbi.og_brep", "rb"))},
+    )
+
+    assert response.status_code == 201
+
+
+def test_missing_files(client):
+    route = f"/missing_files"
+
+    def get_full_data():
+        return {
+            "input_geode_object": "BRep",
+            "filename": "corbi.og_brep",
+        }
+
+    json = get_full_data()
+    response = client.post(
+        route,
+        json=json,
+    )
+
+    assert response.status_code == 200
+    has_missing_files = response.json["has_missing_files"]
+    mandatory_files = response.json["mandatory_files"]
+    additional_files = response.json["additional_files"]
+    assert type(has_missing_files) is bool
+    assert type(mandatory_files) is list
+    assert type(additional_files) is list
+
+    for key, value in get_full_data().items():
+        json = get_full_data()
+        json.pop(key)
+        response = client.post(route, json=json)
+        assert response.status_code == 400
+        error_description = response.json["description"]
+        assert error_description == f"Validation error: '{key}' is a required property"
+
+
+def test_geographic_coordinate_systems(client):
+    route = f"/geographic_coordinate_systems"
+
+    # Normal test with geode_object 'BRep'
+    response = client.post(route, json={"input_geode_object": "BRep"})
+    assert response.status_code == 200
+    crs_list = response.json["crs_list"]
+    assert type(crs_list) is list
+    for crs in crs_list:
+        assert type(crs) is dict
+
+    # Test without geode_object
+    response = client.post(route, json={})
+    assert response.status_code == 400
+    error_message = response.json["description"]
+    assert (
+        error_message == "Validation error: 'input_geode_object' is a required property"
+    )
+
+
+def test_geode_objects_and_output_extensions(client):
+    route = "/geode_objects_and_output_extensions"
+
+    def get_full_data():
+        return {
+            "input_geode_object": "BRep",
+            "filename": "corbi.og_brep",
+        }
+
+    response = client.post(route, json=get_full_data())
+
+    assert response.status_code == 200
+    geode_objects_and_output_extensions = response.json[
+        "geode_objects_and_output_extensions"
+    ]
+    assert type(geode_objects_and_output_extensions) is dict
+    for geode_object, values in geode_objects_and_output_extensions.items():
+        assert type(values) is dict
+        for output_extension, value in values.items():
+            assert type(value) is dict
+            assert type(value["is_saveable"]) is bool
+
+    # Test without input_geode_object
+    response = client.post(route, json={})
+    assert response.status_code == 400
+    error_message = response.json["description"]
+    assert (
+        error_message == "Validation error: 'input_geode_object' is a required property"
+    )