multimodalsim-viewer 0.0.1__tar.gz

multimodalsim_viewer-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: multimodalsim_viewer
+Version: 0.0.1
+Summary: Multimodal simulation viewer
+License: MIT
+Keywords: flask angular ui multimodal server
+Requires-Python: ==3.11.*
+Requires-Dist: flask==3.1.1
+Requires-Dist: flask-socketio==5.5.1
+Requires-Dist: eventlet==0.40.0
+Requires-Dist: websocket-client==1.8.0
+Requires-Dist: filelock==3.18.0
+Requires-Dist: flask_cors==6.0.0
+Requires-Dist: questionary==2.1.0
+Requires-Dist: python-dotenv==1.1.0
+Requires-Dist: multimodalsim==0.0.1
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

multimodalsim_viewer-0.0.1/multimodalsim_viewer/server/http_routes.py

@@ -0,0 +1,125 @@
+import os
+import shutil
+import zipfile
+from flask import Blueprint, request, jsonify, send_file
+import logging
+import tempfile
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+data_dir = BASE_DIR / "data"
+saved_simulations_dir = Path(__file__).parent / "saved_simulations"
+
+http_routes = Blueprint("http_routes", __name__)
+
+# MARK: Zip Management
+
+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 zipf:
+        for root, _, files in os.walk(folder_path):
+            for file in files:
+                file_path = os.path.join(root, file)
+                zipf.write(file_path, os.path.relpath(file_path, folder_path))
+    
+    return zip_path
+
+def handle_zip_upload(folder_path):
+    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)
+
+    if 'file' not in request.files:
+        return jsonify({"error": "No file part"}), 400
+
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({"error": "No selected file"}), 400
+
+    zip_path = os.path.join(tempfile.gettempdir(), file.filename)
+    file.save(zip_path)
+
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(actual_folder_path)
+            logging.info(f"Extracted files: {zip_ref.namelist()}")
+        
+        os.remove(zip_path)
+    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}')"
+    
+    return jsonify({
+        "message": response_message,
+        "actual_folder_name": unique_folder_name
+    }), 201
+
+# MARK: Input Data Routes
+@http_routes.route("/api/input_data/<folder_name>", methods=["GET"])
+def export_input_data(folder_name):
+    folder_path = os.path.join(data_dir, folder_name)
+    logging.info(f"Requested folder: {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)
+
+@http_routes.route("/api/input_data/<folder_name>", methods=["POST"])
+def import_input_data(folder_name):
+    folder_path = os.path.join(data_dir, folder_name)
+    return handle_zip_upload(folder_path)
+
+@http_routes.route("/api/input_data/<folder_name>", methods=["DELETE"])
+def delete_input_data(folder_name):
+    folder_path = os.path.join(data_dir, 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: Saved Simulations Routes
+@http_routes.route("/api/simulation/<folder_name>", methods=["GET"])
+def export_saved_simulation(folder_name):
+    folder_path = os.path.join(saved_simulations_dir, folder_name)
+    logging.info(f"Requested folder: {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)
+
+@http_routes.route("/api/simulation/<folder_name>", methods=["POST"])
+def import_saved_simulation(folder_name):
+    folder_path = os.path.join(saved_simulations_dir, 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 = os.path.join(saved_simulations_dir, 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"})

multimodalsim_viewer-0.0.1/multimodalsim_viewer/server/log_manager.py

@@ -0,0 +1,15 @@
+import os
+
+
+def register_log(simulation_id, message):
+    current_directory = os.path.dirname(os.path.abspath(__file__))
+    log_directory_name = "saved_logs"
+    log_directory_path = f"{current_directory}/{log_directory_name}"
+    file_name = f"{simulation_id}.txt"
+    file_path = f"{log_directory_path}/{file_name}"
+
+    if not os.path.exists(log_directory_path):
+        os.makedirs(log_directory_path)
+
+    with open(file_path, "a") as file:
+        file.write(message + "\n")

multimodalsim_viewer-0.0.1/multimodalsim_viewer/server/scripts.py

@@ -0,0 +1,72 @@
+import threading
+import time
+
+import requests
+from multimodalsim_viewer.server.server import run_server
+from multimodalsim_viewer.server.server_utils import CLIENT_PORT, HOST, PORT
+from multimodalsim_viewer.ui.cli import main as run_ui
+from socketio import Client, exceptions
+
+
+def run_server_and_ui():
+    # Start the server in a separate thread
+    server_thread = threading.Thread(target=run_server)
+    server_thread.start()
+
+    # Start the UI in a separate thread
+    ui_thread = threading.Thread(target=run_ui)
+    ui_thread.start()
+
+    # Wait for both threads to finish
+    server_thread.join()
+    ui_thread.join()
+
+
+def terminate_server():
+    print("Terminating server...")
+
+    sio = Client()
+
+    try:
+        sio.connect(f"http://{HOST}:{PORT}", auth={"type": "script"})
+
+        sio.emit("terminate")
+
+        time.sleep(1)
+
+        sio.disconnect()
+
+        print("Server terminated")
+
+    except exceptions.ConnectionError as e:
+        print(f"Failed to connect to server (server not running?): {e}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+def terminate_ui():
+    print("Terminating UI...")
+
+    try:
+        response = requests.get(f"http://{HOST}:{CLIENT_PORT}/terminate")
+
+        if response.status_code == 200:
+            print("UI terminated")
+        else:
+            print(f"Failed to terminate UI: {response.status_code}")
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error: {e}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+def terminate_all():
+    print("Terminating all...")
+
+    terminate_server()
+    terminate_ui()
+
+    print("All terminated")

multimodalsim_viewer-0.0.1/multimodalsim_viewer/server/server.py

@@ -0,0 +1,210 @@
+import logging
+import time
+
+from flask import Flask
+from flask_cors import CORS
+from flask_socketio import SocketIO, emit, join_room, leave_room
+from multimodalsim_viewer.server.http_routes import http_routes
+from multimodalsim_viewer.server.server_utils import (
+    CLIENT_ROOM,
+    HOST,
+    PORT,
+    get_available_data,
+    get_session_id,
+    log,
+)
+from multimodalsim_viewer.server.simulation_manager import SimulationManager
+
+
+def run_server():
+    app = Flask(__name__)
+
+    # Register HTTP routes
+    CORS(app)
+    app.register_blueprint(http_routes)
+
+    socketio = SocketIO(app, cors_allowed_origins="*")
+
+    # key = session id, value = auth type
+    sockets_types_by_session_id = dict()
+
+    simulation_manager = SimulationManager()
+
+    # MARK: Main events
+    @socketio.on("connect")
+    def on_connect(auth):
+        auth_type = auth["type"]
+        log("connected", auth_type)
+        sockets_types_by_session_id[get_session_id()] = auth_type
+        join_room(auth_type)
+
+    @socketio.on("disconnect")
+    def on_disconnect(reason):
+        session_id = get_session_id()
+        auth_type = sockets_types_by_session_id.pop(session_id)
+        log(f"disconnected: {reason}", auth_type)
+        leave_room(auth_type)
+
+        if auth_type == "simulation":
+            simulation_manager.on_simulation_disconnect(session_id)
+
+    # MARK: Client events
+    @socketio.on("start-simulation")
+    def on_client_start_simulation(name, data, response_event, max_duration):
+        log(
+            f"starting simulation {name} with data {data}, response event {response_event} and max duration {max_duration}",
+            "client",
+        )
+        simulation_manager.start_simulation(name, data, response_event, max_duration)
+
+    @socketio.on("stop-simulation")
+    def on_client_stop_simulation(simulation_id):
+        log(f"stopping simulation {simulation_id}", "client")
+        simulation_manager.stop_simulation(simulation_id)
+
+    @socketio.on("pause-simulation")
+    def on_client_pause_simulation(simulation_id):
+        log(f"pausing simulation {simulation_id}", "client")
+        simulation_manager.pause_simulation(simulation_id)
+
+    @socketio.on("resume-simulation")
+    def on_client_resume_simulation(simulation_id):
+        log(f"resuming simulation {simulation_id}", "client")
+        simulation_manager.resume_simulation(simulation_id)
+
+    @socketio.on("get-simulations")
+    def on_client_get_simulations():
+        log("getting simulations", "client")
+        simulation_manager.emit_simulations()
+
+    @socketio.on("get-available-data")
+    def on_client_get_data():
+        log("getting available data", "client")
+        emit("available-data", get_available_data(), to=CLIENT_ROOM)
+
+    @socketio.on("get-missing-simulation-states")
+    def on_client_get_missing_simulation_states(
+        simulation_id, visualization_time, loaded_state_orders
+    ):
+        log(
+            f"getting missing simulation states for {simulation_id} with visualization time {visualization_time} and {len(loaded_state_orders)} loaded state orders ",
+            "client",
+        )
+        simulation_manager.emit_missing_simulation_states(
+            simulation_id, visualization_time, loaded_state_orders
+        )
+
+    @socketio.on("get-polylines")
+    def on_client_get_polylines(simulation_id):
+        log(f"getting polylines for {simulation_id}", "client")
+        simulation_manager.emit_simulation_polylines(simulation_id)
+
+    @socketio.on("edit-simulation-configuration")
+    def on_client_edit_simulation_configuration(simulation_id, max_duration):
+        log(
+            f"editing simulation {simulation_id} configuration with max duration {max_duration}",
+            "client",
+        )
+        simulation_manager.edit_simulation_configuration(simulation_id, max_duration)
+
+    # MARK: Script events
+    @socketio.on("terminate")
+    def on_script_terminate():
+        log("terminating server", "script")
+
+        for simulation_id, simulation_handler in simulation_manager.simulations.items():
+            if simulation_handler.process is not None:
+                simulation_manager.stop_simulation(simulation_id)
+                simulation_handler.process.join()
+
+        # TODO Solution to remove sleep
+        # - Add a flag to the simulation manager to stop the server
+        # - On simulation-end, check if all simulations with processes are stopped
+        # - If so, stop the server
+        time.sleep(1)
+
+        socketio.stop()
+
+    # MARK: Simulation events
+    @socketio.on("simulation-start")
+    def on_simulation_start(simulation_id, simulation_start_time):
+        log(f"simulation {simulation_id} started", "simulation")
+        simulation_manager.on_simulation_start(
+            simulation_id, get_session_id(), simulation_start_time
+        )
+
+    @socketio.on("simulation-pause")
+    def on_simulation_pause(simulation_id):
+        log(f"simulation {simulation_id} paused", "simulation")
+        simulation_manager.on_simulation_pause(simulation_id)
+
+    @socketio.on("simulation-resume")
+    def on_simulation_resume(simulation_id):
+        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(
+            f"simulation  {simulation_id} time: {timestamp}",
+            "simulation",
+            logging.DEBUG,
+        )
+        simulation_manager.on_simulation_update_time(simulation_id, timestamp)
+
+    @socketio.on("simulation-update-estimated-end-time")
+    def on_simulation_update_estimated_end_time(simulation_id, estimated_end_time):
+        log(
+            f"simulation  {simulation_id} estimated end time: {estimated_end_time}",
+            "simulation",
+            logging.DEBUG,
+        )
+        simulation_manager.on_simulation_update_estimated_end_time(
+            simulation_id, estimated_end_time
+        )
+
+    @socketio.on("simulation-update-polylines-version")
+    def on_simulation_update_polylines_version(simulation_id):
+        log(f"simulation  {simulation_id} polylines version updated", "simulation")
+
+        simulation_manager.on_simulation_update_polylines_version(simulation_id)
+
+    @socketio.on("simulation-identification")
+    def on_simulation_identification(
+        simulation_id,
+        data,
+        simulation_start_time,
+        timestamp,
+        estimated_end_time,
+        max_duration,
+        status,
+    ):
+        log(
+            f"simulation  {simulation_id} identified with data {data}, simulation start time {simulation_start_time}, timestamp {timestamp}, estimated end time {estimated_end_time}, max duration {max_duration} and status {status}",
+            "simulation",
+        )
+        simulation_manager.on_simulation_identification(
+            simulation_id,
+            data,
+            simulation_start_time,
+            timestamp,
+            estimated_end_time,
+            max_duration,
+            status,
+            get_session_id(),
+        )
+
+    logging.basicConfig(level=logging.DEBUG)
+
+    log(f"Starting server at {HOST}:{PORT}", "server", should_emit=False)
+
+    # MARK: Run server
+    socketio.run(app, host=HOST, port=PORT)
+
+
+if __name__ == "__main__":
+    run_server()

multimodalsim_viewer-0.0.1/multimodalsim_viewer/server/server_utils.py

@@ -0,0 +1,129 @@
+import datetime
+import logging
+import os
+import threading
+from enum import Enum
+from pathlib import Path
+
+from dotenv import load_dotenv
+from flask import request
+from flask_socketio import emit
+
+# Load environment variables from the root .env file
+env_path = Path(__file__).parent.parent / ".env"
+load_dotenv(env_path)
+
+HOST = os.getenv("SERVER_HOST", "127.0.0.1")
+PORT = int(os.getenv("PORT_SERVER", "8089"))  # It will use .env or default to 8089
+CLIENT_PORT = int(
+    os.getenv("PORT_CLIENT", "8085")
+)  # It will use .env or default to 8085
+
+CLIENT_ROOM = "client"
+SIMULATION_ROOM = "simulation"
+SCRIPT_ROOM = "script"
+
+# Save the state of the simulation every STATE_SAVE_STEP events
+STATE_SAVE_STEP = 1000
+
+# If the version is identical, the save file can be loaded
+SAVE_VERSION = 9
+
+SIMULATION_SAVE_FILE_SEPARATOR = "---"
+
+
+class SimulationStatus(Enum):
+    STARTING = "starting"
+    PAUSED = "paused"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    COMPLETED = "completed"
+    LOST = "lost"
+    CORRUPTED = "corrupted"
+    OUTDATED = "outdated"
+    FUTURE = "future"
+
+
+RUNNING_SIMULATION_STATUSES = [
+    SimulationStatus.STARTING,
+    SimulationStatus.RUNNING,
+    SimulationStatus.PAUSED,
+    SimulationStatus.STOPPING,
+    SimulationStatus.LOST,
+]
+
+
+def get_session_id():
+    return request.sid
+
+
+def build_simulation_id(name: str) -> tuple[str, str]:
+    # Get the current time
+    start_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S%f")
+    # Remove microseconds
+    start_time = start_time[:-3]
+
+    # Start time first to sort easily
+    simulation_id = f"{start_time}{SIMULATION_SAVE_FILE_SEPARATOR}{name}"
+    return simulation_id, start_time
+
+
+def get_data_directory_path(data: str | None = None) -> str:
+    cwd = os.getcwd()
+    data_directory = os.path.join(cwd, "data")
+
+    if data is not None:
+        data_directory = os.path.join(data_directory, data)
+
+    return data_directory
+
+
+def get_available_data():
+    data_dir = get_data_directory_path()
+
+    if not os.path.exists(data_dir):
+        return []
+
+    return os.listdir(data_dir)
+
+
+def log(message: str, auth_type: str, level=logging.INFO, should_emit=True) -> None:
+    if auth_type == "server":
+        logging.log(level, f"[{auth_type}] {message}")
+        if should_emit:
+            emit("log", f"{level} [{auth_type}] {message}", to=CLIENT_ROOM)
+    else:
+        logging.log(level, f"[{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:
+    if name is None:
+        return "Name is required"
+    elif len(name) < 3:
+        return "Name must be at least 3 characters"
+    elif len(name) > 50:
+        return "Name must be at most 50 characters"
+    elif name.count(SIMULATION_SAVE_FILE_SEPARATOR) > 0:
+        return "Name must not contain three consecutive dashes"
+    elif any(char in name for char in ["/", "\\", ":", "*", "?", '"', "<", ">", "|"]):
+        return 'The name muse not contain characters that might affect the file system (e.g. /, \, :, *, ?, ", <, >, |)'
+    return None
+
+
+def set_event_on_input(action: str, key: str, event: threading.Event) -> None:
+    try:
+        user_input = ""
+        while user_input != key:
+            user_input = input(f"Press {key} to {action}: ")
+
+    except EOFError:
+        pass
+
+    print(f"Received {key}: {action}")
+    event.set()