multimodalsim-viewer 0.0.2__tar.gz → 0.1.0.0__tar.gz

{multimodalsim_viewer-0.0.2 → multimodalsim_viewer-0.1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multimodalsim_viewer
-Version: 0.0.2
+Version: 0.1.0.0
 Summary: Multimodal simulation viewer
 Keywords: flask angular ui multimodal server
 Requires-Python: >=3.10
@@ -37,23 +37,13 @@ This package provides an interface to the [multimodalsim simulation project](htt
 
 ## Usage
 
-You have access to several commands that will allow you to run the project easily.
+You have access to several commands that will allow you to run the project easily. You can use the `--help` flag to see a list of available options.
 
 ```bash
 viewer start 
-viewer start --ui     # only start the UI side
-viewer start --server # only start the server 
 
 viewer stop
-viewer stop --ui     # only stop the UI side
-viewer stop --server # only stop the server
-```
-
-You can also run a simulation from the command line. This is useful for debugging, when you want to run a simulation without the web interface, and also for running simulations that uses a different version of the multimodalsim package.
-
-Several arguments are available to customize the simulation and can be found with the --help option, but the required arguments will be asked interactively if not provided. The command to run a simulation is:
 
-```bash
 viewer simulate
 ```
 
@@ -68,3 +58,7 @@ To run a simulation, you need to provide input data. You can upload input data f
 ```bash
 git clone https://github.com/lab-core/multimodal-data.git
 ```
+
+## Environment variables
+
+Some environment variables are available to customize the application. You can find a detailed list of these variables in the [README.md](https://github.com/lab-core/multimodal-simulator/blob/main/README.md#environment-variables) file of the multimodal-simulator repository.

{multimodalsim_viewer-0.0.2 → multimodalsim_viewer-0.1.0.0}/README.md

@@ -4,23 +4,13 @@ This package provides an interface to the [multimodalsim simulation project](htt
 
 ## Usage
 
-You have access to several commands that will allow you to run the project easily.
+You have access to several commands that will allow you to run the project easily. You can use the `--help` flag to see a list of available options.
 
 ```bash
 viewer start 
-viewer start --ui     # only start the UI side
-viewer start --server # only start the server 
 
 viewer stop
-viewer stop --ui     # only stop the UI side
-viewer stop --server # only stop the server
-```
-
-You can also run a simulation from the command line. This is useful for debugging, when you want to run a simulation without the web interface, and also for running simulations that uses a different version of the multimodalsim package.
 
-Several arguments are available to customize the simulation and can be found with the --help option, but the required arguments will be asked interactively if not provided. The command to run a simulation is:
-
-```bash
 viewer simulate
 ```
 
@@ -34,4 +24,8 @@ To run a simulation, you need to provide input data. You can upload input data f
 
 ```bash
 git clone https://github.com/lab-core/multimodal-data.git
-```
+```
+
+## Environment variables
+
+Some environment variables are available to customize the application. You can find a detailed list of these variables in the [README.md](https://github.com/lab-core/multimodal-simulator/blob/main/README.md#environment-variables) file of the multimodal-simulator repository.

{multimodalsim_viewer-0.0.2 → multimodalsim_viewer-0.1.0.0}/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-0.0.2 → multimodalsim_viewer-0.1.0.0}/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-0.1.0.0/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-0.1.0.0/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-0.1.0.0/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-0.1.0.0/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")