isar 1.20.2__py3-none-any.whl → 1.34.9__py3-none-any.whl

isar/state_machine/states/__init__.py

@@ -1,8 +0,0 @@
-from .idle import Idle
-from .initialize import Initialize
-from .initiate import Initiate
-from .monitor import Monitor
-from .off import Off
-from .offline import Offline
-from .paused import Paused
-from .stop import Stop

isar/state_machine/states/await_next_mission.py

@@ -0,0 +1,114 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import LockdownResponse, MaintenanceResponse
+from isar.config.settings import settings
+from isar.eventhandlers.eventhandler import (
+    EventHandlerBase,
+    EventHandlerMapping,
+    TimeoutHandlerMapping,
+)
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import (
+    return_home_event_handler,
+    start_mission_event_handler,
+    stop_mission_event_handler,
+)
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class AwaitNextMission(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            state_machine.start_return_home_mission()
+            return state_machine.start_lockdown_mission_monitoring  # type: ignore
+
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
+                return None
+
+            state_machine.start_return_home_mission()
+            return state_machine.start_recharging_mission_monitoring  # type: ignore
+
+        def _set_maintenance_mode_event_handler(event: Event[bool]):
+            should_set_maintenande_mode: bool = event.consume_event()
+            if should_set_maintenande_mode:
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(is_maintenance_mode=True)
+                )
+                return state_machine.set_maintenance_mode  # type: ignore
+            return None
+
+        def _start_return_home():
+            state_machine.start_return_home_mission()
+            return state_machine.start_return_home_monitoring  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.request,
+                handler=lambda event: start_mission_event_handler(
+                    state_machine, event, events.api_requests.start_mission.response
+                ),
+            ),
+            EventHandlerMapping(
+                name="return_home_event",
+                event=events.api_requests.return_home.request,
+                handler=lambda event: return_home_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.return_home.request,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="set_maintenance_mode",
+                event=events.api_requests.set_maintenance_mode.request,
+                handler=_set_maintenance_mode_event_handler,
+            ),
+        ]
+
+        timers: List[TimeoutHandlerMapping] = [
+            TimeoutHandlerMapping(
+                name="should_return_home_timer",
+                timeout_in_seconds=settings.RETURN_HOME_DELAY,
+                handler=_start_return_home,
+            )
+        ]
+
+        super().__init__(
+            state_name="await_next_mission",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+            timers=timers,
+        )

isar/state_machine/states/blocked_protective_stop.py

@@ -0,0 +1,60 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import MaintenanceResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.mission.status import RobotStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class BlockedProtectiveStop(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _set_maintenance_mode_event_handler(event: Event[bool]):
+            should_set_maintenande_mode: bool = event.consume_event()
+            if should_set_maintenande_mode:
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(is_maintenance_mode=True)
+                )
+                return state_machine.set_maintenance_mode  # type: ignore
+            return None
+
+        def _robot_status_event_handler(
+            status_changed_event: Event[bool],
+        ) -> Optional[Callable]:
+            has_changed = status_changed_event.consume_event()
+            if not has_changed:
+                return None
+            robot_status: Optional[RobotStatus] = shared_state.robot_status.check()
+            if robot_status == RobotStatus.BlockedProtectiveStop:
+                return None
+            elif robot_status == RobotStatus.Home:
+                return state_machine.robot_status_home  # type: ignore
+            elif robot_status == RobotStatus.Available:
+                return state_machine.robot_status_available  # type: ignore
+            elif robot_status == RobotStatus.Offline:
+                return state_machine.robot_status_offline  # type: ignore
+            return state_machine.robot_status_unknown  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=events.robot_service_events.robot_status_changed,
+                handler=_robot_status_event_handler,
+            ),
+            EventHandlerMapping(
+                name="set_maintenance_mode",
+                event=events.api_requests.set_maintenance_mode.request,
+                handler=_set_maintenance_mode_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="blocked_protective_stop",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/going_to_lockdown.py

@@ -0,0 +1,95 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import mission_started_event_handler
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.status import MissionStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class GoingToLockdown(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _mission_failed_event_handler(
+            event: Event[Optional[ErrorMessage]],
+        ) -> Optional[Callable]:
+            mission_failed: Optional[ErrorMessage] = event.consume_event()
+            if mission_failed is None:
+                return None
+
+            state_machine.logger.warning(
+                f"Failed to go to lockdown because: "
+                f"{mission_failed.error_description}"
+            )
+            state_machine.publish_intervention_needed(
+                error_message="Lockdown mission failed."
+            )
+            return state_machine.lockdown_mission_failed  # type: ignore
+
+        def _mission_failed_to_resume_event_handler(
+            event: Event[Optional[ErrorMessage]],
+        ) -> Optional[Callable]:
+            mission_failed_to_resume: Optional[ErrorMessage] = event.consume_event()
+            if mission_failed_to_resume is None:
+                return None
+
+            state_machine.logger.warning(
+                f"Failed to resume return to home mission and going to lockdown because: "
+                f"{mission_failed_to_resume.error_description or ''}"
+            )
+            return state_machine.lockdown_mission_failed  # type: ignore
+
+        def _mission_status_event_handler(
+            event: Event[MissionStatus],
+        ) -> Optional[Callable]:
+            mission_status: Optional[MissionStatus] = event.consume_event()
+
+            if mission_status and mission_status not in [
+                MissionStatus.InProgress,
+                MissionStatus.NotStarted,
+                MissionStatus.Paused,
+            ]:
+                if mission_status != MissionStatus.Successful:
+                    state_machine.publish_intervention_needed(
+                        error_message="Lockdown mission failed."
+                    )
+                    return state_machine.lockdown_mission_failed  # type: ignore
+
+                state_machine.print_transitions()
+                return state_machine.reached_lockdown  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="mission_started_event",
+                event=events.robot_service_events.mission_started,
+                handler=lambda event: mission_started_event_handler(
+                    state_machine, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="mission_failed_event",
+                event=events.robot_service_events.mission_failed,
+                handler=_mission_failed_event_handler,
+            ),
+            EventHandlerMapping(
+                name="mission_failed_to_resume",
+                event=events.robot_service_events.mission_failed_to_resume,
+                handler=_mission_failed_to_resume_event_handler,
+            ),
+            EventHandlerMapping(
+                name="mission_status_event",
+                event=events.robot_service_events.mission_status_updated,
+                handler=_mission_status_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="going_to_lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/going_to_recharging.py

@@ -0,0 +1,92 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import LockdownResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.status import MissionStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class GoingToRecharging(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _mission_failed_event_handler(
+            event: Event[Optional[ErrorMessage]],
+        ) -> Optional[Callable]:
+            mission_failed: Optional[ErrorMessage] = event.consume_event()
+            if mission_failed is None:
+                return None
+
+            state_machine.logger.warning(
+                f"Failed to go to recharging because: "
+                f"{mission_failed.error_description}"
+            )
+            state_machine.publish_intervention_needed(
+                error_message="Return home to recharge failed."
+            )
+            state_machine.print_transitions()
+            return state_machine.return_home_failed  # type: ignore
+
+        def _mission_status_event_handler(
+            event: Event[MissionStatus],
+        ) -> Optional[Callable]:
+            mission_status: Optional[MissionStatus] = event.consume_event()
+
+            if not mission_status or mission_status in [
+                MissionStatus.InProgress,
+                MissionStatus.NotStarted,
+                MissionStatus.Paused,
+            ]:
+                return None
+
+            if mission_status != MissionStatus.Successful:
+                state_machine.logger.warning(
+                    "Failed to return home. Mission reported as failed."
+                )
+                state_machine.publish_intervention_needed(
+                    error_message="Return home to recharge failed."
+                )
+                state_machine.print_transitions()
+                return state_machine.return_home_failed  # type: ignore
+
+            return state_machine.starting_recharging  # type: ignore
+
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.go_to_lockdown  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="mission_failed_event",
+                event=events.robot_service_events.mission_failed,
+                handler=_mission_failed_event_handler,
+            ),
+            EventHandlerMapping(
+                name="mission_status_event",
+                event=events.robot_service_events.mission_status_updated,
+                handler=_mission_status_event_handler,
+            ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="going_to_recharging",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/home.py

@@ -0,0 +1,115 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import LockdownResponse, MaintenanceResponse
+from isar.config.settings import settings
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import (
+    return_home_event_handler,
+    start_mission_event_handler,
+    stop_mission_event_handler,
+)
+from robot_interface.models.mission.status import RobotStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Home(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _send_to_lockdown_event_handler(event: Event[bool]):
+            should_send_robot_home: bool = event.consume_event()
+            if not should_send_robot_home:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.reached_lockdown  # type: ignore
+
+        def _set_maintenance_mode_event_handler(event: Event[bool]):
+            should_set_maintenande_mode: bool = event.consume_event()
+            if should_set_maintenande_mode:
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(is_maintenance_mode=True)
+                )
+                return state_machine.set_maintenance_mode  # type: ignore
+            return None
+
+        def _robot_status_event_handler(
+            status_changed_event: Event[bool],
+        ) -> Optional[Callable]:
+            has_changed = status_changed_event.consume_event()
+            if not has_changed:
+                return None
+            robot_status: Optional[RobotStatus] = shared_state.robot_status.check()
+            if robot_status == RobotStatus.Home:
+                return None
+            elif robot_status == RobotStatus.Available:
+                return state_machine.robot_status_available  # type: ignore
+            elif robot_status == RobotStatus.Offline:
+                return state_machine.robot_status_offline  # type: ignore
+            elif robot_status == RobotStatus.BlockedProtectiveStop:
+                return state_machine.robot_status_blocked_protective_stop  # type: ignore
+            return state_machine.robot_status_unknown  # type: ignore
+
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
+                return None
+
+            return state_machine.starting_recharging  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.request,
+                handler=lambda event: start_mission_event_handler(
+                    state_machine, event, events.api_requests.start_mission.response
+                ),
+            ),
+            EventHandlerMapping(
+                name="return_home_event",
+                event=events.api_requests.return_home.request,
+                handler=lambda event: return_home_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.return_home.request,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=events.robot_service_events.robot_status_changed,
+                handler=_robot_status_event_handler,
+            ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="set_maintenance_mode",
+                event=events.api_requests.set_maintenance_mode.request,
+                handler=_set_maintenance_mode_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/intervention_needed.py

@@ -0,0 +1,77 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING, List, Optional
+
+from isar.apis.models.models import MaintenanceResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import return_home_event_handler
+from robot_interface.models.mission.status import RobotStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class InterventionNeeded(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _set_maintenance_mode_event_handler(event: Event[bool]):
+            should_set_maintenande_mode: bool = event.consume_event()
+            if should_set_maintenande_mode:
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(is_maintenance_mode=True)
+                )
+                return state_machine.set_maintenance_mode  # type: ignore
+            return None
+
+        def release_intervention_needed_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
+
+            state_machine.events.api_requests.release_intervention_needed.response.trigger_event(
+                True
+            )
+            return state_machine.release_intervention_needed  # type: ignore
+
+        def _robot_status_event_handler(
+            status_changed_event: Event[bool],
+        ) -> Optional[Callable]:
+            has_changed = status_changed_event.consume_event()
+            if not has_changed:
+                return None
+            robot_status: Optional[RobotStatus] = shared_state.robot_status.check()
+            if robot_status == RobotStatus.Home:
+                return state_machine.go_to_home  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="return_home_event",
+                event=events.api_requests.return_home.request,
+                handler=lambda event: return_home_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="release_intervention_needed_event",
+                event=events.api_requests.release_intervention_needed.request,
+                handler=release_intervention_needed_handler,
+            ),
+            EventHandlerMapping(
+                name="set_maintenance_mode",
+                event=events.api_requests.set_maintenance_mode.request,
+                handler=_set_maintenance_mode_event_handler,
+            ),
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=events.robot_service_events.robot_status_changed,
+                handler=_robot_status_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="intervention_needed",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/lockdown.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING, List
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Lockdown(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _release_from_lockdown_handler(event: Event[bool]):
+            should_release_from_lockdown: bool = event.consume_event()
+            if not should_release_from_lockdown:
+                return None
+
+            events.api_requests.release_from_lockdown.response.trigger_event(True)
+            if state_machine.battery_level_is_above_mission_start_threshold():
+                return state_machine.release_from_lockdown  # type: ignore
+            else:
+                return state_machine.starting_recharging  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="release_from_lockdown",
+                event=events.api_requests.release_from_lockdown.request,
+                handler=_release_from_lockdown_handler,
+            ),
+        ]
+
+        super().__init__(
+            state_name="lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/maintenance.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING, List
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Maintenance(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _release_from_maintenance_handler(event: Event[bool]):
+            should_release_from_maintenance: bool = event.consume_event()
+            if should_release_from_maintenance:
+                events.api_requests.release_from_maintenance_mode.response.trigger_event(
+                    True
+                )
+                return state_machine.release_from_maintenance  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="release_from_maintenance",
+                event=events.api_requests.release_from_maintenance_mode.request,
+                handler=_release_from_maintenance_handler,
+            ),
+        ]
+
+        super().__init__(
+            state_name="maintenance",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )