OpenGeodeWeb-Back 6.9.1__tar.gz → 6.9.2__tar.gz

{opengeodeweb_back-6.9.1/src/OpenGeodeWeb_Back.egg-info → opengeodeweb_back-6.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.9.1
+Version: 6.9.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

{opengeodeweb_back-6.9.1 → opengeodeweb_back-6.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "6.9.1"
+version = "6.9.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-6.9.1 → opengeodeweb_back-6.9.2/src/OpenGeodeWeb_Back.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.9.1
+Version: 6.9.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

{opengeodeweb_back-6.9.1 → opengeodeweb_back-6.9.2}/src/opengeodeweb_back/app.py

@@ -18,15 +18,6 @@ from opengeodeweb_microservice.database import connection
 def create_app(name: str) -> flask.Flask:
     app = flask.Flask(name)
 
-    """ Config variables """
-    FLASK_DEBUG = (
-        True if os.environ.get("FLASK_DEBUG", default=None) == "True" else False
-    )
-    if FLASK_DEBUG == False:
-        app.config.from_object(app_config.ProdConfig)
-    else:
-        app.config.from_object(app_config.DevConfig)
-
     @app.before_request
     def before_request() -> flask.Response | None:
         if flask.request.method == "OPTIONS":
@@ -96,78 +87,110 @@ def register_ogw_back_blueprints(app: flask.Flask) -> None:
 
 
 def run_server(app: Flask) -> None:
+    pre_parser = argparse.ArgumentParser(add_help=False)
+    pre_parser.add_argument("-d", "--debug", action="store_true", default=False)
+    pre_parser.add_argument("-pfp", "--project_folder_path", type=str)
+    pre_args, _ = pre_parser.parse_known_args()
+
+    if pre_args.project_folder_path is None:
+        raise ValueError("project_folder_path must be provided")
+    project_folder_path = os.path.abspath(pre_args.project_folder_path)
+
+    if pre_args.debug:
+        app.config.from_object(app_config.DevConfig(project_folder_path))
+    else:
+        app.config.from_object(app_config.ProdConfig(project_folder_path))
+
     parser = argparse.ArgumentParser(
         prog="OpenGeodeWeb-Back", description="Backend server for OpenGeodeWeb"
     )
     parser.add_argument(
-        "--host",
-        type=str,
-        default=app.config.get("DEFAULT_HOST"),
-        help="Host to run on",
+        "--host", default=app.config.get("HOST"), type=str, help="Host to run on"
     )
     parser.add_argument(
         "-p",
         "--port",
-        type=int,
-        default=app.config.get("DEFAULT_PORT"),
+        default=app.config.get("PORT"),
+        type=str,
         help="Port to listen on",
     )
     parser.add_argument(
         "-d",
         "--debug",
-        default=app.config.get("FLASK_DEBUG"),
-        help="Whether to run in debug mode",
+        default=pre_args.debug,
         action="store_true",
+        help="Whether to run in debug mode",
+    )
+    parser.add_argument(
+        "-pfp",
+        "--project_folder_path",
+        default=project_folder_path,
+        type=str,
+        help="Path to the folder where the project is stored",
     )
     parser.add_argument(
         "-dfp",
         "--data_folder_path",
+        default=app.config.get("DATA_FOLDER_PATH"),
         type=str,
-        default=app.config.get("DEFAULT_DATA_FOLDER_PATH"),
-        help="Path to the folder where data is stored",
+        help="Path to the folder where the data is stored",
     )
     parser.add_argument(
         "-ufp",
         "--upload_folder_path",
+        default=app.config.get("UPLOAD_FOLDER_PATH"),
         type=str,
-        default=app.config.get("UPLOAD_FOLDER"),
         help="Path to the folder where uploads are stored",
     )
     parser.add_argument(
         "-origins",
         "--allowed_origins",
-        nargs="+",
         default=app.config.get("ORIGINS"),
+        nargs="+",
         help="Origins that are allowed to connect to the server",
     )
     parser.add_argument(
         "-t",
         "--timeout",
         default=app.config.get("MINUTES_BEFORE_TIMEOUT"),
+        type=int,
         help="Number of minutes before the server times out",
     )
-    args, _ = parser.parse_known_args()
-    app.config.update(DATA_FOLDER_PATH=args.data_folder_path)
+    args = parser.parse_args()
+
+    args.project_folder_path = os.path.abspath(args.project_folder_path)
+
+    print(f"{args=}", flush=True)
+
     app.config.update(
-        EXTENSIONS_FOLDER_PATH=os.path.join(str(args.data_folder_path), "extensions")
+        HOST=args.host,
+        PORT=args.port,
+        FLASK_DEBUG=args.debug,
+        PROJECT_FOLDER_PATH=args.project_folder_path,
+        DATA_FOLDER_PATH=args.data_folder_path,
+        UPLOAD_FOLDER_PATH=args.upload_folder_path,
+        ALLOWED_ORIGINS=args.allowed_origins,
+        MINUTES_BEFORE_TIMEOUT=args.timeout,
     )
-    app.config.update(UPLOAD_FOLDER=args.upload_folder_path)
-    app.config.update(MINUTES_BEFORE_TIMEOUT=args.timeout)
-    flask_cors.CORS(app, origins=args.allowed_origins)
-    print(f"{args=}", flush=True)
 
-    db_filename: str = app.config.get("DATABASE_FILENAME") or "project.db"
-    db_path = os.path.join(str(args.data_folder_path), db_filename)
+    db_filename = app.config.get("DATABASE_FILENAME")
+    if not isinstance(db_filename, str):
+        raise TypeError(
+            f"DATABASE_FILENAME config must be a string, got {db_filename!r}"
+        )
+    db_path = os.path.join(str(app.config.get("DATA_FOLDER_PATH")), db_filename)
     os.makedirs(os.path.dirname(db_path), exist_ok=True)
     app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{db_path}"
     app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
 
     connection.init_database(db_path)
     print(f"Database initialized at: {db_path}", flush=True)
+
+    flask_cors.CORS(app, origins=args.allowed_origins)
     app.run(
-        debug=args.debug,
-        host=args.host,
-        port=args.port,
+        debug=app.config.get("FLASK_DEBUG"),
+        host=app.config.get("HOST"),
+        port=app.config.get("PORT"),
         ssl_context=app.config.get("SSL"),
     )
 

{opengeodeweb_back-6.9.1 → opengeodeweb_back-6.9.2}/src/opengeodeweb_back/app_config.py

@@ -5,26 +5,31 @@ import time
 # Third party imports
 # Local application imports
 
+base_dir = os.path.dirname(os.path.abspath(__file__))
+
 
 class Config(object):
     FLASK_DEBUG = os.environ.get("FLASK_DEBUG", default=False)
-    DEFAULT_HOST = "localhost"
-    DEFAULT_PORT = "5000"
+    HOST = "localhost"
+    PORT = "5000"
     CORS_HEADERS = "Content-Type"
-    UPLOAD_FOLDER = "./uploads"
     REQUEST_COUNTER = 0
     LAST_REQUEST_TIME = time.time()
     LAST_PING_TIME = time.time()
     DATABASE_FILENAME = "project.db"
 
+    def __init__(self, project_folder_path: str):
+        self.PROJECT_FOLDER_PATH = project_folder_path
+        self.DATA_FOLDER_PATH = os.path.join(project_folder_path, "data")
+        self.EXTENSIONS_FOLDER_PATH = os.path.join(project_folder_path, "extensions")
+        self.UPLOAD_FOLDER_PATH = os.path.join(project_folder_path, "uploads")
+
 
 class ProdConfig(Config):
     SSL = None
     ORIGINS = ""
     MINUTES_BEFORE_TIMEOUT = "1"
     SECONDS_BETWEEN_SHUTDOWNS = "10"
-    DATA_FOLDER_PATH = "/data"
-    EXTENSIONS_FOLDER_PATH = os.path.join(DATA_FOLDER_PATH, "extensions")
 
 
 class DevConfig(Config):
@@ -32,6 +37,3 @@ class DevConfig(Config):
     ORIGINS = "*"
     MINUTES_BEFORE_TIMEOUT = "1"
     SECONDS_BETWEEN_SHUTDOWNS = "10"
-    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-    DATA_FOLDER_PATH = os.path.join(BASE_DIR, "data")
-    EXTENSIONS_FOLDER_PATH = os.path.join(DATA_FOLDER_PATH, "extensions")

{opengeodeweb_back-6.9.1 → opengeodeweb_back-6.9.2}/src/opengeodeweb_back/geode_functions.py

@@ -46,7 +46,7 @@ def get_data_info(data_id: str) -> Data:
 
 
 def upload_file_path(filename: str) -> str:
-    upload_folder = flask.current_app.config["UPLOAD_FOLDER"]
+    upload_folder = flask.current_app.config["UPLOAD_FOLDER_PATH"]
     secure_filename = werkzeug.utils.secure_filename(filename)
     return os.path.abspath(os.path.join(upload_folder, secure_filename))
 

{opengeodeweb_back-6.9.1 → opengeodeweb_back-6.9.2}/src/opengeodeweb_back/routes/blueprint_routes.py

@@ -66,20 +66,22 @@ def allowed_files() -> flask.Response:
     methods=schemas_dict["upload_file"]["methods"],
 )
 def upload_file() -> flask.Response:
-    UPLOAD_FOLDER = flask.current_app.config["UPLOAD_FOLDER"]
-    print(f"{UPLOAD_FOLDER=}", flush=True)
-    if not os.path.exists(UPLOAD_FOLDER):
-        os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+    UPLOAD_FOLDER_PATH = flask.current_app.config["UPLOAD_FOLDER_PATH"]
+    print(f"{UPLOAD_FOLDER_PATH=}", flush=True)
+    if not os.path.exists(UPLOAD_FOLDER_PATH):
+        os.makedirs(UPLOAD_FOLDER_PATH, exist_ok=True)
 
     file = flask.request.files["file"]
     if file.filename is None:
         flask.abort(400, "Filename is required")
     filename = werkzeug.utils.secure_filename(os.path.basename(file.filename))
     print(f"{filename=}", flush=True)
-    file_path = os.path.join(UPLOAD_FOLDER, filename)
+    file_path = os.path.join(UPLOAD_FOLDER_PATH, filename)
     file.save(file_path)
     if filename.lower().endswith(".csv.json"):
-        shutil.copyfile(file_path, os.path.join(UPLOAD_FOLDER, filename[:-9] + ".json"))
+        shutil.copyfile(
+            file_path, os.path.join(UPLOAD_FOLDER_PATH, filename[:-9] + ".json")
+        )
     return flask.make_response({"message": "File uploaded"}, 201)
 
 
@@ -547,10 +549,11 @@ def export_project() -> flask.Response:
         for data_id, native_file in rows:
             base_dir = os.path.join(project_folder, data_id)
             if os.path.isdir(base_dir):
-                for f_name in os.listdir(base_dir):
-                    file_path = os.path.join(base_dir, f_name)
-                    if os.path.isfile(file_path):
-                        zip_file.write(file_path, os.path.join(data_id, f_name))
+                for root, directories, files in os.walk(base_dir):
+                    for file_name in files:
+                        file_path = os.path.join(root, file_name)
+                        relative_path = os.path.relpath(file_path, base_dir)
+                        zip_file.write(file_path, os.path.join(data_id, relative_path))
 
         zip_file.writestr("snapshot.json", flask.json.dumps(params.snapshot))
 
@@ -584,8 +587,13 @@ def import_project() -> flask.Response:
 
     try:
         if os.path.exists(data_folder_path):
-            shutil.rmtree(data_folder_path)
-        os.makedirs(data_folder_path, exist_ok=True)
+            for item in os.scandir(data_folder_path):
+                if item.is_dir(follow_symlinks=False):
+                    shutil.rmtree(item.path)
+                else:
+                    os.remove(item.path)
+        else:
+            os.makedirs(data_folder_path, exist_ok=True)
     except PermissionError:
         flask.abort(423, "Project files are locked; cannot overwrite")
 
@@ -622,7 +630,13 @@ def import_project() -> flask.Response:
                 viewable_name = data.viewable_file
                 if viewable_name:
                     vpath = geode_functions.data_file_path(data.id, viewable_name)
-                    if os.path.isfile(vpath):
+                    viewable_dir = os.path.join(data_path, "viewable")
+                    has_components = os.path.isdir(viewable_dir) and bool(
+                        os.listdir(viewable_dir)
+                    )
+                    if os.path.isfile(vpath) and (
+                        data.viewer_object != "model" or has_components
+                    ):
                         continue
 
                 native_file = str(data.native_file or "")

{opengeodeweb_back-6.9.1 → opengeodeweb_back-6.9.2}/tests/test_utils_functions.py

@@ -232,7 +232,7 @@ def test_generate_native_viewable_and_light_viewable_from_file_with_multi_dots(
 def test_send_file_multiple_returns_zip(client: FlaskClient, tmp_path: Path) -> None:
     app = client.application
     with app.app_context():
-        app.config["UPLOAD_FOLDER"] = str(tmp_path)
+        app.config["UPLOAD_FOLDER_PATH"] = str(tmp_path)
         file_paths = []
         for i, content in [(1, b"hello 1"), (2, b"hello 2")]:
             file_path = tmp_path / f"tmp_send_file_{i}.txt"
@@ -240,13 +240,13 @@ def test_send_file_multiple_returns_zip(client: FlaskClient, tmp_path: Path) ->
             file_paths.append(str(file_path))
         with app.test_request_context():
             response = utils_functions.send_file(
-                app.config["UPLOAD_FOLDER"], file_paths, "bundle"
+                app.config["UPLOAD_FOLDER_PATH"], file_paths, "bundle"
             )
             assert response.status_code == 200
             assert response.mimetype == "application/zip"
             new_file_name = response.headers.get("new-file-name")
             assert new_file_name == "bundle.zip"
-            zip_path = os.path.join(app.config["UPLOAD_FOLDER"], new_file_name)
+            zip_path = os.path.join(app.config["UPLOAD_FOLDER_PATH"], new_file_name)
             with zipfile.ZipFile(zip_path, "r") as zip_file:
                 zip_entries = zip_file.namelist()
                 assert "tmp_send_file_1.txt" in zip_entries
@@ -259,18 +259,20 @@ def test_send_file_single_returns_octet_binary(
 ) -> None:
     app = client.application
     with app.app_context():
-        app.config["UPLOAD_FOLDER"] = str(tmp_path)
+        app.config["UPLOAD_FOLDER_PATH"] = str(tmp_path)
         file_path = tmp_path / "tmp_send_file_1.txt"
         file_path.write_bytes(b"hello 1")
         with app.test_request_context():
             response = utils_functions.send_file(
-                app.config["UPLOAD_FOLDER"], [str(file_path)], "tmp_send_file_1.txt"
+                app.config["UPLOAD_FOLDER_PATH"],
+                [str(file_path)],
+                "tmp_send_file_1.txt",
             )
             assert response.status_code == 200
             assert response.mimetype == "application/octet-binary"
             new_file_name = response.headers.get("new-file-name")
             assert new_file_name == "tmp_send_file_1.txt"
-            zip_path = os.path.join(app.config["UPLOAD_FOLDER"], new_file_name)
+            zip_path = os.path.join(app.config["UPLOAD_FOLDER_PATH"], new_file_name)
             with open(zip_path, "rb") as f:
                 file_bytes = f.read()
             assert file_bytes == b"hello 1"