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

multimodalsim_viewer/server/scripts.py

@@ -1,25 +1,52 @@
-import threading
+import argparse
 import time
+import webbrowser
 
-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
+from requests import get
+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.server.server import configure_server
+from multimodalsim_viewer.server.simulation import (
+    configure_simulation_parser,
+    start_simulation_cli,
+)
+from multimodalsim_viewer.ui.angular_app import configure_angular_app
 
-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()
+def start(should_start_ui: bool, should_start_server: bool):
+    app = None
+    socketio = None
 
-    # Wait for both threads to finish
-    server_thread.join()
-    ui_thread.join()
+    if should_start_server:
+        (app, socketio) = configure_server()
+
+    if should_start_ui:
+        app = configure_angular_app(app)
+
+    # Use SERVER_PORT even for the client if the server is running
+    ui_port = SERVER_PORT if should_start_server else CLIENT_PORT
+    if should_start_ui:
+        webbrowser.open(f"http://{HOST}:{ui_port}")
+
+    if socketio is not None:
+        socketio.run(app, host=HOST, port=SERVER_PORT)
+    else:
+        # app should not be None here
+        app.run(host=HOST, port=CLIENT_PORT)
+
+
+def stop(should_stop_ui: bool, should_stop_server: bool):
+    if should_stop_ui:
+        terminate_ui()
+    if should_stop_server:
+        terminate_server()
 
 
 def terminate_server():
@@ -28,7 +55,7 @@ def terminate_server():
     sio = Client()
 
     try:
-        sio.connect(f"http://{HOST}:{PORT}", auth={"type": "script"})
+        sio.connect(f"http://{HOST}:{SERVER_PORT}", auth={"type": "script"})
 
         sio.emit("terminate")
 
@@ -38,35 +65,82 @@ def terminate_server():
 
         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}")
+    except SocketIOConnectionError:  # pylint: disable=broad-exception-caught
+        print("Server is not running or cannot be reached.")
 
 
 def terminate_ui():
     print("Terminating UI...")
 
+    terminated = False
+
     try:
-        response = requests.get(f"http://{HOST}:{CLIENT_PORT}/terminate")
+        response = get(f"http://{HOST}:{CLIENT_PORT}/terminate", timeout=5)
 
         if response.status_code == 200:
             print("UI terminated")
+            terminated = True
         else:
             print(f"Failed to terminate UI: {response.status_code}")
 
-    except requests.exceptions.RequestException as e:
-        print(f"Error: {e}")
+    except RequestsConnectionError:  # pylint: disable=broad-exception-caught
+        print("UI is not running or cannot be reached.")
+
+    if terminated:
+        return
+
+    print("Trying to terminate UI at server port...")
+    try:
+        response = get(f"http://{HOST}:{SERVER_PORT}/terminate", timeout=5)
+
+        if response.status_code == 200:
+            print("UI terminated at server port")
+        else:
+            print(f"Failed to terminate UI at server port: {response.status_code}")
+
+    except RequestsConnectionError:
+        print("UI is not running or cannot be reached at server port.")
+
+
+def main():
+    """
+    Main entry point for the multimodal simulation viewer CLI.
+
+    This function sets up the command-line interface using argparse and provides
+    options to run the server, UI, or both, as well as to terminate them.
+    """
+
+    parser = argparse.ArgumentParser(description="Multimodal Simulation Viewer CLI")
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    start_parser = subparsers.add_parser("start", help="Start the server and UI")
+    start_parser.add_argument("--server", action="store_true", help="Start only the server")
+    start_parser.add_argument("--ui", action="store_true", help="Start only the UI")
+
+    stop_parser = subparsers.add_parser("stop", help="Stop the server and UI")
+    stop_parser.add_argument("--ui", action="store_true", help="Stop only the UI")
+    stop_parser.add_argument("--server", action="store_true", help="Stop only the server")
+
+    simulate_parser = subparsers.add_parser("simulate", help="Run a simulation")
+    configure_simulation_parser(simulate_parser)
+
+    # Parse the arguments
+    args = parser.parse_args()
 
-    except Exception as e:
-        print(f"Error: {e}")
+    if args.command == "start":
+        should_start_ui = args.ui or not args.server
+        should_start_server = args.server or not args.ui
+        start(should_start_ui, should_start_server)
 
+    elif args.command == "stop":
+        should_stop_ui = args.ui or not args.server
+        should_stop_server = args.server or not args.ui
+        stop(should_stop_ui, should_stop_server)
 
-def terminate_all():
-    print("Terminating all...")
+    elif args.command == "simulate":
+        start_simulation_cli(args)
 
-    terminate_server()
-    terminate_ui()
 
-    print("All terminated")
+if __name__ == "__main__":
+    main()

multimodalsim_viewer/server/server.py

@@ -1,210 +1,196 @@
-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()
+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.common.utils import (
+    CLIENT_ROOM,
+    get_available_data,
+    get_session_id,
+    log,
+)
+from multimodalsim_viewer.server.http_routes import http_routes
+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__)
+
+    # 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 = {}
+
+    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}, "
+            f"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} "
+            f"with visualization time {visualization_time} "
+            f"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()
+
+        # Wait for all connections to close
+        time.sleep(1)
+
+        socketio.stop()
+
+        print("Server terminated successfully.")
+
+    # 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(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        simulation_id,
+        data,
+        simulation_start_time,
+        timestamp,
+        estimated_end_time,
+        max_duration,
+        status,
+    ):
+        log(
+            f"simulation  {simulation_id} identified with data {data}, "
+            f"simulation start time {simulation_start_time}, timestamp {timestamp}, "
+            f"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(),
+        )
+
+    return app, socketio