s2-python 0.0.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

s2python/reception_status_awaiter.py

@@ -0,0 +1,60 @@
+"""ReceptationStatusAwaiter class which notifies any coroutine waiting for a certain reception status message.
+
+Copied from
+https://github.com/flexiblepower/s2-analyzer/blob/main/backend/s2_analyzer_backend/reception_status_awaiter.py under
+Apache2 license on 31-08-2024.
+"""
+
+import asyncio
+import uuid
+from typing import Dict
+
+from s2python.common import ReceptionStatus
+
+
+class ReceptionStatusAwaiter:
+    received: Dict[uuid.UUID, ReceptionStatus]
+    awaiting: Dict[uuid.UUID, asyncio.Event]
+
+    def __init__(self) -> None:
+        self.received = {}
+        self.awaiting = {}
+
+    async def wait_for_reception_status(
+        self, message_id: uuid.UUID, timeout_reception_status: float
+    ) -> ReceptionStatus:
+        if message_id in self.received:
+            reception_status = self.received[message_id]
+        else:
+            if message_id in self.awaiting:
+                received_event = self.awaiting[message_id]
+            else:
+                received_event = asyncio.Event()
+                self.awaiting[message_id] = received_event
+
+            await asyncio.wait_for(received_event.wait(), timeout_reception_status)
+            reception_status = self.received[message_id]
+
+            if message_id in self.awaiting:
+                del self.awaiting[message_id]
+
+        return reception_status
+
+    async def receive_reception_status(self, reception_status: ReceptionStatus) -> None:
+        if not isinstance(reception_status, ReceptionStatus):
+            raise RuntimeError(
+                f"Expected a ReceptionStatus but received message {reception_status}"
+            )
+
+        if reception_status.subject_message_id in self.received:
+            raise RuntimeError(
+                f"ReceptationStatus for message_subject_id {reception_status.subject_message_id} has already "
+                f"been received!"
+            )
+
+        self.received[reception_status.subject_message_id] = reception_status
+        awaiting = self.awaiting.get(reception_status.subject_message_id)
+
+        if awaiting:
+            awaiting.set()
+            del self.awaiting[reception_status.subject_message_id]

s2python/s2_connection.py

@@ -0,0 +1,470 @@
+import asyncio
+import json
+import logging
+import threading
+import uuid
+from dataclasses import dataclass
+from typing import Optional, List, Type, Dict, Callable, Awaitable, Union
+
+from websockets.asyncio.client import ClientConnection as WSConnection, connect as ws_connect
+
+from s2python.common import (
+    ReceptionStatusValues,
+    ReceptionStatus,
+    Handshake,
+    EnergyManagementRole,
+    Role,
+    HandshakeResponse,
+    ResourceManagerDetails,
+    Duration,
+    Currency,
+    SelectControlType,
+)
+from s2python.generated.gen_s2 import CommodityQuantity
+from s2python.reception_status_awaiter import ReceptionStatusAwaiter
+from s2python.s2_control_type import S2ControlType
+from s2python.s2_parser import S2Parser
+from s2python.s2_validation_error import S2ValidationError
+from s2python.validate_values_mixin import S2Message
+from s2python.version import S2_VERSION
+
+logger = logging.getLogger("s2python")
+
+
+@dataclass
+class AssetDetails:  # pylint: disable=too-many-instance-attributes
+    resource_id: str
+
+    provides_forecast: bool
+    provides_power_measurements: List[CommodityQuantity]
+
+    instruction_processing_delay: Duration
+    roles: List[Role]
+    currency: Optional[Currency] = None
+
+    name: Optional[str] = None
+    manufacturer: Optional[str] = None
+    model: Optional[str] = None
+    firmware_version: Optional[str] = None
+    serial_number: Optional[str] = None
+
+    def to_resource_manager_details(
+        self, control_types: List[S2ControlType]
+    ) -> ResourceManagerDetails:
+        return ResourceManagerDetails(
+            available_control_types=[
+                control_type.get_protocol_control_type() for control_type in control_types
+            ],
+            currency=self.currency,
+            firmware_version=self.firmware_version,
+            instruction_processing_delay=self.instruction_processing_delay,
+            manufacturer=self.manufacturer,
+            message_id=uuid.uuid4(),
+            model=self.model,
+            name=self.name,
+            provides_forecast=self.provides_forecast,
+            provides_power_measurement_types=self.provides_power_measurements,
+            resource_id=self.resource_id,
+            roles=self.roles,
+            serial_number=self.serial_number,
+        )
+
+
+S2MessageHandler = Union[
+    Callable[["S2Connection", S2Message, Callable[[], None]], None],
+    Callable[["S2Connection", S2Message, Awaitable[None]], Awaitable[None]],
+]
+
+
+class SendOkay:
+    status_is_send: threading.Event
+    connection: "S2Connection"
+    subject_message_id: uuid.UUID
+
+    def __init__(self, connection: "S2Connection", subject_message_id: uuid.UUID):
+        self.status_is_send = threading.Event()
+        self.connection = connection
+        self.subject_message_id = subject_message_id
+
+    async def run_async(self) -> None:
+        self.status_is_send.set()
+
+        await self.connection.respond_with_reception_status(
+            subject_message_id=str(self.subject_message_id),
+            status=ReceptionStatusValues.OK,
+            diagnostic_label="Processed okay.",
+        )
+
+    def run_sync(self) -> None:
+        self.status_is_send.set()
+
+        self.connection.respond_with_reception_status_sync(
+            subject_message_id=str(self.subject_message_id),
+            status=ReceptionStatusValues.OK,
+            diagnostic_label="Processed okay.",
+        )
+
+    async def ensure_send_async(self, type_msg: Type[S2Message]) -> None:
+        if not self.status_is_send.is_set():
+            logger.warning(
+                "Handler for message %s %s did not call send_okay / function to send the ReceptionStatus. "
+                "Sending it now.",
+                type_msg,
+                self.subject_message_id,
+            )
+            await self.run_async()
+
+    def ensure_send_sync(self, type_msg: Type[S2Message]) -> None:
+        if not self.status_is_send.is_set():
+            logger.warning(
+                "Handler for message %s %s did not call send_okay / function to send the ReceptionStatus. "
+                "Sending it now.",
+                type_msg,
+                self.subject_message_id,
+            )
+            self.run_sync()
+
+
+class MessageHandlers:
+    handlers: Dict[Type[S2Message], S2MessageHandler]
+
+    def __init__(self) -> None:
+        self.handlers = {}
+
+    async def handle_message(self, connection: "S2Connection", msg: S2Message) -> None:
+        """Handle the S2 message using the registered handler.
+
+        :param connection: The S2 conncetion the `msg` is received from.
+        :param msg: The S2 message
+        """
+        handler = self.handlers.get(type(msg))
+        if handler is not None:
+            send_okay = SendOkay(connection, msg.message_id)  # type: ignore[attr-defined]
+
+            try:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(connection, msg, send_okay.run_async())  # type: ignore[arg-type]
+                    await send_okay.ensure_send_async(type(msg))
+                else:
+
+                    def do_message() -> None:
+                        handler(connection, msg, send_okay.run_sync)  # type: ignore[arg-type]
+                        send_okay.ensure_send_sync(type(msg))
+
+                    eventloop = asyncio.get_event_loop()
+                    await eventloop.run_in_executor(executor=None, func=do_message)
+            except Exception:
+                if not send_okay.status_is_send.is_set():
+                    await connection.respond_with_reception_status(
+                        subject_message_id=str(msg.message_id),  # type: ignore[attr-defined]
+                        status=ReceptionStatusValues.PERMANENT_ERROR,
+                        diagnostic_label=f"While processing message {msg.message_id} "  # type: ignore[attr-defined]
+                        f"an unrecoverable error occurred.",
+                    )
+                raise
+        else:
+            logger.warning(
+                "Received a message of type %s but no handler is registered. Ignoring the message.",
+                type(msg),
+            )
+
+    def register_handler(self, msg_type: Type[S2Message], handler: S2MessageHandler) -> None:
+        """Register a coroutine function or a normal function as the handler for a specific S2 message type.
+
+        :param msg_type: The S2 message type to attach the handler to.
+        :param handler: The function (asynchronuous or normal) which should handle the S2 message.
+        """
+        self.handlers[msg_type] = handler
+
+
+class S2Connection:  # pylint: disable=too-many-instance-attributes
+    url: str
+    reception_status_awaiter: ReceptionStatusAwaiter
+    ws: Optional[WSConnection]
+    s2_parser: S2Parser
+    control_types: List[S2ControlType]
+    role: EnergyManagementRole
+    asset_details: AssetDetails
+
+    _thread: threading.Thread
+
+    _handlers: MessageHandlers
+    _current_control_type: Optional[S2ControlType]
+    _received_messages: asyncio.Queue
+
+    _eventloop: asyncio.AbstractEventLoop
+    _background_tasks: Optional[asyncio.Task]
+    _stop_event: asyncio.Event
+
+    def __init__(
+        self,
+        url: str,
+        role: EnergyManagementRole,
+        control_types: List[S2ControlType],
+        asset_details: AssetDetails,
+    ) -> None:
+        self.url = url
+        self.reception_status_awaiter = ReceptionStatusAwaiter()
+        self.s2_parser = S2Parser()
+
+        self._handlers = MessageHandlers()
+        self._current_control_type = None
+
+        self._eventloop = asyncio.new_event_loop()
+        self._background_tasks = None
+
+        self.control_types = control_types
+        self.role = role
+        self.asset_details = asset_details
+
+        self._handlers.register_handler(SelectControlType, self.handle_select_control_type_as_rm)
+        self._handlers.register_handler(Handshake, self.handle_handshake)
+        self._handlers.register_handler(HandshakeResponse, self.handle_handshake_response_as_rm)
+
+    def start_as_rm(self) -> None:
+        self._thread = threading.Thread(target=self._run_eventloop)
+        self._thread.start()
+        logger.debug("Started eventloop thread!")
+
+    def _run_eventloop(self) -> None:
+        logger.debug("Starting eventloop")
+        self._eventloop.run_until_complete(self._run_as_rm())
+
+    def stop(self) -> None:
+        """Stops the S2 connection.
+
+        Note: Ensure this method is called from a different thread than the thread running the S2 connection.
+        Otherwise it will block waiting on the coroutine _do_stop to terminate successfully but it can't run
+        the coroutine. A `RuntimeError` will be raised to prevent the indefinite block.
+        """
+        if threading.current_thread() == self._thread:
+            raise RuntimeError(
+                "Do not call stop from the thread running the S2 connection. This results in an "
+                "infinite block!"
+            )
+
+        asyncio.run_coroutine_threadsafe(self._do_stop(), self._eventloop).result()
+
+    async def _do_stop(self) -> None:
+        logger.info("Will stop the S2 connection.")
+        if self._background_tasks:
+            self._background_tasks.cancel()
+            self._background_tasks = None
+
+        if self.ws:
+            await self.ws.close()
+            await self.ws.wait_closed()
+
+    async def _run_as_rm(self) -> None:
+        logger.debug("Connecting as S2 resource manager.")
+        self._received_messages = asyncio.Queue()
+        await self.connect_ws()
+
+        self._background_tasks = self._eventloop.create_task(
+            asyncio.wait(
+                (self._receive_messages(), self._handle_received_messages()),
+                return_when=asyncio.FIRST_EXCEPTION,
+            )
+        )
+
+        await self.connect_as_rm()
+        done: List[asyncio.Task]
+        pending: List[asyncio.Task]
+        (done, pending) = await self._background_tasks
+
+        for task in done:
+            task.result()
+
+        for task in pending:
+            task.cancel()
+
+    async def connect_ws(self) -> None:
+        self.ws = await ws_connect(uri=self.url)
+
+    async def connect_as_rm(self) -> None:
+        await self.send_msg_and_await_reception_status_async(
+            Handshake(
+                message_id=uuid.uuid4(), role=self.role, supported_protocol_versions=[S2_VERSION]
+            )
+        )
+        logger.debug("Send handshake to CEM. Expecting Handshake and HandshakeResponse from CEM.")
+
+    async def handle_handshake(
+        self, _: "S2Connection", message: S2Message, send_okay: Awaitable[None]
+    ) -> None:
+        if not isinstance(message, Handshake):
+            logger.error(
+                "Handler for Handshake received a message of the wrong type: %s", type(message)
+            )
+            return
+
+        logger.debug(
+            "%s supports S2 protocol versions: %s",
+            message.role,
+            message.supported_protocol_versions,
+        )
+        await send_okay
+
+    async def handle_handshake_response_as_rm(
+        self, _: "S2Connection", message: S2Message, send_okay: Awaitable[None]
+    ) -> None:
+        if not isinstance(message, HandshakeResponse):
+            logger.error(
+                "Handler for HandshakeResponse received a message of the wrong type: %s",
+                type(message),
+            )
+            return
+
+        logger.debug("Received HandshakeResponse %s", message.to_json())
+
+        logger.debug("CEM selected to use version %s", message.selected_protocol_version)
+        await send_okay
+        logger.debug("Handshake complete. Sending first ResourceManagerDetails.")
+
+        await self.send_msg_and_await_reception_status_async(
+            self.asset_details.to_resource_manager_details(self.control_types)
+        )
+
+    async def handle_select_control_type_as_rm(
+        self, _: "S2Connection", message: S2Message, send_okay: Awaitable[None]
+    ) -> None:
+        if not isinstance(message, SelectControlType):
+            logger.error(
+                "Handler for SelectControlType received a message of the wrong type: %s",
+                type(message),
+            )
+            return
+
+        await send_okay
+
+        logger.debug("CEM selected control type %s. Activating control type.", message.control_type)
+
+        control_types_by_protocol_name = {
+            c.get_protocol_control_type(): c for c in self.control_types
+        }
+        selected_control_type: Optional[S2ControlType] = control_types_by_protocol_name.get(
+            message.control_type
+        )
+
+        if self._current_control_type is not None:
+            await self._eventloop.run_in_executor(None, self._current_control_type.deactivate, self)
+
+        self._current_control_type = selected_control_type
+
+        if self._current_control_type is not None:
+            await self._eventloop.run_in_executor(None, self._current_control_type.activate, self)
+            self._current_control_type.register_handlers(self._handlers)
+
+    async def _receive_messages(self) -> None:
+        """Receives all incoming messages in the form of a generator.
+
+        Will also receive the ReceptionStatus messages but instead of yielding these messages, they are routed
+        to any calls of `send_msg_and_await_reception_status`.
+        """
+        if self.ws is None:
+            raise RuntimeError(
+                "Cannot receive messages if websocket connection is not yet established."
+            )
+
+        logger.info("S2 connection has started to receive messages.")
+
+        async for message in self.ws:
+            try:
+                s2_msg: S2Message = self.s2_parser.parse_as_any_message(message)
+            except json.JSONDecodeError:
+                await self._send_and_forget(
+                    ReceptionStatus(
+                        subject_message_id="00000000-0000-0000-0000-000000000000",
+                        status=ReceptionStatusValues.INVALID_DATA,
+                        diagnostic_label="Not valid json.",
+                    )
+                )
+            except S2ValidationError as e:
+                json_msg = json.loads(message)
+                message_id = json_msg.get("message_id")
+                if message_id:
+                    await self.respond_with_reception_status(
+                        subject_message_id=message_id,
+                        status=ReceptionStatusValues.INVALID_MESSAGE,
+                        diagnostic_label=str(e),
+                    )
+                else:
+                    await self.respond_with_reception_status(
+                        subject_message_id="00000000-0000-0000-0000-000000000000",
+                        status=ReceptionStatusValues.INVALID_DATA,
+                        diagnostic_label="Message appears valid json but could not find a message_id field.",
+                    )
+            else:
+                logger.debug("Received message %s", s2_msg.to_json())
+
+                if isinstance(s2_msg, ReceptionStatus):
+                    logger.debug(
+                        "Message is a reception status for %s so registering in cache.",
+                        s2_msg.subject_message_id,
+                    )
+                    await self.reception_status_awaiter.receive_reception_status(s2_msg)
+                else:
+                    await self._received_messages.put(s2_msg)
+
+    async def _send_and_forget(self, s2_msg: S2Message) -> None:
+        if self.ws is None:
+            raise RuntimeError(
+                "Cannot send messages if websocket connection is not yet established."
+            )
+
+        json_msg = s2_msg.to_json()
+        logger.debug("Sending message %s", json_msg)
+        await self.ws.send(json_msg)
+
+    async def respond_with_reception_status(
+        self, subject_message_id: str, status: ReceptionStatusValues, diagnostic_label: str
+    ) -> None:
+        logger.debug("Responding to message %s with status %s", subject_message_id, status)
+        await self._send_and_forget(
+            ReceptionStatus(
+                subject_message_id=subject_message_id,
+                status=status,
+                diagnostic_label=diagnostic_label,
+            )
+        )
+
+    def respond_with_reception_status_sync(
+        self, subject_message_id: str, status: ReceptionStatusValues, diagnostic_label: str
+    ) -> None:
+        asyncio.run_coroutine_threadsafe(
+            self.respond_with_reception_status(subject_message_id, status, diagnostic_label),
+            self._eventloop,
+        ).result()
+
+    async def send_msg_and_await_reception_status_async(
+        self, s2_msg: S2Message, timeout_reception_status: float = 5.0, raise_on_error: bool = True
+    ) -> ReceptionStatus:
+        await self._send_and_forget(s2_msg)
+        logger.debug(
+            "Waiting for ReceptionStatus for %s %s seconds",
+            s2_msg.message_id,  # type: ignore[attr-defined]
+            timeout_reception_status,
+        )
+        reception_status = await self.reception_status_awaiter.wait_for_reception_status(
+            s2_msg.message_id, timeout_reception_status  # type: ignore[attr-defined]
+        )
+
+        if reception_status.status != ReceptionStatusValues.OK and raise_on_error:
+            raise RuntimeError(f"ReceptionStatus was not OK but rather {reception_status.status}")
+
+        return reception_status
+
+    def send_msg_and_await_reception_status_sync(
+        self, s2_msg: S2Message, timeout_reception_status: float = 5.0, raise_on_error: bool = True
+    ) -> ReceptionStatus:
+        return asyncio.run_coroutine_threadsafe(
+            self.send_msg_and_await_reception_status_async(
+                s2_msg, timeout_reception_status, raise_on_error
+            ),
+            self._eventloop,
+        ).result()
+
+    async def _handle_received_messages(self) -> None:
+        while True:
+            msg = await self._received_messages.get()
+            await self._handlers.handle_message(self, msg)

s2python/s2_control_type.py

@@ -0,0 +1,56 @@
+import abc
+import typing
+
+from s2python.common import ControlType as ProtocolControlType
+from s2python.frbc import FRBCInstruction
+from s2python.validate_values_mixin import S2Message
+
+if typing.TYPE_CHECKING:
+    from s2python.s2_connection import S2Connection, MessageHandlers
+
+
+class S2ControlType(abc.ABC):
+    @abc.abstractmethod
+    def get_protocol_control_type(self) -> ProtocolControlType: ...
+
+    @abc.abstractmethod
+    def register_handlers(self, handlers: "MessageHandlers") -> None: ...
+
+    @abc.abstractmethod
+    def activate(self, conn: "S2Connection") -> None: ...
+
+    @abc.abstractmethod
+    def deactivate(self, conn: "S2Connection") -> None: ...
+
+
+class FRBCControlType(S2ControlType):
+    def get_protocol_control_type(self) -> ProtocolControlType:
+        return ProtocolControlType.FILL_RATE_BASED_CONTROL
+
+    def register_handlers(self, handlers: "MessageHandlers") -> None:
+        handlers.register_handler(FRBCInstruction, self.handle_instruction)
+
+    @abc.abstractmethod
+    def handle_instruction(
+        self, conn: "S2Connection", msg: S2Message, send_okay: typing.Callable[[], None]
+    ) -> None: ...
+
+    @abc.abstractmethod
+    def activate(self, conn: "S2Connection") -> None: ...
+
+    @abc.abstractmethod
+    def deactivate(self, conn: "S2Connection") -> None: ...
+
+
+class NoControlControlType(S2ControlType):
+    def get_protocol_control_type(self) -> ProtocolControlType:
+        return ProtocolControlType.NOT_CONTROLABLE
+
+    def register_handlers(self, handlers: "MessageHandlers") -> None:
+        pass
+
+    @abc.abstractmethod
+    def activate(self, conn: "S2Connection") -> None: ...
+
+    @abc.abstractmethod
+    def deactivate(self, conn: "S2Connection") -> None: ...

s2python/s2_parser.py

@@ -0,0 +1,113 @@
+import json
+import logging
+from typing import Optional, TypeVar, Union, Type, Dict
+
+from s2python.common import (
+    Handshake,
+    HandshakeResponse,
+    InstructionStatusUpdate,
+    PowerForecast,
+    PowerMeasurement,
+    ReceptionStatus,
+    ResourceManagerDetails,
+    RevokeObject,
+    SelectControlType,
+    SessionRequest,
+)
+from s2python.frbc import (
+    FRBCActuatorStatus,
+    FRBCFillLevelTargetProfile,
+    FRBCInstruction,
+    FRBCLeakageBehaviour,
+    FRBCStorageStatus,
+    FRBCSystemDescription,
+    FRBCTimerStatus,
+    FRBCUsageForecast,
+)
+from s2python.validate_values_mixin import S2Message
+from s2python.s2_validation_error import S2ValidationError
+
+
+LOGGER = logging.getLogger(__name__)
+S2MessageType = str
+
+M = TypeVar("M", bound=S2Message)
+
+
+# May be generated with development_utilities/generate_s2_message_type_to_class.py
+TYPE_TO_MESSAGE_CLASS: Dict[str, Type[S2Message]] = {
+    "FRBC.ActuatorStatus": FRBCActuatorStatus,
+    "FRBC.FillLevelTargetProfile": FRBCFillLevelTargetProfile,
+    "FRBC.Instruction": FRBCInstruction,
+    "FRBC.LeakageBehaviour": FRBCLeakageBehaviour,
+    "FRBC.StorageStatus": FRBCStorageStatus,
+    "FRBC.SystemDescription": FRBCSystemDescription,
+    "FRBC.TimerStatus": FRBCTimerStatus,
+    "FRBC.UsageForecast": FRBCUsageForecast,
+    "Handshake": Handshake,
+    "HandshakeResponse": HandshakeResponse,
+    "InstructionStatusUpdate": InstructionStatusUpdate,
+    "PowerForecast": PowerForecast,
+    "PowerMeasurement": PowerMeasurement,
+    "ReceptionStatus": ReceptionStatus,
+    "ResourceManagerDetails": ResourceManagerDetails,
+    "RevokeObject": RevokeObject,
+    "SelectControlType": SelectControlType,
+    "SessionRequest": SessionRequest,
+}
+
+
+class S2Parser:
+    @staticmethod
+    def _parse_json_if_required(unparsed_message: Union[dict, str, bytes]) -> dict:
+        if isinstance(unparsed_message, (str, bytes)):
+            return json.loads(unparsed_message)
+        return unparsed_message
+
+    @staticmethod
+    def parse_as_any_message(unparsed_message: Union[dict, str, bytes]) -> S2Message:
+        """Parse the message as any S2 python message regardless of message type.
+
+        :param unparsed_message: The message as a JSON-formatted string or as a json-parsed dictionary.
+        :raises: S2ValidationError, json.JSONDecodeError
+        :return: The parsed S2 message if no errors were found.
+        """
+        message_json = S2Parser._parse_json_if_required(unparsed_message)
+        message_type = S2Parser.parse_message_type(message_json)
+
+        if message_type not in TYPE_TO_MESSAGE_CLASS:
+            raise S2ValidationError(
+                None,
+                message_json,
+                f"Unable to parse {message_type} as an S2 message. Type unknown.",
+                None,
+            )
+
+        return TYPE_TO_MESSAGE_CLASS[message_type].model_validate(message_json)
+
+    @staticmethod
+    def parse_as_message(unparsed_message: Union[dict, str, bytes], as_message: Type[M]) -> M:
+        """Parse the message to a specific S2 python message.
+
+        :param unparsed_message: The message as a JSON-formatted string or as a JSON-parsed dictionary.
+        :param as_message: The type of message that is expected within the `message`
+        :raises: S2ValidationError, json.JSONDecodeError
+        :return: The parsed S2 message if no errors were found.
+        """
+        message_json = S2Parser._parse_json_if_required(unparsed_message)
+        return as_message.from_dict(message_json)
+
+    @staticmethod
+    def parse_message_type(unparsed_message: Union[dict, str, bytes]) -> Optional[S2MessageType]:
+        """Parse only the message type from the unparsed message.
+
+        This is useful to call before `parse_as_message` to retrieve the message type and allows for strictly-typed
+        parsing.
+
+        :param unparsed_message: The message as a JSON-formatted string or as a JSON-parsed dictionary.
+        :raises: json.JSONDecodeError
+        :return: The parsed S2 message type if no errors were found.
+        """
+        message_json = S2Parser._parse_json_if_required(unparsed_message)
+
+        return message_json.get("message_type")