multimodalsim-viewer 0.1.2.0__py3-none-any.whl → 0.1.4.0__py3-none-any.whl

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/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/server/http_routes.py

@@ -3,130 +3,154 @@ 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
 
-http_routes = Blueprint("http_routes", __name__)
 
-# MARK: Zip Management
+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))
 
-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
+        return zip_path
 
+    def save_and_extract_zip(path: str, files):
+        try:
+            if "file" not in files:
+                raise InvalidFilesRequestError("No file part")
 
-def zip_folder(folder_path, zip_name):
-    if not os.path.isdir(folder_path):
-        return None
+            file = files["file"]
+            if file.filename == "":
+                raise InvalidFilesRequestError("No selected file")
 
-    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))
+            # Create temporary zip file
+            zip_path = os.path.join(tempfile.gettempdir(), file.filename)
+            file.save(zip_path)
 
-    return 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):
-    parent_dir = os.path.dirname(folder_path)
-    base_folder_name = os.path.basename(folder_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)
+        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)
+        os.makedirs(actual_folder_path, exist_ok=True)
 
-    if "file" not in request.files:
-        return jsonify({"error": "No file part"}), 400
+        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
 
-    file = request.files["file"]
-    if file.filename == "":
-        return jsonify({"error": "No selected 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}')"
 
-    zip_path = os.path.join(tempfile.gettempdir(), file.filename)
-    file.save(zip_path)
+        if on_success:
+            on_success()
 
-    try:
-        with zipfile.ZipFile(zip_path, "r") as zip_ref:
-            zip_ref.extractall(actual_folder_path)
-            logging.info("Extracted files: %s", zip_ref.namelist())
+        return (
+            jsonify({"message": response_message, "folderName": unique_folder_name}),
+            201,
+        )
 
-        os.remove(zip_path)
-    except zipfile.BadZipFile:
-        return jsonify({"error": "Invalid ZIP file"}), 400
+    # 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)
 
-    response_message = f"Folder '{unique_folder_name}' uploaded successfully"
-    if unique_folder_name != base_folder_name:
-        response_message += f" (renamed from '{base_folder_name}')"
+        zip_path = zip_folder(folder_path, folder_name)
+        if not zip_path:
+            return jsonify({"error": "Folder not found"}), 404
 
-    return (
-        jsonify({"message": response_message, "actual_folder_name": unique_folder_name}),
-        201,
-    )
+        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)
 
-# MARK: Input Data Routes
-@http_routes.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)
+    @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
 
-    zip_path = zip_folder(folder_path, folder_name)
-    if not zip_path:
-        return jsonify({"error": "Folder not found"}), 404
+        shutil.rmtree(folder_path)
+        return jsonify({"message": f"Folder '{folder_name}' deleted successfully"})
 
-    return send_file(zip_path, as_attachment=True)
+    # 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
 
-@http_routes.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)
+        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)
 
-@http_routes.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
+        def on_success():
+            simulation_manager.emit_simulation(folder_name)
 
-    shutil.rmtree(folder_path)
-    return jsonify({"message": f"Folder '{folder_name}' deleted successfully"})
+        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)
 
-# MARK: Saved Simulations Routes
-@http_routes.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)
+        if not os.path.isdir(folder_path):
+            return jsonify({"error": "Folder not found"}), 404
 
-    zip_path = zip_folder(folder_path, folder_name)
-    if not zip_path:
-        return jsonify({"error": "Folder not found"}), 404
+        shutil.rmtree(folder_path)
 
-    return send_file(zip_path, as_attachment=True)
+        simulation_manager.on_simulation_delete(folder_name)
 
+        return jsonify({"message": f"Folder '{folder_name}' deleted successfully"})
 
-@http_routes.route("/api/simulation/<folder_name>", methods=["POST"])
-def import_saved_simulation(folder_name):
-    folder_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(folder_name)
-    return handle_zip_upload(folder_path)
-
-
-@http_routes.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)
-    return jsonify({"message": f"Folder '{folder_name}' deleted successfully"})
+    return blueprint

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/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(