eflips-depot 3.0.0__tar.gz → 3.0.2__tar.gz

{eflips_depot-3.0.0 → eflips_depot-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eflips-depot
-Version: 3.0.0
+Version: 3.0.2
 Summary: Depot Simulation for eFLIPS
 License: AGPLv3
 Author: Enrico Lauth

{eflips_depot-3.0.0 → eflips_depot-3.0.2}/eflips/depot/api/__init__.py

@@ -724,11 +724,7 @@ def add_evaluation_to_database(
                 else:
                     for process in process_log:
                         match process.status:
-                            case ProcessStatus.CANCELLED:
-                                raise NotImplementedError(
-                                    f"Cancelled processes {process.ID} are not implemented."
-                                )
-                            case ProcessStatus.COMPLETED:
+                            case ProcessStatus.COMPLETED | ProcessStatus.CANCELLED:
                                 assert (
                                     len(process.starts) == 1 and len(process.ends) == 1
                                 ), (
@@ -754,13 +750,38 @@ def add_evaluation_to_database(
                                     }
                                 else:
                                     # Duration is 0
-
-                                    if start_time in dict_of_events:
-                                        assert current_area.issink is True
+                                    if current_area.issink is True:
                                         # Standby departure
-                                        actual_start_time = dict_of_events[start_time][
-                                            "end"
-                                        ]
+                                        if start_time in dict_of_events:
+                                            # Actual start time should be the end time of the other positive duration
+                                            # process starting at the same time
+                                            actual_start_time = dict_of_events[
+                                                start_time
+                                            ]["end"]
+                                        else:
+                                            for other_process in process_log:
+                                                if (
+                                                    other_process.dur > 0
+                                                    and len(other_process.ends) != 0
+                                                ):
+                                                    actual_start_time = (
+                                                        other_process.ends[0]
+                                                    )
+                                                else:
+                                                    # Invalid standby before a process in progress will be ignored
+                                                    continue
+
+                                        last_standby_departure_start = actual_start_time
+
+                                        # If this standby event lasts actually 0 seconds, it is not a real event
+                                        if (
+                                            actual_start_time in dict_of_events.keys()
+                                            and dict_of_events[actual_start_time][
+                                                "type"
+                                            ]
+                                            == "trip"
+                                        ):
+                                            continue
                                         dict_of_events[actual_start_time] = {
                                             "type": type(process).__name__,
                                             "area": current_area.ID,
@@ -769,11 +790,12 @@ def add_evaluation_to_database(
                                             "id": process.ID,
                                         }
 
-                                        last_standby_departure_start = actual_start_time
-
                                     else:
                                         # Standby arrival
-                                        assert current_area.issink is False
+                                        assert current_area.issink is False, (
+                                            f"A bus cannot go from Area {current_area.ID} to other areas. A Parking Area"
+                                            f" for standby arrival should be added."
+                                        )
                                         dict_of_events[start_time] = {
                                             "type": type(process).__name__,
                                             "area": current_area.ID,
@@ -782,9 +804,30 @@ def add_evaluation_to_database(
                                             "id": process.ID,
                                         }
                             case ProcessStatus.IN_PROGRESS:
-                                raise NotImplementedError(
-                                    f"Current process {process.ID} is in progress. Not implemented yet."
-                                )
+                                assert (
+                                    len(process.starts) == 1 and len(process.ends) == 0
+                                ), f"Current process {process.ID} is marked IN_PROGRESS, but has an end."
+                                current_area = area_log[start_time]
+                                current_slot = slot_log[start_time]
+
+                                if current_area is None or current_slot is None:
+                                    raise ValueError(
+                                        f"For process {process.ID} Area and slot should not be None."
+                                    )
+
+                                if process.dur > 0:
+                                    # Valid duration
+                                    dict_of_events[start_time] = {
+                                        "type": type(process).__name__,
+                                        "end": process.etc,
+                                        "area": current_area.ID,
+                                        "slot": current_slot,
+                                        "id": process.ID,
+                                    }
+                                else:
+                                    raise NotImplementedError(
+                                        "We believe this should never happen. If it happens, handle it here."
+                                    )
                             case ProcessStatus.WAITING:
                                 raise NotImplementedError(
                                     f"Current process {process.ID} is waiting. Not implemented yet."

{eflips_depot-3.0.0 → eflips_depot-3.0.2}/eflips/depot/api/private/depot.py

@@ -137,7 +137,7 @@ def depot_to_template(depot: Depot) -> Dict[str, str | Dict[str, str | int]]:
             "ismandatory": True,
             "vehicle_filter": {},
             # True if this process can be interrupted by a dispatch. False if it cannot be interrupted
-            "cancellable_for_dispatch": False,
+            "cancellable_for_dispatch": process.dispatchable,
         }
 
         match process_type(process):