isar 1.10.14__py3-none-any.whl → 1.12.0__py3-none-any.whl

isar/state_machine/states/idle.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Optional
+from typing import Optional, TYPE_CHECKING
 
 from transitions import State
 
@@ -11,19 +11,19 @@ if TYPE_CHECKING:
 
 
 class Idle(State):
-    def __init__(self, state_machine: "StateMachine"):
+    def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="idle", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
 
-    def start(self):
+    def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
-    def stop(self):
+    def stop(self) -> None:
         pass
 
-    def _run(self):
+    def _run(self) -> None:
         while True:
             start_mission: Optional[
                 StartMissionMessage
@@ -33,7 +33,7 @@ class Idle(State):
                     mission=start_mission.mission,
                     initial_pose=start_mission.initial_pose,
                 )
-                transition = self.state_machine.mission_started
+                transition = self.state_machine.mission_started  # type: ignore
                 break
             time.sleep(self.state_machine.sleep_time)
 

isar/state_machine/states/initialize.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Callable, Optional
+from typing import Callable, Optional, TYPE_CHECKING
 
 from injector import inject
 from transitions import State
@@ -17,23 +17,23 @@ if TYPE_CHECKING:
 
 class Initialize(State):
     @inject
-    def __init__(self, state_machine: "StateMachine"):
+    def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="initialize", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
 
         self.logger = logging.getLogger("state_machine")
         self.initialize_thread: Optional[ThreadedRequest] = None
 
-    def start(self):
+    def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
-    def stop(self):
+    def stop(self) -> None:
         if self.initialize_thread:
             self.initialize_thread.wait_for_thread()
         self.initialize_thread = None
 
-    def _run(self):
+    def _run(self) -> None:
         transition: Callable
         while True:
             if not self.initialize_thread:
@@ -41,7 +41,8 @@ class Initialize(State):
                     self.state_machine.robot.initialize
                 )
                 self.initialize_thread.start_thread(
-                    self.state_machine.get_initialize_params()
+                    self.state_machine.get_initialize_params(),
+                    name="State Machine Initialize Robot",
                 )
 
             try:
@@ -51,9 +52,9 @@ class Initialize(State):
                 continue
             except RobotException as e:
                 self.logger.error(f"Initialization of robot failed. Error: {e}")
-                transition = self.state_machine.initialization_failed
+                transition = self.state_machine.initialization_failed  # type: ignore
                 break
 
-            transition = self.state_machine.initialization_successful
+            transition = self.state_machine.initialization_successful  # type: ignore
             break
         transition()

isar/state_machine/states/initiate_step.py

@@ -1,28 +1,25 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Callable
+from typing import Callable, Optional, TYPE_CHECKING
 
 from transitions import State
 
 from isar.config.settings import settings
-from isar.models.mission.status import MissionStatus
 from isar.services.utilities.threaded_request import (
     ThreadedRequest,
     ThreadedRequestNotFinishedError,
 )
-from isar.state_machine.states_enum import States
 from robot_interface.models.exceptions import (
     RobotException,
     RobotInfeasibleStepException,
 )
-from robot_interface.models.mission.status import StepStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
 class InitiateStep(State):
-    def __init__(self, state_machine: "StateMachine"):
+    def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="initiate_step", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
         self.initiate_step_failure_counter: int = 0
@@ -31,45 +28,48 @@ class InitiateStep(State):
         )
         self.logger = logging.getLogger("state_machine")
 
-        self.initiate_step_thread = None
+        self.initiate_step_thread: Optional[ThreadedRequest] = None
 
-    def start(self):
+    def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
-    def stop(self):
+    def stop(self) -> None:
         self.initiate_step_failure_counter = 0
         if self.initiate_step_thread:
             self.initiate_step_thread.wait_for_thread()
         self.initiate_step_thread = None
 
-    def _run(self):
+    def _run(self) -> None:
         transition: Callable
         while True:
             if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop
+                transition = self.state_machine.stop  # type: ignore
                 break
 
             if self.state_machine.should_pause_mission():
-                transition = self.state_machine.pause
+                transition = self.state_machine.pause  # type: ignore
                 break
 
             if not self.state_machine.current_task:
                 self.logger.info(
                     f"Completed mission: {self.state_machine.current_mission.id}"
                 )
-                transition = self.state_machine.mission_finished
+                transition = self.state_machine.mission_finished  # type: ignore
                 break
 
             if not self.initiate_step_thread:
                 self.initiate_step_thread = ThreadedRequest(
                     self.state_machine.robot.initiate_step
                 )
-                self.initiate_step_thread.start_thread(self.state_machine.current_step)
+                self.initiate_step_thread.start_thread(
+                    self.state_machine.current_step,
+                    name="State Machine Initiate Step",
+                )
 
             try:
                 self.initiate_step_thread.get_output()
-                transition = self.state_machine.step_initiated
+                transition = self.state_machine.step_initiated  # type: ignore
                 break
             except ThreadedRequestNotFinishedError:
                 time.sleep(self.state_machine.sleep_time)
@@ -80,7 +80,7 @@ class InitiateStep(State):
                     f"{type(self.state_machine.current_step).__name__}"
                     f"Invalid step: {str(self.state_machine.current_step.id)[:8]}"
                 )
-                transition = self.state_machine.step_infeasible
+                transition = self.state_machine.step_infeasible  # type: ignore
                 break
             except RobotException as e:
                 self.initiate_step_thread = None
@@ -100,7 +100,7 @@ class InitiateStep(State):
                     f"{self.initiate_step_failure_counter_limit} attempts. "
                     f"Cancelling mission."
                 )
-                transition = self.state_machine.initiate_step_failed
+                transition = self.state_machine.initiate_step_failed  # type: ignore
                 break
 
             time.sleep(self.state_machine.sleep_time)

isar/state_machine/states/monitor.py

@@ -1,7 +1,7 @@
 import logging
 import time
 from copy import deepcopy
-from typing import TYPE_CHECKING, Callable, Optional, Sequence, Tuple
+from typing import Callable, Optional, Sequence, TYPE_CHECKING, Tuple
 
 from injector import inject
 from transitions import State
@@ -21,38 +21,40 @@ if TYPE_CHECKING:
 
 class Monitor(State):
     @inject
-    def __init__(self, state_machine: "StateMachine"):
+    def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="monitor", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
 
         self.logger = logging.getLogger("state_machine")
         self.step_status_thread: Optional[ThreadedRequest] = None
 
-    def start(self):
+    def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
-    def stop(self):
+    def stop(self) -> None:
         if self.step_status_thread:
             self.step_status_thread.wait_for_thread()
         self.step_status_thread = None
 
-    def _run(self):
+    def _run(self) -> None:
         transition: Callable
         while True:
             if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop
+                transition = self.state_machine.stop  # type: ignore
                 break
 
             if self.state_machine.should_pause_mission():
-                transition = self.state_machine.pause
+                transition = self.state_machine.pause  # type: ignore
                 break
 
             if not self.step_status_thread:
                 self.step_status_thread = ThreadedRequest(
                     self.state_machine.robot.step_status
                 )
-                self.step_status_thread.start_thread()
+                self.step_status_thread.start_thread(
+                    name="State Machine Monitor Current Step"
+                )
 
             try:
                 step_status: StepStatus = self.step_status_thread.get_output()
@@ -65,8 +67,12 @@ class Monitor(State):
             self.state_machine.current_step.status = step_status
 
             if self._step_finished(step=self.state_machine.current_step):
-                self._process_finished_step(step=self.state_machine.current_step)
-                transition = self.state_machine.step_finished
+                get_inspections_thread = ThreadedRequest(self._process_finished_step)
+                get_inspections_thread.start_thread(
+                    self.state_machine.current_step,
+                    name="State Machine Get Inspections",
+                )
+                transition = self.state_machine.step_finished  # type: ignore
                 break
 
             self.step_status_thread = None
@@ -74,7 +80,7 @@ class Monitor(State):
 
         transition()
 
-    def _queue_inspections_for_upload(self, current_step: InspectionStep):
+    def _queue_inspections_for_upload(self, current_step: InspectionStep) -> None:
         try:
             inspections: Sequence[
                 Inspection

isar/state_machine/states/paused.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Callable
+from typing import Callable, TYPE_CHECKING
 
 from transitions import State
 
@@ -9,24 +9,24 @@ if TYPE_CHECKING:
 
 
 class Paused(State):
-    def __init__(self, state_machine: "StateMachine"):
+    def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="paused", on_enter=self.start)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
 
-    def start(self):
+    def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
-    def _run(self):
+    def _run(self) -> None:
         transition: Callable
         while True:
             if self.state_machine.should_stop_mission():
-                transition = self.state_machine.mission_stopped
+                transition = self.state_machine.mission_stopped  # type: ignore
                 break
 
             if self.state_machine.should_resume_mission():
-                transition = self.state_machine.resume
+                transition = self.state_machine.resume  # type: ignore
                 break
 
             time.sleep(self.state_machine.sleep_time)

isar/state_machine/states/stop_step.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import Callable, TYPE_CHECKING
+from typing import Callable, Optional, TYPE_CHECKING
 
 from transitions import State
 
@@ -15,29 +15,29 @@ if TYPE_CHECKING:
 
 
 class StopStep(State):
-    def __init__(self, state_machine: "StateMachine"):
+    def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="stop_step", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
-        self.stop_thread = None
+        self.stop_thread: Optional[ThreadedRequest] = None
         self._count_number_retries: int = 0
 
-    def start(self):
+    def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
-    def stop(self):
+    def stop(self) -> None:
         if self.stop_thread:
             self.stop_thread.wait_for_thread()
         self.stop_thread = None
         self._count_number_retries = 0
 
-    def _run(self):
+    def _run(self) -> None:
         transition: Callable
         while True:
             if not self.stop_thread:
                 self.stop_thread = ThreadedRequest(self.state_machine.robot.stop)
-                self.stop_thread.start_thread()
+                self.stop_thread.start_thread(name="State Machine Stop Robot")
 
             if self.state_machine.should_stop_mission():
                 self.state_machine.stopped = True
@@ -52,16 +52,16 @@ class StopStep(State):
                 if self.handle_stop_fail(
                     retry_limit=self.state_machine.stop_robot_attempts_limit
                 ):
-                    transition = self.state_machine.mission_stopped
+                    transition = self.state_machine.mission_stopped  # type: ignore
                     break
 
                 self.logger.warning("Failed to stop robot. Retrying.")
                 self.stop_thread = None
                 continue
             if self.state_machine.stopped:
-                transition = self.state_machine.mission_stopped
+                transition = self.state_machine.mission_stopped  # type: ignore
             else:
-                transition = self.state_machine.mission_paused
+                transition = self.state_machine.mission_paused  # type: ignore
             break
 
         transition()

isar/state_machine/states_enum.py

@@ -2,7 +2,6 @@ from enum import Enum
 
 
 class States(str, Enum):
-
     Off = "off"
     Idle = "idle"
     InitiateStep = "initiate_step"

isar/storage/local_storage.py

@@ -9,11 +9,11 @@ from robot_interface.models.inspection.inspection import Inspection
 
 
 class LocalStorage(StorageInterface):
-    def __init__(self):
+    def __init__(self) -> None:
         self.root_folder: Path = Path(settings.LOCAL_STORAGE_PATH)
         self.logger = logging.getLogger("uploader")
 
-    def store(self, inspection: Inspection, metadata: MissionMetadata):
+    def store(self, inspection: Inspection, metadata: MissionMetadata) -> None:
         local_path, local_metadata_path = construct_local_paths(
             inspection=inspection, metadata=metadata
         )

isar/storage/slimm_storage.py

@@ -1,3 +1,4 @@
+import json
 import logging
 
 from azure.identity import DefaultAzureCredential
@@ -10,8 +11,8 @@ from isar.models.mission_metadata.mission_metadata import MissionMetadata
 from isar.services.auth.azure_credentials import AzureCredentials
 from isar.services.service_connections.request_handler import RequestHandler
 from isar.storage.storage_interface import StorageException, StorageInterface
-from isar.storage.utilities import get_filename, get_inspection_type
-from robot_interface.models.inspection.inspection import Inspection
+from isar.storage.utilities import get_filename
+from robot_interface.models.inspection.inspection import Inspection, ThermalVideo, Video
 
 
 class SlimmStorage(StorageInterface):
@@ -31,40 +32,60 @@ class SlimmStorage(StorageInterface):
         self.url: str = settings.SLIMM_API_URL
 
     def store(self, inspection: Inspection, metadata: MissionMetadata):
-        token: str = self.credentials.get_token(self.request_scope).token
-
-        request_url: str = f"{self.url}/UploadSingleFile"
-
-        inspection_type: str = get_inspection_type(inspection=inspection)
         filename: str = get_filename(
             mission_id=metadata.mission_id,
-            inspection_type=inspection_type,
+            inspection_type=type(inspection).__name__,
             inspection_id=inspection.id,
         )
-        filename_with_ending: str = f"{filename}.{inspection.metadata.file_type}"
+        filename = f"{filename}.{inspection.metadata.file_type}"
+        if type(inspection) in [Video, ThermalVideo]:
+            self._store_video(filename, inspection, metadata)
+        else:
+            self._store_image(filename, inspection, metadata)
 
-        multiform_body: MultipartEncoder = self._construct_multiform_request(
-            filename=filename_with_ending, inspection=inspection, metadata=metadata
+    def _store_image(
+        self, filename: str, inspection: Inspection, metadata: MissionMetadata
+    ):
+        multiform_body: MultipartEncoder = self._construct_multiform_request_image(
+            filename=filename, inspection=inspection, metadata=metadata
+        )
+        request_url: str = f"{self.url}/UploadSingleImage"
+        self._ingest(
+            inspection=inspection,
+            multiform_body=multiform_body,
+            request_url=request_url,
         )
+        return
 
+    def _store_video(
+        self, filename: str, inspection: Inspection, metadata: MissionMetadata
+    ):
+        multiform_body: MultipartEncoder = self._construct_multiform_request_video(
+            filename=filename, inspection=inspection, metadata=metadata
+        )
+        request_url = f"{self.url}/UploadSingleVideo"
         self._ingest(
             inspection=inspection,
             multiform_body=multiform_body,
             request_url=request_url,
-            token=token,
         )
+        return
 
-    def _ingest(self, inspection, multiform_body, request_url, token):
+    def _ingest(
+        self, inspection: Inspection, multiform_body: MultipartEncoder, request_url: str
+    ):
+        token: str = self.credentials.get_token(self.request_scope).token
         try:
-            self.request_handler.post(
+            response = self.request_handler.post(
                 url=request_url,
-                params={"DataType": "still"},
                 data=multiform_body,
                 headers={
                     "Authorization": f"Bearer {token}",
                     "Content-Type": multiform_body.content_type,
                 },
             )
+            guid = json.loads(response.text)["guid"]
+            self.logger.info(f"SLIMM upload GUID: {guid}")
         except (RequestException, HTTPError) as e:
             self.logger.warning(
                 f"Failed to upload inspection: {inspection.id} to SLIMM due to a "
@@ -73,48 +94,93 @@ class SlimmStorage(StorageInterface):
             raise StorageException from e
 
     @staticmethod
-    def _construct_multiform_request(filename, inspection, metadata):
+    def _construct_multiform_request_image(
+        filename: str, inspection: Inspection, metadata: MissionMetadata
+    ):
         array_of_orientation = (
             inspection.metadata.time_indexed_pose.pose.orientation.to_quat_array().tolist()
         )
         multiform_body: MultipartEncoder = MultipartEncoder(
             fields={
-                "SchemaMetadata.Mission.MissionId": metadata.mission_id,
-                "SchemaMetadata.Mission.StartDate": metadata.mission_date.isoformat(),
-                "SchemaMetadata.Mission.EndDate": metadata.mission_date.isoformat(),
-                "SchemaMetadata.Geodetic.CoordinateReferenceSystemCode": metadata.coordinate_reference_system,  # noqa: E501
-                "SchemaMetadata.Geodetic.VerticalCoordinateReferenceSystemCode": metadata.vertical_reference_system,  # noqa: E501
-                "SchemaMetadata.Geodetic.OrientationReferenceSystem": metadata.media_orientation_reference_system,  # noqa: E501
-                "SchemaMetadata.SensorCarrier.Id": metadata.robot_id,
-                "SchemaMetadata.InternalClassification": metadata.data_classification,
-                "SchemaMetadata.PlantFacilitySAPCode": metadata.plant_code,
-                "SchemaMetadata.Mission.Client": "Equinor",
-                "SchemaMetadata.IsoCountryCode": "NO",
-                "AttachedFileMetadata.X": str(
+                "PlantFacilitySAPCode": metadata.plant_code,
+                "InstCode": metadata.plant_short_name,
+                "InternalClassification": metadata.data_classification,
+                "IsoCountryCode": "NO",
+                "Geodetic.CoordinateReferenceSystemCode": metadata.coordinate_reference_system,  # noqa: E501
+                "Geodetic.VerticalCoordinateReferenceSystemCode": metadata.vertical_reference_system,  # noqa: E501
+                "Geodetic.OrientationReferenceSystem": metadata.media_orientation_reference_system,  # noqa: E501
+                "SensorCarrier.SensorCarrierId": metadata.robot_id,
+                "SensorCarrier.ModelName": metadata.robot_model,
+                "Mission.MissionId": metadata.mission_id,
+                "Mission.Client": "Equinor",
+                "ImageMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
+                "ImageMetadata.X": str(
                     inspection.metadata.time_indexed_pose.pose.position.x
                 ),
-                "AttachedFileMetadata.Y": str(
+                "ImageMetadata.Y": str(
                     inspection.metadata.time_indexed_pose.pose.position.y
                 ),
-                "AttachedFileMetadata.Z": str(
+                "ImageMetadata.Y": str(
                     inspection.metadata.time_indexed_pose.pose.position.z
                 ),
-                "AttachedFileMetadata.CameraOrientation[0]": str(
-                    array_of_orientation[0]
-                ),
-                "AttachedFileMetadata.CameraOrientation[1]": str(
-                    array_of_orientation[1]
+                "ImageMetadata.CameraOrientation1": str(array_of_orientation[0]),
+                "ImageMetadata.CameraOrientation2": str(array_of_orientation[1]),
+                "ImageMetadata.CameraOrientation3": str(array_of_orientation[2]),
+                "ImageMetadata.CameraOrientation4": str(array_of_orientation[3]),
+                "ImageMetadata.AnalysisMethods": str(inspection.metadata.analysis),
+                "ImageMetadata.Description": str(inspection.metadata.additional),
+                "ImageMetadata.FunctionalLocation": inspection.metadata.tag_id  # noqa: E501
+                if inspection.metadata.tag_id
+                else "NA",
+                "Filename": filename,
+                "AttachedFile": (filename, inspection.data),
+            }
+        )
+        return multiform_body
+
+    @staticmethod
+    def _construct_multiform_request_video(
+        filename: str,
+        inspection: Inspection,
+        metadata: MissionMetadata,
+    ):
+        array_of_orientation = (
+            inspection.metadata.time_indexed_pose.pose.orientation.to_quat_array().tolist()
+        )
+        multiform_body: MultipartEncoder = MultipartEncoder(
+            fields={
+                "PlantFacilitySAPCode": metadata.plant_code,
+                "InstCode": metadata.plant_short_name,
+                "InternalClassification": metadata.data_classification,
+                "IsoCountryCode": "NO",
+                "Geodetic.CoordinateReferenceSystemCode": metadata.coordinate_reference_system,  # noqa: E501
+                "Geodetic.VerticalCoordinateReferenceSystemCode": metadata.vertical_reference_system,  # noqa: E501
+                "Geodetic.OrientationReferenceSystem": metadata.media_orientation_reference_system,  # noqa: E501
+                "SensorCarrier.SensorCarrierId": metadata.robot_id,
+                "SensorCarrier.ModelName": metadata.robot_model,
+                "Mission.MissionId": metadata.mission_id,
+                "Mission.Client": "Equinor",
+                "VideoMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
+                "VideoMetadata.Duration": str(inspection.metadata.duration),  # type: ignore
+                "VideoMetadata.X": str(
+                    inspection.metadata.time_indexed_pose.pose.position.x
                 ),
-                "AttachedFileMetadata.CameraOrientation[2]": str(
-                    array_of_orientation[2]
+                "VideoMetadata.Y": str(
+                    inspection.metadata.time_indexed_pose.pose.position.y
                 ),
-                "AttachedFileMetadata.CameraOrientation[3]": str(
-                    array_of_orientation[3]
+                "VideoMetadata.Y": str(
+                    inspection.metadata.time_indexed_pose.pose.position.z
                 ),
-                "AttachedFileMetadata.FunctionalLocation": inspection.metadata.tag_id  # noqa: E501
+                "VideoMetadata.CameraOrientation1": str(array_of_orientation[0]),
+                "VideoMetadata.CameraOrientation2": str(array_of_orientation[1]),
+                "VideoMetadata.CameraOrientation3": str(array_of_orientation[2]),
+                "VideoMetadata.CameraOrientation4": str(array_of_orientation[3]),
+                "VideoMetadata.AnalysisMethods": str(inspection.metadata.analysis),
+                "VideoMetadata.Description": str(inspection.metadata.additional),
+                "VideoMetadata.FunctionalLocation": inspection.metadata.tag_id  # noqa: E501
                 if inspection.metadata.tag_id
                 else "NA",
-                "AttachedFileMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
+                "Filename": filename,
                 "AttachedFile": (filename, inspection.data),
             }
         )

isar/storage/uploader.py

@@ -4,11 +4,10 @@ from datetime import datetime, timedelta
 from queue import Empty, Queue
 from typing import List
 
-from robot_interface.models.inspection.inspection import Inspection
-
 from isar.config.settings import settings
 from isar.models.mission_metadata.mission_metadata import MissionMetadata
 from isar.storage.storage_interface import StorageException, StorageInterface
+from robot_interface.models.inspection.inspection import Inspection
 
 
 @dataclass
@@ -19,7 +18,7 @@ class UploaderQueueItem:
     _retry_count: int
     _next_retry_time: datetime = datetime.utcnow()
 
-    def increment_retry(self, max_wait_time: int):
+    def increment_retry(self, max_wait_time: int) -> None:
         self._retry_count += 1
         seconds_until_retry: int = min(2**self._retry_count, max_wait_time)
         self._next_retry_time = datetime.utcnow() + timedelta(
@@ -85,7 +84,7 @@ class Uploader:
             except Empty:
                 continue
 
-    def _upload(self, upload_item: UploaderQueueItem):
+    def _upload(self, upload_item: UploaderQueueItem) -> None:
         try:
             upload_item.storage_handler.store(
                 inspection=upload_item.inspection, metadata=upload_item.mission_metadata
@@ -112,7 +111,7 @@ class Uploader:
                     f"{str(upload_item.inspection.id)[:8]}. Aborting upload."
                 )
 
-    def _process_upload_queue(self):
+    def _process_upload_queue(self) -> None:
         ready_items: List[UploaderQueueItem] = [
             x for x in self._internal_upload_queue if x.is_ready_for_upload()
         ]