multimodalsim-viewer 0.1.2.0__tar.gz → 0.1.4.0__tar.gz

{multimodalsim_viewer-0.1.2.0 → multimodalsim_viewer-0.1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multimodalsim_viewer
-Version: 0.1.2.0
+Version: 0.1.4.0
 Summary: Multimodal simulation viewer
 Keywords: flask angular ui multimodal server
 Requires-Python: >=3.10

{multimodalsim_viewer-0.1.2.0 → multimodalsim_viewer-0.1.4.0}/multimodalsim_viewer/common/utils.py

@@ -9,7 +9,6 @@ from json import dumps
 from dotenv import dotenv_values
 from filelock import FileLock
 from flask import request
-from flask_socketio import emit
 
 environment = {}
 
@@ -147,19 +146,11 @@ def build_simulation_id(name: str) -> tuple[str, str]:
     return simulation_id, start_time
 
 
-def log(message: str, auth_type: str, level=logging.INFO, should_emit=True) -> None:
+def log(message: str, auth_type: str, level=logging.INFO) -> None:
     if auth_type == "server":
         logging.log(level, "[%s] %s", auth_type, message)
-        if should_emit:
-            emit("log", f"{level} [{auth_type}] {message}", to=CLIENT_ROOM)
     else:
         logging.log(level, "[%s] %s %s", auth_type, get_session_id(), message)
-        if should_emit:
-            emit(
-                "log",
-                f"{level} [{auth_type}] {get_session_id()} {message}",
-                to=CLIENT_ROOM,
-            )
 
 
 def verify_simulation_name(name: str | None) -> str | None:

{multimodalsim_viewer-0.1.2.0 → multimodalsim_viewer-0.1.4.0}/multimodalsim_viewer/server/data_manager.py

@@ -499,34 +499,6 @@ class SimulationVisualizationDataManager:  # pylint: disable=too-many-public-met
 
         return polylines, version
 
-    @staticmethod
-    def get_all_simulation_states(simulation_id: str) -> tuple[list[str], dict[list[str]]]:
-        states = []
-        updates = {}
-
-        sorted_states = SimulationVisualizationDataManager.get_sorted_states(simulation_id)
-
-        for update_index, timestamp in sorted_states:
-            file_path = SimulationVisualizationDataManager.get_saved_simulation_state_file_path(
-                simulation_id, update_index, timestamp
-            )
-
-            lock = FileLock(f"{file_path}.lock")
-
-            with lock:
-                with open(file_path, "r", encoding="utf-8") as file:
-                    state_data = file.readline()
-                    states.append(state_data)
-
-                    updates_data = file.readlines()
-                    current_state_updates = []
-                    for update_data in updates_data:
-                        current_state_updates.append(update_data)
-
-                    updates[update_index] = current_state_updates
-
-        return states, updates
-
     # MARK: +- Simulation Data
     @staticmethod
     def get_output_data_directory_path() -> str:

multimodalsim_viewer-0.1.4.0/multimodalsim_viewer/server/http_routes.py

@@ -0,0 +1,156 @@
+import logging
+import os
+import shutil
+import tempfile
+import zipfile
+from typing import Callable
+
+from flask import Blueprint, jsonify, request, send_file
+
+from multimodalsim_viewer.server.data_manager import SimulationVisualizationDataManager
+from multimodalsim_viewer.server.simulation_manager import SimulationManager
+
+
+class InvalidFilesRequestError(Exception):
+    def __init__(self, error_message: str) -> None:
+        self.error_message = error_message
+
+
+def http_routes(simulation_manager: SimulationManager):  # pylint: disable=too-many-statements
+    blueprint = Blueprint("http_routes", __name__)
+
+    # MARK: Helpers
+    def get_unique_folder_name(base_path, folder_name):
+        counter = 1
+        original_name = folder_name
+        while os.path.exists(os.path.join(base_path, folder_name)):
+            folder_name = f"{original_name}_({counter})"
+            counter += 1
+        return folder_name
+
+    def zip_folder(folder_path, zip_name):
+        if not os.path.isdir(folder_path):
+            return None
+
+        zip_path = os.path.join(tempfile.gettempdir(), f"{zip_name}.zip")
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
+            for root, _, files in os.walk(folder_path):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    zip_file.write(file_path, os.path.relpath(file_path, folder_path))
+
+        return zip_path
+
+    def save_and_extract_zip(path: str, files):
+        try:
+            if "file" not in files:
+                raise InvalidFilesRequestError("No file part")
+
+            file = files["file"]
+            if file.filename == "":
+                raise InvalidFilesRequestError("No selected file")
+
+            # Create temporary zip file
+            zip_path = os.path.join(tempfile.gettempdir(), file.filename)
+            file.save(zip_path)
+
+            # Extract files
+            with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                zip_ref.extractall(path)
+                logging.info("Extracted files: %s", zip_ref.namelist())
+
+        # Let the exception propagate
+        finally:
+            # Remove temporary zip file
+            if os.path.exists(zip_path):
+                os.remove(zip_path)
+
+    def handle_zip_upload(folder_path, on_success: Callable | None = None):
+        parent_dir = os.path.dirname(folder_path)
+        base_folder_name = os.path.basename(folder_path)
+
+        unique_folder_name = get_unique_folder_name(parent_dir, base_folder_name)
+        actual_folder_path = os.path.join(parent_dir, unique_folder_name)
+
+        os.makedirs(actual_folder_path, exist_ok=True)
+
+        try:
+            save_and_extract_zip(actual_folder_path, request.files)
+        except InvalidFilesRequestError as error:
+            return jsonify({"error": error.error_message}), 400
+        except zipfile.BadZipFile:
+            return jsonify({"error": "Invalid ZIP file"}), 400
+
+        response_message = f"Folder '{unique_folder_name}' uploaded successfully"
+        if unique_folder_name != base_folder_name:
+            response_message += f" (renamed from '{base_folder_name}')"
+
+        if on_success:
+            on_success()
+
+        return (
+            jsonify({"message": response_message, "folderName": unique_folder_name}),
+            201,
+        )
+
+    # MARK: Instances
+    @blueprint.route("/api/input_data/<folder_name>", methods=["GET"])
+    def export_input_data(folder_name):
+        folder_path = SimulationVisualizationDataManager.get_input_data_directory_path(folder_name)
+        logging.info("Requested folder: %s", folder_path)
+
+        zip_path = zip_folder(folder_path, folder_name)
+        if not zip_path:
+            return jsonify({"error": "Folder not found"}), 404
+
+        return send_file(zip_path, as_attachment=True)
+
+    @blueprint.route("/api/input_data/<folder_name>", methods=["POST"])
+    def import_input_data(folder_name):
+        folder_path = SimulationVisualizationDataManager.get_input_data_directory_path(folder_name)
+        return handle_zip_upload(folder_path)
+
+    @blueprint.route("/api/input_data/<folder_name>", methods=["DELETE"])
+    def delete_input_data(folder_name):
+        folder_path = SimulationVisualizationDataManager.get_input_data_directory_path(folder_name)
+        if not os.path.isdir(folder_path):
+            return jsonify({"error": "Folder not found"}), 404
+
+        shutil.rmtree(folder_path)
+        return jsonify({"message": f"Folder '{folder_name}' deleted successfully"})
+
+    # MARK: Visualizations
+    @blueprint.route("/api/simulation/<folder_name>", methods=["GET"])
+    def export_saved_simulation(folder_name):
+        folder_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(folder_name)
+        logging.info("Requested folder: %s", folder_path)
+
+        zip_path = zip_folder(folder_path, folder_name)
+        if not zip_path:
+            return jsonify({"error": "Folder not found"}), 404
+
+        return send_file(zip_path, as_attachment=True)
+
+    @blueprint.route("/api/simulation/<folder_name>", methods=["POST"])
+    def import_saved_simulation(folder_name):
+        folder_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(folder_name)
+
+        def on_success():
+            simulation_manager.emit_simulation(folder_name)
+
+        return handle_zip_upload(folder_path, on_success)
+
+    @blueprint.route("/api/simulation/<folder_name>", methods=["DELETE"])
+    def delete_saved_simulation(folder_name):
+        folder_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(folder_name)
+
+        if not os.path.isdir(folder_path):
+            return jsonify({"error": "Folder not found"}), 404
+
+        shutil.rmtree(folder_path)
+
+        simulation_manager.on_simulation_delete(folder_name)
+
+        return jsonify({"message": f"Folder '{folder_name}' deleted successfully"})
+
+    return blueprint

{multimodalsim_viewer-0.1.2.0 → multimodalsim_viewer-0.1.4.0}/multimodalsim_viewer/server/scripts.py

@@ -7,11 +7,7 @@ from requests.exceptions import ConnectionError as RequestsConnectionError
 from socketio import Client
 from socketio.exceptions import ConnectionError as SocketIOConnectionError
 
-from multimodalsim_viewer.common.utils import (
-    CLIENT_PORT,
-    HOST,
-    SERVER_PORT,
-)
+from multimodalsim_viewer.common.utils import CLIENT_PORT, HOST, SERVER_PORT
 from multimodalsim_viewer.server.server import configure_server
 from multimodalsim_viewer.server.simulation import (
     configure_simulation_parser,

{multimodalsim_viewer-0.1.2.0 → multimodalsim_viewer-0.1.4.0}/multimodalsim_viewer/server/server.py

@@ -14,17 +14,17 @@ from multimodalsim_viewer.server.simulation_manager import SimulationManager
 def configure_server() -> tuple[Flask, SocketIO]:  # pylint: disable=too-many-statements, too-many-locals
     app = Flask(__name__)
 
+    socketio = SocketIO(app, cors_allowed_origins="*")
+
+    simulation_manager = SimulationManager(socketio)
+
     # Register HTTP routes
     CORS(app)
-    app.register_blueprint(http_routes)
-
-    socketio = SocketIO(app, cors_allowed_origins="*")
+    app.register_blueprint(http_routes(simulation_manager))
 
     # key = session id, value = auth type
     sockets_types_by_session_id = {}
 
-    simulation_manager = SimulationManager()
-
     # MARK: Main events
     @socketio.on("connect")
     def on_connect(auth):
@@ -69,9 +69,9 @@ def configure_server() -> tuple[Flask, SocketIO]:  # pylint: disable=too-many-st
         simulation_manager.resume_simulation(simulation_id)
 
     @socketio.on("get-simulations")
-    def on_client_get_simulations():
-        log("getting simulations", "client")
-        simulation_manager.emit_simulations()
+    def on_client_get_simulations(loaded_simulations_ids: list[str]):
+        log(f"getting simulations with already loaded ids {loaded_simulations_ids}", "client")
+        simulation_manager.emit_simulations(loaded_simulations_ids)
 
     @socketio.on("get-available-data")
     def on_client_get_data():
@@ -136,10 +136,6 @@ def configure_server() -> tuple[Flask, SocketIO]:  # pylint: disable=too-many-st
         log(f"simulation {simulation_id} resumed", "simulation")
         simulation_manager.on_simulation_resume(simulation_id)
 
-    @socketio.on("log")
-    def on_simulation_log(simulation_id, message):
-        log(f"simulation  {simulation_id}: {message}", "simulation", logging.DEBUG)
-
     @socketio.on("simulation-update-time")
     def on_simulation_update_time(simulation_id, timestamp):
         log(