isar 1.31.1__tar.gz → 1.32.0__tar.gz

{isar-1.31.1 → isar-1.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.31.1
+Version: 1.32.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.31.1 → isar-1.32.0}/src/isar/apis/api.py

@@ -245,6 +245,24 @@ class API:
                 },
             },
         )
+        router.add_api_route(
+            path="/schedule/release-intervention-needed",
+            endpoint=self.scheduling_controller.release_intervention_needed,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Release the intervention needed state",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Robot released from intervention needed state"
+                },
+                HTTPStatus.CONFLICT.value: {
+                    "description": "Conflict - Invalid command in the current state"
+                },
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error - Current state of state machine unknown"
+                },
+            },
+        )
         router.add_api_route(
             path="/schedule/move_arm/{arm_pose_literal}",
             endpoint=self.scheduling_controller.start_move_arm_mission,

{isar-1.31.1 → isar-1.32.0}/src/isar/apis/schedule/scheduling_controller.py

@@ -256,6 +256,22 @@ class SchedulingController:
         self.scheduling_utilities.start_mission(mission=mission)
         return self._api_response(mission)
 
+    def release_intervention_needed(self) -> None:
+        self.logger.info("Received request to release intervention needed state")
+
+        state: States = self.scheduling_utilities.get_state()
+
+        if state != States.InterventionNeeded:
+            error_message = f"Conflict - Release intervention needed command received in invalid state - State: {state}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
+            )
+
+        self.scheduling_utilities.release_intervention_needed()
+        self.logger.info("Released intervention needed state successfully")
+
     def _api_response(self, mission: Mission) -> StartMissionResponse:
         return StartMissionResponse(
             id=mission.id,

{isar-1.31.1 → isar-1.32.0}/src/isar/config/log.py

@@ -5,11 +5,10 @@ from importlib.resources import as_file, files
 import yaml
 from uvicorn.logging import ColourizedFormatter
 
-from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 
 
-def setup_loggers(keyvault: Keyvault) -> None:
+def setup_loggers() -> None:
     log_levels: dict = settings.LOG_LEVELS
     log_config = load_log_config()
 

isar-1.32.0/src/isar/config/logging.conf

@@ -0,0 +1,37 @@
+version: 1
+formatters:
+  simple:
+    format: '%(asctime)s - %(levelname)s - %(name)s - %(message)s'
+  colourized:
+    style: "{"
+    format: "{asctime} - {levelprefix:<8} - {name} - {message}"
+loggers:
+  console:
+    handlers: []
+    propagate: no
+  main:
+    handlers: []
+    propagate: no
+  api:
+    handlers: []
+    propagate: no
+  mqtt:
+    handlers: []
+    propagate: no
+  state_machine:
+    handlers: []
+    propagate: no
+  uploader:
+    handlers: []
+    propagate: no
+  urllib3:
+    handlers: []
+  uvicorn:
+    handlers: []
+    propagate: no
+  azure:
+    handlers: []
+    propagate: no
+root:
+  level: DEBUG
+  handlers: []

{isar-1.31.1 → isar-1.32.0}/src/isar/config/settings.py

@@ -224,6 +224,9 @@ class Settings(BaseSettings):
         default="robot_heartbeat", validate_default=True
     )
     TOPIC_ISAR_STARTUP: str = Field(default="startup", validate_default=True)
+    TOPIC_ISAR_INTERVENTION_NEEDED: str = Field(
+        default="intervention_needed", validate_default=True
+    )
 
     # Logging
 
@@ -275,6 +278,7 @@ class Settings(BaseSettings):
         "TOPIC_ISAR_INSPECTION_RESULT",
         "TOPIC_ISAR_INSPECTION_VALUE",
         "TOPIC_ISAR_STARTUP",
+        "TOPIC_ISAR_INTERVENTION_NEEDED",
     )
     @classmethod
     def prefix_isar_topics(cls, v: Any, info: ValidationInfo):

{isar-1.31.1 → isar-1.32.0}/src/isar/models/events.py

@@ -86,6 +86,7 @@ class APIRequests:
         self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
         self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
         self.return_home: APIEvent[bool, bool] = APIEvent()
+        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent()
 
 
 class StateMachineEvents:

{isar-1.31.1 → isar-1.32.0}/src/isar/script.py

@@ -36,7 +36,8 @@ def print_setting(
 
 
 def print_startup_info():
-    print(
+    logger: Logger = logging.getLogger("main")
+    logger.info(
         """
          __   ________   ___        ________
         / /  / ______/  /   |      / ____  /
@@ -48,21 +49,15 @@ def print_startup_info():
 """
     )
 
-    WIDTH = 48
-
     def print_setting(setting: str = "", value: Any = "", fillchar: str = " "):
         separator = ": " if value != "" else ""
-        text = setting.ljust(22, fillchar) + separator + str(value)
-        print("*", text.ljust(WIDTH - 4, fillchar), "*")
+        logger.info(setting + separator + str(value))
 
-    print("Integration and Supervisory control".center(WIDTH, " "))
-    print("of Autonomous Robots".center(WIDTH, " "))
-    print()
-    print(f"Version: {isar.__version__}\n".center(WIDTH, " "))
+    logger.info(
+        f"Integration and Supervisory control of Autonomous Robots - Version: {isar.__version__}\n"
+    )
 
-    print_setting(fillchar="*")
     print_setting("ISAR settings")
-    print_setting(fillchar="-")
     print_setting("Robot package", settings.ROBOT_PACKAGE)
     print_setting("Robot name", settings.ROBOT_NAME)
     print_setting("Running on port", settings.API_PORT)
@@ -74,17 +69,13 @@ def print_startup_info():
     print_setting("Plant code", settings.PLANT_CODE)
     print_setting("Plant name", settings.PLANT_NAME)
     print_setting("Plant shortname", settings.PLANT_SHORT_NAME)
-    print_setting(fillchar="-")
     print_setting("Robot capabilities", robot_settings.CAPABILITIES)
-    print_setting(fillchar="*")
-    print()
 
 
 def start() -> None:
     injector: ApplicationContainer = get_injector()
 
-    keyvault = injector.keyvault()
-    setup_loggers(keyvault=keyvault)
+    setup_loggers()
     setup_open_telemetry(app=injector.api().app)
     logger: Logger = logging.getLogger("main")
 

{isar-1.31.1 → isar-1.32.0}/src/isar/services/utilities/scheduling_utilities.py

@@ -290,6 +290,26 @@ class SchedulingUtilities:
         self.logger.info("OK - Mission successfully stopped")
         return stop_mission_response
 
+    def release_intervention_needed(self) -> None:
+        """Release intervention needed state
+
+        Raises
+        ------
+        HTTPException 500 Internal Server Error
+            If the intervention needed state could not be released
+        """
+        try:
+            self._send_command(True, self.api_events.release_intervention_needed)
+            self.logger.info("OK - Intervention needed state released")
+        except EventTimeoutError:
+            error_message = (
+                "Internal Server Error - Failed to release intervention needed state"
+            )
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
+
     def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
         api_event.input.trigger_event(input)
         try:

{isar-1.31.1 → isar-1.32.0}/src/isar/state_machine/state_machine.py

@@ -18,6 +18,7 @@ from isar.models.events import Events, SharedState
 from isar.state_machine.states.await_next_mission import AwaitNextMission
 from isar.state_machine.states.blocked_protective_stop import BlockedProtectiveStop
 from isar.state_machine.states.home import Home
+from isar.state_machine.states.intervention_needed import InterventionNeeded
 from isar.state_machine.states.monitor import Monitor
 from isar.state_machine.states.offline import Offline
 from isar.state_machine.states.paused import Paused
@@ -41,6 +42,7 @@ from robot_interface.models.mission.task import TASKS, InspectionTask, Task
 from robot_interface.robot_interface import RobotInterface
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from robot_interface.telemetry.payloads import (
+    InterventionNeededPayload,
     MissionPayload,
     RobotStatusPayload,
     TaskPayload,
@@ -101,6 +103,7 @@ class StateMachine(object):
         self.await_next_mission_state: State = AwaitNextMission(self)
         self.home_state: State = Home(self)
         self.robot_standing_still_state: State = RobotStandingStill(self)
+        self.intervention_needed_state: State = InterventionNeeded(self)
 
         # Status states
         self.offline_state: State = Offline(self)
@@ -120,6 +123,7 @@ class StateMachine(object):
             self.offline_state,
             self.blocked_protective_stopping_state,
             self.unknown_status_state,
+            self.intervention_needed_state,
         ]
 
         self.machine = Machine(
@@ -282,6 +286,25 @@ class StateMachine(object):
             retain=True,
         )
 
+    def publish_intervention_needed(self, error_message: str) -> None:
+        """Publishes the intervention needed message to the MQTT Broker"""
+        if not self.mqtt_publisher:
+            return
+
+        payload: InterventionNeededPayload = InterventionNeededPayload(
+            isar_id=settings.ISAR_ID,
+            robot_name=settings.ROBOT_NAME,
+            reason=error_message,
+            timestamp=datetime.now(timezone.utc),
+        )
+
+        self.mqtt_publisher.publish(
+            topic=settings.TOPIC_ISAR_INTERVENTION_NEEDED,
+            payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+            qos=1,
+            retain=True,
+        )
+
     def publish_status(self) -> None:
         if not self.mqtt_publisher:
             return
@@ -314,6 +337,8 @@ class StateMachine(object):
             return RobotStatus.Offline
         elif self.current_state == States.BlockedProtectiveStop:
             return RobotStatus.BlockedProtectiveStop
+        elif self.current_state == States.InterventionNeeded:
+            return RobotStatus.InterventionNeeded
         else:
             return RobotStatus.Busy
 

isar-1.32.0/src/isar/state_machine/states/intervention_needed.py

@@ -0,0 +1,43 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING, List, Optional
+
+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
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class InterventionNeeded(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def release_intervention_needed_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            if event.consume_event():
+                state_machine.events.api_requests.release_intervention_needed.output.trigger_event(
+                    True
+                )
+                return state_machine.release_intervention_needed  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="return_home_event",
+                event=events.api_requests.return_home.input,
+                handler=lambda event: return_home_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="release_intervention_needed_event",
+                event=events.api_requests.release_intervention_needed.input,
+                handler=release_intervention_needed_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="intervention_needed",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

{isar-1.31.1 → isar-1.32.0}/src/isar/state_machine/states_enum.py

@@ -12,6 +12,7 @@ class States(str, Enum):
     Offline = "offline"
     BlockedProtectiveStop = "blocked_protective_stop"
     UnknownStatus = "unknown_status"
+    InterventionNeeded = "intervention_needed"
 
     def __repr__(self):
         return self.value

{isar-1.31.1 → isar-1.32.0}/src/isar/state_machine/transitions/functions/fail_mission.py

@@ -11,3 +11,10 @@ def report_failed_mission_and_finalize(state_machine: "StateMachine") -> None:
     state_machine.current_mission.status = MissionStatus.Failed
     state_machine.publish_task_status(task=state_machine.current_task)
     state_machine._finalize()
+
+
+def report_failed_return_home_and_intervention_needed(
+    state_machine: "StateMachine",
+) -> None:
+    error_message: str = "Return home failed."
+    state_machine.publish_intervention_needed(error_message=error_message)

{isar-1.31.1 → isar-1.32.0}/src/isar/state_machine/transitions/mission.py

@@ -122,12 +122,6 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.home_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
-        {
-            "trigger": "request_mission_start",
-            "source": state_machine.returning_home_state,
-            "dest": state_machine.returning_home_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
-        },
         {
             "trigger": "mission_failed_to_start",
             "source": [state_machine.monitor_state, state_machine.returning_home_state],

{isar-1.31.1 → isar-1.32.0}/src/isar/state_machine/transitions/return_home.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, List
 
 from isar.state_machine.transitions.functions.fail_mission import (
     report_failed_mission_and_finalize,
+    report_failed_return_home_and_intervention_needed,
 )
 from isar.state_machine.transitions.functions.return_home import (
     return_home_finished,
@@ -26,6 +27,7 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
                 state_machine.await_next_mission_state,
                 state_machine.home_state,
                 state_machine.robot_standing_still_state,
+                state_machine.intervention_needed_state,
             ],
             "dest": state_machine.returning_home_state,
             "conditions": [
@@ -62,8 +64,18 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "return_home_failed",
             "source": state_machine.returning_home_state,
-            "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
+            "dest": state_machine.intervention_needed_state,
+            "before": [
+                def_transition(
+                    state_machine, report_failed_return_home_and_intervention_needed
+                ),
+                def_transition(state_machine, report_failed_mission_and_finalize),
+            ],
+        },
+        {
+            "trigger": "release_intervention_needed",
+            "source": state_machine.intervention_needed_state,
+            "dest": state_machine.unknown_status_state,
         },
     ]
     return return_home_transitions

{isar-1.31.1 → isar-1.32.0}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.31.1
+Version: 1.32.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.31.1 → isar-1.32.0}/src/isar.egg-info/SOURCES.txt

@@ -105,6 +105,7 @@ src/isar/state_machine/states/__init__.py
 src/isar/state_machine/states/await_next_mission.py
 src/isar/state_machine/states/blocked_protective_stop.py
 src/isar/state_machine/states/home.py
+src/isar/state_machine/states/intervention_needed.py
 src/isar/state_machine/states/monitor.py
 src/isar/state_machine/states/offline.py
 src/isar/state_machine/states/paused.py

{isar-1.31.1 → isar-1.32.0}/src/robot_interface/models/mission/status.py

@@ -29,3 +29,4 @@ class RobotStatus(Enum):
     Blocked = "blocked"
     BlockedProtectiveStop = "blockedprotectivestop"
     ReturningHome = "returninghome"
+    InterventionNeeded = "interventionneeded"

{isar-1.31.1 → isar-1.32.0}/src/robot_interface/telemetry/payloads.py

@@ -138,3 +138,11 @@ class InspectionValuePayload:
 class StartUpMessagePayload:
     isar_id: str
     timestamp: datetime
+
+
+@dataclass
+class InterventionNeededPayload:
+    isar_id: str
+    robot_name: str
+    reason: str
+    timestamp: datetime

{isar-1.31.1 → isar-1.32.0}/tests/isar/state_machine/test_state_machine.py

@@ -157,7 +157,7 @@ def test_state_machine_failed_dependency(
             States.Monitor,
             States.AwaitNextMission,
             States.ReturningHome,
-            States.RobotStandingStill,
+            States.InterventionNeeded,
         ]
     )
 

isar-1.31.1/src/isar/config/logging.conf

@@ -1,58 +0,0 @@
-version: 1
-formatters:
-  simple:
-    format: '%(asctime)s - %(levelname)s - %(name)s - %(message)s'
-  colourized:
-    style: "{"
-    format: "{asctime} - {levelprefix:<8} - {name} - {message}"
-handlers:
-  api:
-    class: logging.FileHandler
-    formatter: simple
-    filename: api.log
-  main:
-    class: logging.FileHandler
-    formatter: simple
-    filename: main.log
-  mqtt:
-    class: logging.FileHandler
-    formatter: simple
-    filename: mqtt.log
-  state_machine:
-    class: logging.FileHandler
-    formatter: simple
-    filename: state_machine.log
-  uploader:
-    class: logging.FileHandler
-    formatter: simple
-    filename: uploader.log
-loggers:
-  console:
-    handlers: []
-    propagate: no
-  main:
-    handlers: [main]
-    propagate: no
-  api:
-    handlers: [api]
-    propagate: no
-  mqtt:
-    handlers: [mqtt]
-    propagate: False
-  state_machine:
-    handlers: [state_machine]
-    propagate: False
-  uploader:
-    handlers: [uploader]
-    propagate: False
-  urllib3:
-    handlers: []
-  uvicorn:
-    handlers: [api]
-    propagate: no
-  azure:
-    handlers: []
-    propagate: no
-root:
-  level: DEBUG
-  handlers: []