multimodalsim-viewer 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

multimodalsim_viewer/common/environments/.env

@@ -0,0 +1,4 @@
+CLIENT_PORT=8085
+SERVER_PORT=8089
+SIMULATION_SAVE_FILE_SEPARATOR=---
+INPUT_DATA_DIRECTORY_PATH=data

multimodalsim_viewer/common/utils.py

@@ -0,0 +1,223 @@
+import datetime
+import logging
+import os
+import shutil
+import threading
+from enum import Enum
+from json import dumps
+
+from dotenv import dotenv_values
+from filelock import FileLock
+from flask import request
+from flask_socketio import emit
+
+environment = {}
+
+
+def load_environment() -> None:
+    # Copy .env if it exists
+    current_directory = os.path.dirname(os.path.abspath(__file__))
+    default_environment_path = os.path.join(current_directory, "../../../.env")
+    environment_path = os.path.join(current_directory, "environments/.env")
+
+    if os.path.exists(default_environment_path):
+        shutil.copy(default_environment_path, environment_path)
+
+    # Load environment variables from .env
+    def load_environment_file(path: str, previous_environment: dict) -> None:
+        if not os.path.exists(path):
+            return
+
+        values = dotenv_values(path)
+        for key in values:
+            previous_environment[key] = values[key]
+
+    # Load default environment
+    load_environment_file(environment_path, environment)
+    # Load environment from the current working directory
+    load_environment_file(os.path.join(os.getcwd(), ".env"), environment)
+
+    # Get host from docker if available and set it in environment
+    environment["HOST"] = os.getenv("HOST", "127.0.0.1")
+
+    # Write environment into static folder
+    static_environment_path = os.path.join(current_directory, "../ui/static/environment.json")
+    lock = FileLock(f"{static_environment_path}.lock")
+    with lock:
+        with open(static_environment_path, "w", encoding="utf-8") as static_environment_file:
+            static_environment_file.write(dumps(environment, indent=2, separators=(",", ": "), sort_keys=True))
+
+
+class _Environment:
+    is_environment_loaded = False
+
+    def __init__(self):
+        if _Environment.is_environment_loaded:
+            return
+
+        load_environment()
+        _Environment.is_environment_loaded = True
+        print(f"Environment loaded {environment}")
+
+    @property
+    def server_port(self) -> int:
+        return int(environment.get("SERVER_PORT"))
+
+    @property
+    def client_port(self) -> int:
+        return int(environment.get("CLIENT_PORT"))
+
+    @property
+    def host(self) -> str:
+        return environment.get("HOST")
+
+    @property
+    def simulation_save_file_separator(self) -> str:
+        return environment.get("SIMULATION_SAVE_FILE_SEPARATOR")
+
+    @property
+    def input_data_directory_path(self) -> str:
+        return environment.get("INPUT_DATA_DIRECTORY_PATH")
+
+
+_environment = _Environment()
+SERVER_PORT = _environment.server_port
+CLIENT_PORT = _environment.client_port
+HOST = _environment.host
+SIMULATION_SAVE_FILE_SEPARATOR = _environment.simulation_save_file_separator
+INPUT_DATA_DIRECTORY_PATH = _environment.input_data_directory_path
+
+
+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
+
+
+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() -> str:
+    current_file_path = os.path.abspath(__file__)
+    current_file_dir = os.path.dirname(current_file_path)
+    data_directory_path = os.path.join(current_file_dir, "..", "data")
+
+    if not os.path.exists(data_directory_path):
+        os.makedirs(data_directory_path)
+
+    return data_directory_path
+
+
+def get_saved_logs_directory_path() -> str:
+    data_directory_path = get_data_directory_path()
+    saved_logs_directory_path = os.path.join(data_directory_path, "saved_logs")
+
+    if not os.path.exists(saved_logs_directory_path):
+        os.makedirs(saved_logs_directory_path)
+
+    return saved_logs_directory_path
+
+
+def get_input_data_directory_path(data: str | None = None) -> str:
+    input_data_directory = INPUT_DATA_DIRECTORY_PATH
+
+    if data is not None:
+        input_data_directory = os.path.join(input_data_directory, data)
+
+    return input_data_directory
+
+
+def get_available_data():
+    input_data_directory = get_input_data_directory_path()
+
+    if not os.path.exists(input_data_directory):
+        return []
+
+    # List all directories in the input data directory
+    return [
+        name
+        for name in os.listdir(input_data_directory)
+        if os.path.isdir(os.path.join(input_data_directory, name)) and not name.startswith(".")
+    ]
+
+
+def log(message: str, auth_type: str, level=logging.INFO, should_emit=True) -> 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:
+    if name is None:
+        return "Name is required"
+    if len(name) < 3:
+        return "Name must be at least 3 characters"
+    if len(name) > 50:
+        return "Name must be at most 50 characters"
+    if name.count(SIMULATION_SAVE_FILE_SEPARATOR) > 0:
+        return "Name must not contain three consecutive dashes"
+    if 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()

multimodalsim_viewer/server/http_routes.py

@@ -1,125 +1,135 @@
-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"})
+import logging
+import os
+import shutil
+import tempfile
+import zipfile
+
+from flask import Blueprint, jsonify, request, send_file
+
+from multimodalsim_viewer.common.utils import get_input_data_directory_path
+from multimodalsim_viewer.server.simulation_visualization_data_model import (
+    SimulationVisualizationDataManager,
+)
+
+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 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 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("Extracted files: %s", 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 = 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)
+
+
+@http_routes.route("/api/input_data/<folder_name>", methods=["POST"])
+def import_input_data(folder_name):
+    folder_path = get_input_data_directory_path(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 = 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: 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)
+
+    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 = 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"})

multimodalsim_viewer/server/log_manager.py

@@ -1,15 +1,10 @@
-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")
+from multimodalsim_viewer.common.utils import get_saved_logs_directory_path
+
+
+def register_log(simulation_id, message):
+    saved_logs_directory_path = get_saved_logs_directory_path()
+    file_name = f"{simulation_id}.txt"
+    file_path = f"{saved_logs_directory_path}/{file_name}"
+
+    with open(file_path, "a", encoding="utf-8") as file:
+        file.write(message + "\n")