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

multimodalsim_viewer/common/environments/.env

@@ -2,3 +2,5 @@ CLIENT_PORT=8085
 SERVER_PORT=8089
 SIMULATION_SAVE_FILE_SEPARATOR=---
 INPUT_DATA_DIRECTORY_PATH=data
+NUMBER_OF_UPDATES_BETWEEN_STATES=1000
+NUMBER_OF_STATES_TO_SEND_AT_ONCE=1

multimodalsim_viewer/common/utils.py

@@ -79,6 +79,14 @@ class _Environment:
     def input_data_directory_path(self) -> str:
         return environment.get("INPUT_DATA_DIRECTORY_PATH")
 
+    @property
+    def number_of_updates_between_states(self) -> int:
+        return int(environment.get("NUMBER_OF_UPDATES_BETWEEN_STATES"))
+
+    @property
+    def number_of_states_to_send_at_once(self) -> int:
+        return int(environment.get("NUMBER_OF_STATES_TO_SEND_AT_ONCE"))
+
 
 _environment = _Environment()
 SERVER_PORT = _environment.server_port
@@ -86,17 +94,16 @@ 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
+NUMBER_OF_UPDATES_BETWEEN_STATES = _environment.number_of_updates_between_states
+NUMBER_OF_STATES_TO_SEND_AT_ONCE = _environment.number_of_states_to_send_at_once
 
 
 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
+SAVE_VERSION = 12
 
 
 class SimulationStatus(Enum):
@@ -135,50 +142,6 @@ def build_simulation_id(name: str) -> tuple[str, str]:
     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)

multimodalsim_viewer/models/environment.py

@@ -0,0 +1,70 @@
+from multimodalsim_viewer.models.passenger import VisualizedPassenger
+from multimodalsim_viewer.models.serializable import Serializable
+from multimodalsim_viewer.models.vehicle import VisualizedVehicle
+
+
+# MARK: Environment
+class VisualizedEnvironment(Serializable):
+
+    def __init__(self) -> None:
+        self.passengers: dict[str, VisualizedPassenger] = {}
+        self.vehicles: dict[str, VisualizedVehicle] = {}
+        self.timestamp: float = 0.0
+        self.estimated_end_time: float = 0.0
+        self.update_index: int = 0
+        self.statistics: dict | None = None
+
+    def add_passenger(self, passenger: VisualizedPassenger) -> None:
+        self.passengers[passenger.passenger_id] = passenger
+
+    def get_passenger(self, passenger_id: str) -> VisualizedPassenger | None:
+        if passenger_id in self.passengers:
+            return self.passengers[passenger_id]
+        return None
+
+    def add_vehicle(self, vehicle: VisualizedVehicle) -> None:
+        self.vehicles[vehicle.vehicle_id] = vehicle
+
+    def get_vehicle(self, vehicle_id: str) -> VisualizedVehicle | None:
+        if vehicle_id in self.vehicles:
+            return self.vehicles[vehicle_id]
+        return None
+
+    def serialize(self) -> dict:
+        return {
+            "passengers": [passenger.serialize() for passenger in self.passengers.values()],
+            "vehicles": [vehicle.serialize() for vehicle in self.vehicles.values()],
+            "timestamp": self.timestamp,
+            "statistics": self.statistics if self.statistics is not None else {},
+            "updateIndex": self.update_index,
+        }
+
+    @classmethod
+    def deserialize(cls, serialized_data: dict | str) -> "VisualizedEnvironment":
+        serialized_data = cls.serialized_data_to_dict(serialized_data)
+
+        required_keys = [
+            "passengers",
+            "vehicles",
+            "timestamp",
+            "statistics",
+            "updateIndex",
+        ]
+
+        cls.verify_required_fields(serialized_data, required_keys, "VisualizedEnvironment")
+
+        environment = VisualizedEnvironment()
+        for passenger_data in serialized_data["passengers"]:
+            passenger = VisualizedPassenger.deserialize(passenger_data)
+            environment.add_passenger(passenger)
+
+        for vehicle_data in serialized_data["vehicles"]:
+            vehicle = VisualizedVehicle.deserialize(vehicle_data)
+            environment.add_vehicle(vehicle)
+
+        environment.timestamp = serialized_data["timestamp"]
+        environment.estimated_end_time = serialized_data["estimatedEndTime"]
+        environment.statistics = serialized_data["statistics"]
+        environment.update_index = serialized_data["updateIndex"]
+
+        return environment

multimodalsim_viewer/models/leg.py

@@ -0,0 +1,194 @@
+from enum import Enum
+
+from multimodalsim.simulator.environment import Environment
+from multimodalsim.simulator.request import Leg, Trip
+from multimodalsim.simulator.stop import Stop
+
+from multimodalsim_viewer.models.serializable import Serializable
+
+
+# MARK: get_stop_id
+def get_stop_id(stop: Stop) -> str:
+    return f"{stop.location.lat},{stop.location.lon}"
+
+
+# MARK: LegType
+class LegType(Enum):
+    PREVIOUS = "previous"
+    CURRENT = "current"
+    NEXT = "next"
+
+
+# MARK: Leg
+class VisualizedLeg(Serializable):  # pylint: disable=too-many-instance-attributes
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        assigned_vehicle_id: str | None,
+        boarding_stop_id: str | None,
+        alighting_stop_id: str | None,
+        boarding_stop_index: int | None,
+        alighting_stop_index: int | None,
+        boarding_time: float | None,
+        alighting_time: float | None,
+        tags: list[str],
+        leg_type: LegType,
+    ) -> None:
+        self.assigned_vehicle_id: str | None = assigned_vehicle_id
+
+        self.boarding_stop_id: str | None = boarding_stop_id
+        self.alighting_stop_id: str | None = alighting_stop_id
+        self.boarding_stop_index: int | None = boarding_stop_index
+        self.alighting_stop_index: int | None = alighting_stop_index
+        self.boarding_time: float | None = boarding_time
+        self.alighting_time: float | None = alighting_time
+
+        self.tags: list[str] = tags
+        self.leg_type: LegType = leg_type
+
+    @classmethod
+    def from_leg_environment_and_trip(  # pylint: disable=too-many-locals, too-many-branches, too-many-arguments, too-many-positional-arguments
+        cls,
+        leg: Leg,
+        environment: Environment,
+        trip: Trip,
+        leg_type: LegType,
+    ) -> "VisualizedLeg":
+        boarding_stop_id = None
+        alighting_stop_id = None
+        boarding_stop_index = None
+        alighting_stop_index = None
+
+        route = (
+            environment.get_route_by_vehicle_id(leg.assigned_vehicle.id) if leg.assigned_vehicle is not None else None
+        )
+
+        all_legs = trip.previous_legs + ([trip.current_leg] if trip.current_leg else []) + trip.next_legs
+
+        same_vehicle_leg_index = 0
+        for other_leg in all_legs:
+            if other_leg.assigned_vehicle == leg.assigned_vehicle:
+                if other_leg == leg:
+                    break
+                same_vehicle_leg_index += 1
+
+        if route is not None:
+            all_stops = route.previous_stops.copy()
+            if route.current_stop is not None:
+                all_stops.append(route.current_stop)
+            all_stops += route.next_stops
+
+            trip_found_count = 0
+
+            for i, stop in enumerate(all_stops):
+                if boarding_stop_index is None and trip in (
+                    stop.passengers_to_board + stop.boarding_passengers + stop.boarded_passengers
+                ):
+                    if trip_found_count == same_vehicle_leg_index:
+                        boarding_stop_id = get_stop_id(stop)
+                        boarding_stop_index = i
+                        break
+                    trip_found_count += 1
+
+            trip_found_count = 0
+
+            for i, stop in enumerate(all_stops):
+                if alighting_stop_index is None and trip in (
+                    stop.passengers_to_alight + stop.alighting_passengers + stop.alighted_passengers
+                ):
+                    if trip_found_count == same_vehicle_leg_index:
+                        alighting_stop_id = get_stop_id(stop)
+                        alighting_stop_index = i
+                        break
+                    trip_found_count += 1
+
+        assigned_vehicle_id = leg.assigned_vehicle.id if leg.assigned_vehicle is not None else None
+
+        return cls(
+            assigned_vehicle_id,
+            boarding_stop_id,
+            alighting_stop_id,
+            boarding_stop_index,
+            alighting_stop_index,
+            leg.boarding_time,
+            leg.alighting_time,
+            leg.tags,
+            leg_type,
+        )
+
+    def serialize(self) -> dict:
+        serialized = {}
+
+        serialized["legType"] = self.leg_type.value
+
+        if self.assigned_vehicle_id is not None:
+            serialized["assignedVehicleId"] = self.assigned_vehicle_id
+
+        if self.boarding_stop_id is not None:
+            serialized["boardingStopId"] = self.boarding_stop_id
+
+        if self.alighting_stop_id is not None:
+            serialized["alightingStopId"] = self.alighting_stop_id
+
+        if self.boarding_stop_index is not None:
+            serialized["boardingStopIndex"] = self.boarding_stop_index
+
+        if self.alighting_stop_index is not None:
+            serialized["alightingStopIndex"] = self.alighting_stop_index
+
+        if self.boarding_time is not None:
+            serialized["boardingTime"] = self.boarding_time
+
+        if self.alighting_time is not None:
+            serialized["alightingTime"] = self.alighting_time
+
+        if len(self.tags) > 0:
+            serialized["tags"] = self.tags
+
+        return serialized
+
+    @classmethod
+    def deserialize(cls, serialized_data: dict | str) -> "VisualizedLeg":
+        serialized_data = cls.serialized_data_to_dict(serialized_data)
+
+        required_keys = ["legType"]
+
+        cls.verify_required_fields(serialized_data, required_keys, "VisualizedLeg")
+
+        assigned_vehicle_id = serialized_data.get("assignedVehicleId", None)
+
+        boarding_stop_id = serialized_data.get("boardingStopId", None)
+
+        alighting_stop_id = serialized_data.get("alightingStopId", None)
+
+        boarding_stop_index = serialized_data.get("boardingStopIndex", None)
+        if boarding_stop_index is not None:
+            boarding_stop_index = int(boarding_stop_index)
+
+        alighting_stop_index = serialized_data.get("alightingStopIndex", None)
+        if alighting_stop_index is not None:
+            alighting_stop_index = int(alighting_stop_index)
+
+        boarding_time = serialized_data.get("boardingTime", None)
+        if boarding_time is not None:
+            boarding_time = float(boarding_time)
+
+        alighting_time = serialized_data.get("alightingTime", None)
+        if alighting_time is not None:
+            alighting_time = float(alighting_time)
+
+        tags = serialized_data.get("tags", [])
+
+        leg_type = serialized_data.get("legType")
+
+        return cls(
+            assigned_vehicle_id,
+            boarding_stop_id,
+            alighting_stop_id,
+            boarding_stop_index,
+            alighting_stop_index,
+            boarding_time,
+            alighting_time,
+            tags,
+            LegType(leg_type),
+        )

multimodalsim_viewer/models/passenger.py

@@ -0,0 +1,148 @@
+from multimodalsim.optimization.dispatcher import (  # To avoid circular import issues. pylint: disable=unused-import;
+    Dispatcher,
+)
+from multimodalsim.simulator.environment import Environment
+from multimodalsim.simulator.request import Trip
+from multimodalsim.state_machine.status import PassengerStatus
+
+from multimodalsim_viewer.models.leg import LegType, VisualizedLeg
+from multimodalsim_viewer.models.serializable import Serializable
+
+
+# MARK: Enums
+def convert_passenger_status_to_string(status: PassengerStatus) -> str:
+    if status == PassengerStatus.RELEASE:
+        return "release"
+    if status == PassengerStatus.ASSIGNED:
+        return "assigned"
+    if status == PassengerStatus.READY:
+        return "ready"
+    if status == PassengerStatus.ONBOARD:
+        return "onboard"
+    if status == PassengerStatus.COMPLETE:
+        return "complete"
+    raise ValueError(f"Unknown PassengerStatus {status}")
+
+
+def convert_string_to_passenger_status(status: str) -> PassengerStatus:
+    if status == "release":
+        return PassengerStatus.RELEASE
+    if status == "assigned":
+        return PassengerStatus.ASSIGNED
+    if status == "ready":
+        return PassengerStatus.READY
+    if status == "onboard":
+        return PassengerStatus.ONBOARD
+    if status == "complete":
+        return PassengerStatus.COMPLETE
+    raise ValueError(f"Unknown PassengerStatus {status}")
+
+
+# MARK: Passenger
+class VisualizedPassenger(Serializable):  # pylint: disable=too-many-instance-attributes
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        passenger_id: str,
+        name: str | None,
+        status: PassengerStatus,
+        number_of_passengers: int,
+        previous_legs: list[VisualizedLeg],
+        current_leg: VisualizedLeg | None,
+        next_legs: list[VisualizedLeg],
+        tags: list[str],
+    ) -> None:
+        self.passenger_id: str = passenger_id
+        self.name: str | None = name
+        self.status: PassengerStatus = status
+        self.number_of_passengers: int = number_of_passengers
+
+        self.previous_legs: list[VisualizedLeg] = previous_legs
+        self.current_leg: VisualizedLeg | None = current_leg
+        self.next_legs: list[VisualizedLeg] = next_legs
+
+        self.tags: list[str] = tags
+
+    @classmethod
+    def from_trip_and_environment(cls, trip: Trip, environment: Environment) -> "VisualizedPassenger":
+        previous_legs = [
+            VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip, LegType.PREVIOUS)
+            for leg in trip.previous_legs
+        ]
+        current_leg = (
+            VisualizedLeg.from_leg_environment_and_trip(trip.current_leg, environment, trip, LegType.CURRENT)
+            if trip.current_leg is not None
+            else None
+        )
+        next_legs = [
+            VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip, LegType.NEXT) for leg in trip.next_legs
+        ]
+
+        return cls(
+            trip.id, trip.name, trip.status, trip.nb_passengers, previous_legs, current_leg, next_legs, trip.tags
+        )
+
+    @property
+    def all_legs(self) -> list[VisualizedLeg]:
+        """
+        Returns all legs of the passenger, including previous, current, and next legs.
+        """
+        return self.previous_legs + ([self.current_leg] if self.current_leg is not None else []) + self.next_legs
+
+    # Similar to VisualizedVehicle
+    # pylint: disable=duplicate-code
+    def serialize(self) -> dict:
+        serialized = {
+            "id": self.passenger_id,
+            "status": convert_passenger_status_to_string(self.status),
+            "numberOfPassengers": self.number_of_passengers,
+        }
+
+        if self.name is not None:
+            serialized["name"] = self.name
+
+        serialized["previousLegs"] = [leg.serialize() for leg in self.previous_legs]
+
+        if self.current_leg is not None:
+            serialized["currentLeg"] = self.current_leg.serialize()
+
+        serialized["nextLegs"] = [leg.serialize() for leg in self.next_legs]
+
+        if len(self.tags) > 0:
+            serialized["tags"] = self.tags
+
+        return serialized
+
+    @classmethod
+    def deserialize(cls, serialized_data: dict | str) -> "VisualizedPassenger":
+        serialized_data = cls.serialized_data_to_dict(serialized_data)
+
+        required_keys = [
+            "id",
+            "status",
+            "previousLegs",
+            "nextLegs",
+            "numberOfPassengers",
+        ]
+
+        cls.verify_required_fields(serialized_data, required_keys, "VisualizedPassenger")
+
+        passenger_id = str(serialized_data["id"])
+        name = serialized_data.get("name", None)
+        status = convert_string_to_passenger_status(serialized_data["status"])
+        number_of_passengers = int(serialized_data["numberOfPassengers"])
+
+        previous_legs = [VisualizedLeg.deserialize(leg_data) for leg_data in serialized_data["previousLegs"]]
+        next_legs = [VisualizedLeg.deserialize(leg_data) for leg_data in serialized_data["nextLegs"]]
+
+        current_leg = serialized_data.get("currentLeg", None)
+        if current_leg is not None:
+            current_leg = VisualizedLeg.deserialize(current_leg)
+
+        tags = serialized_data.get("tags", [])
+
+        return VisualizedPassenger(
+            passenger_id, name, status, number_of_passengers, previous_legs, current_leg, next_legs, tags
+        )
+
+    # pylint: enable=duplicate-code

multimodalsim_viewer/models/serializable.py

@@ -0,0 +1,43 @@
+from json import loads
+
+
+# MARK: Serializable
+class Serializable:
+    def serialize(self) -> dict:
+        """
+        Serialize the instance into a dictionary.
+
+        This method should be implemented by subclasses.
+        """
+
+    @classmethod
+    def deserialize(cls, serialized_data: dict | str) -> "Serializable":
+        """
+        Deserialize a dictionary into an instance of the class.
+
+        If the dictionary is not valid, raise a `ValueError`.
+
+        This method should be implemented by subclasses.
+        """
+
+    @staticmethod
+    def serialized_data_to_dict(serialized_data: dict | str) -> dict:
+        """
+        Parse the serialized data into a dictionary if it is a string.
+
+        This method should be called before each deserialization.
+        """
+        if isinstance(serialized_data, str):
+            return loads(serialized_data)
+        return serialized_data
+
+    @staticmethod
+    def verify_required_fields(serialized_data: dict, required_fields: list[str], class_name: str) -> None:
+        """
+        Verify that the serialized data contains all required fields.
+
+        If any field is missing, raise a `ValueError`.
+        """
+        for field in required_fields:
+            if field not in serialized_data:
+                raise ValueError(f"Serialized data of {class_name} must contain '{field}' key")

multimodalsim_viewer/models/simulation_information.py

@@ -0,0 +1,84 @@
+from multimodalsim_viewer.common.utils import (
+    SAVE_VERSION,
+    SIMULATION_SAVE_FILE_SEPARATOR,
+)
+from multimodalsim_viewer.models.serializable import Serializable
+
+
+# MARK: SimulationInformation
+class SimulationInformation(Serializable):  # pylint: disable=too-many-instance-attributes
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        simulation_id: str,
+        data: str,
+        simulation_start_time: float | None,
+        simulation_end_time: float | None,
+        last_update_index: int | None,
+        version: int | None,
+    ) -> None:
+        self.version: int = version
+        if self.version is None:
+            self.version = SAVE_VERSION
+
+        self.simulation_id: str = simulation_id
+
+        self.name: str = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)[1]
+        self.start_time: str = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)[0]
+        self.data: str = data
+
+        self.simulation_start_time: float | None = simulation_start_time
+        self.simulation_end_time: float | None = simulation_end_time
+        self.last_update_index: int | None = last_update_index
+
+    def serialize(self) -> dict:
+        serialized = {
+            "version": self.version,
+            "simulationId": self.simulation_id,
+            "name": self.name,
+            "startTime": self.start_time,
+            "data": self.data,
+        }
+
+        if self.simulation_start_time is not None:
+            serialized["simulationStartTime"] = self.simulation_start_time
+
+        if self.simulation_end_time is not None:
+            serialized["simulationEndTime"] = self.simulation_end_time
+
+        if self.last_update_index is not None:
+            serialized["lastUpdateIndex"] = self.last_update_index
+
+        return serialized
+
+    @classmethod
+    def deserialize(cls, serialized_data: dict | str) -> "SimulationInformation":
+        serialized_data = cls.serialized_data_to_dict(serialized_data)
+
+        required_keys = ["version", "simulationId", "data"]
+        cls.verify_required_fields(serialized_data, required_keys, "SimulationInformation")
+
+        version = int(serialized_data["version"])
+        simulation_id = str(serialized_data["simulationId"])
+        simulation_data = str(serialized_data["data"])
+
+        simulation_start_time = serialized_data.get("simulationStartTime", None)
+        if simulation_start_time is not None:
+            simulation_start_time = float(simulation_start_time)
+
+        simulation_end_time = serialized_data.get("simulationEndTime", None)
+        if simulation_end_time is not None:
+            simulation_end_time = float(simulation_end_time)
+
+        last_update_index = serialized_data.get("lastUpdateIndex", None)
+        if last_update_index is not None:
+            last_update_index = int(last_update_index)
+
+        return SimulationInformation(
+            simulation_id,
+            simulation_data,
+            simulation_start_time,
+            simulation_end_time,
+            last_update_index,
+            version,
+        )

multimodalsim_viewer/models/state.py

@@ -0,0 +1,44 @@
+from multimodalsim_viewer.models.environment import VisualizedEnvironment
+from multimodalsim_viewer.models.update import Update
+
+
+# MARK: State
+class VisualizedState(VisualizedEnvironment):
+    def __init__(self) -> None:
+        super().__init__()
+        self.updates: list[Update] = []
+
+    @classmethod
+    def from_environment(cls, environment: VisualizedEnvironment) -> "VisualizedState":
+        state = cls()
+        state.passengers = environment.passengers
+        state.vehicles = environment.vehicles
+        state.timestamp = environment.timestamp
+        state.estimated_end_time = environment.estimated_end_time
+        state.update_index = environment.update_index
+        return state
+
+    def serialize(self) -> dict:
+        serialized = super().serialize()
+
+        serialized["updates"] = [update.serialize() for update in self.updates]
+
+        return serialized
+
+    @classmethod
+    def deserialize(cls, serialized_data: dict | str) -> "VisualizedState":
+        serialized_data = cls.serialized_data_to_dict(serialized_data)
+
+        environment = VisualizedEnvironment.deserialize(serialized_data)
+
+        required_keys = ["updates"]
+
+        cls.verify_required_fields(serialized_data, required_keys, "VisualizedState")
+
+        state = cls.from_environment(environment)
+
+        for update_data in serialized_data["updates"]:
+            update = Update.deserialize(update_data)
+            state.updates.append(update)
+
+        return state