zepben.ewb 1.0.0__py3-none-any.whl

zepben/ewb/services/services.py

@@ -0,0 +1,48 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+from typing import Optional
+
+from zepben.ewb import NetworkService, DiagramService, CustomerService
+
+
+class Services:
+    """
+    A convenience class for storing the data supported by the SDK.
+
+    :param network_service: An optional `NetworkService` to add to the services, otherwise an empty `NetworkService` will be created.
+    :param diagram_service: An optional `NetworkService` to add to the services, otherwise an empty `NetworkService` will be created.
+    :param customer_service: An optional `NetworkService` to add to the services, otherwise an empty `NetworkService` will be created.
+    """
+
+    def __init__(
+        self,
+        network_service: Optional[NetworkService] = NetworkService(),
+        diagram_service: Optional[DiagramService] = DiagramService(),
+        customer_service: Optional[CustomerService] = CustomerService()
+    ):
+        super().__init__()
+        self.network_service = network_service
+        """The `NetworkService` of these services."""
+
+        self.diagram_service = diagram_service
+        """The `DiagramService` of these services."""
+
+        self.customer_service = customer_service
+        """The `CustomerService` of these services."""
+
+    def __iter__(self):
+        self._iter_index = 0
+        return self
+
+    def __next__(self):
+        self._iter_index += 1
+        if self._iter_index == 1:
+            return self.network_service
+        elif self._iter_index == 2:
+            return self.diagram_service
+        elif self._iter_index == 3:
+            return self.customer_service
+        else:
+            raise StopIteration

zepben/ewb/streaming/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.

zepben/ewb/streaming/data/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.

zepben/ewb/streaming/data/current_state_event.py

@@ -0,0 +1,314 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CurrentStateEvent", "SwitchStateEvent", "SwitchAction", "AddCutEvent", "RemoveCutEvent", "AddJumperEvent", "RemoveJumperEvent", "JumperConnection"]
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+
+from zepben.protobuf.ns.data.change_events_pb2 import CurrentStateEvent as PBCurrentStateEvent, SwitchStateEvent as PBSwitchStateEvent, \
+    AddCutEvent as PBAddCutEvent, RemoveCutEvent as PBRemoveCutEvent, AddJumperEvent as PBAddJumperEvent, RemoveJumperEvent as PBRemoveJumperEvent, \
+    JumperConnection as PBJumperConnection, SwitchAction as PBSwitchAction
+
+from zepben.ewb.model.cim.iec61970.base.core.phase_code import PhaseCode, phase_code_by_id
+# noinspection PyProtectedMember
+from zepben.ewb.services.common.enum_mapper import EnumMapper
+# noinspection PyProtectedMember
+from zepben.ewb.services.network.translator.network_enum_mappers import _map_phase_code
+from zepben.ewb.util import datetime_to_timestamp
+
+
+@dataclass
+class CurrentStateEvent(ABC):
+    """
+    An event to apply to the current state of the network.
+
+    Attributes:
+        event_id: An identifier of this event. This must be unique across requests to allow detection of
+                  duplicates when requesting events via dates versus those streamed via live updates.
+        timestamp: The timestamp when the event occurred.
+    """
+
+    def __init__(self, event_id: str, timestamp: datetime):
+        self.event_id = event_id
+        self.timestamp = timestamp
+
+    @staticmethod
+    def from_pb(event: PBCurrentStateEvent) -> 'CurrentStateEvent':
+        """
+        Creates a `CurrentStateEvent` object from a protobuf `CurrentStateEvent`.
+        """
+        active_event = event.WhichOneof("event")
+        if active_event == "switch":
+            return SwitchStateEvent.from_pb(event)
+        elif active_event == "addCut":
+            return AddCutEvent.from_pb(event)
+        elif active_event == "removeCut":
+            return RemoveCutEvent.from_pb(event)
+        elif active_event == "addJumper":
+            return AddJumperEvent.from_pb(event)
+        elif active_event == "removeJumper":
+            return RemoveJumperEvent.from_pb(event)
+        else:
+            raise NotImplementedError(f"'{active_event}' is currently unsupported.")
+
+    @abstractmethod
+    def to_pb(self) -> PBCurrentStateEvent:
+        """
+        Creates a protobuf `CurrentStateEvent` object with switch from this `CurrentStateEvent`.
+        """
+        pass
+
+
+@dataclass
+class SwitchStateEvent(CurrentStateEvent):
+    """
+    An event to update the state of a switch.
+
+    Attributes:
+        event_id: An identifier of this event. This must be unique across requests to allow detection of
+                  duplicates when requesting events via dates versus those streamed via live updates.
+        timestamp: The timestamp when the event occurred, always in UTC (Coordinated Universal Time).
+        mrid: The mRID of the switch affected by this event.
+        action: The action to take on the switch for the specified phases.
+        phases: The phases affected by this event. Defaults to 'NONE'.
+    """
+
+    def __init__(self, event_id: str, timestamp: datetime, mrid: str, action: 'SwitchAction', phases: PhaseCode = PhaseCode.NONE):
+        super().__init__(event_id, timestamp)
+        self.mrid = mrid
+        self.action = action
+        self.phases = phases
+
+    @staticmethod
+    def from_pb(event: PBCurrentStateEvent) -> 'SwitchStateEvent':
+        """
+        Creates a `SwitchStateEvent` object from a protobuf `CurrentStateEvent`.
+        """
+        return SwitchStateEvent(
+            event.eventId,
+            event.timestamp.ToDatetime(),
+            event.switch.mRID,
+            SwitchAction(event.switch.action),
+            phase_code_by_id(event.switch.phases)
+        )
+
+    def to_pb(self) -> PBCurrentStateEvent:
+        """
+        Creates a protobuf `CurrentStateEvent` object with `switch` from this `SwitchStateEvent`.
+        """
+        return PBCurrentStateEvent(
+            eventId=self.event_id,
+            timestamp=datetime_to_timestamp(self.timestamp),
+            switch=PBSwitchStateEvent(mRID=self.mrid, action=_map_switch_action.to_pb(self.action), phases=_map_phase_code.to_pb(self.phases))
+        )
+
+
+@dataclass
+class AddCutEvent(CurrentStateEvent):
+    """
+    An event to add a cut to the network.
+
+    Attributes:
+        event_id: An identifier of this event. This must be unique across requests to allow detection of
+          duplicates when requesting events via dates vs those streamed via live updates.
+        timestamp: The timestamp when the event occurred. This is always handled as UTC (Coordinated Universal Time).
+        mrid: The mRID of the cut defined by this event. This should match any future remove instructions.
+        acls_mrid: The mRID of the AC line segment that was cut.
+    """
+
+    def __init__(self, event_id: str, timestamp: datetime, mrid: str, acls_mrid: str):
+        super().__init__(event_id, timestamp)
+        self.mrid = mrid
+        self.acls_mrid = acls_mrid
+
+    @staticmethod
+    def from_pb(event: PBCurrentStateEvent) -> 'AddCutEvent':
+        """
+        Creates an `AddCutEvent` object from a protobuf `PBCurrentStateEvent`
+        """
+        return AddCutEvent(
+            event.eventId,
+            event.timestamp.ToDatetime(),
+            event.addCut.mRID,
+            event.addCut.aclsMRID
+        )
+
+    def to_pb(self) -> PBCurrentStateEvent:
+        """
+        Creates a protobuf `PBCurrentStateEvent` object with `addCut` from this `AddCutEvent`
+        """
+        return PBCurrentStateEvent(
+            eventId=self.event_id,
+            timestamp=datetime_to_timestamp(self.timestamp),
+            addCut=PBAddCutEvent(mRID=self.mrid, aclsMRID=self.acls_mrid)
+        )
+
+
+@dataclass
+class RemoveCutEvent(CurrentStateEvent):
+    """
+    An event to remove a cut from the network.
+
+    Attributes:
+        event_id: An identifier of this event. This must be unique across requests to allow detection of
+          duplicates when requesting events via dates vs those streamed via live updates.
+        timestamp: The timestamp when the event occurred. This is always handled as UTC (Coordinated Universal Time).
+        mrid: The mRID of the cut to remove. This should match a previously added cut.
+    """
+
+    def __init__(self, event_id: str, timestamp: datetime, mrid: str):
+        super().__init__(event_id, timestamp)
+        self.mrid = mrid
+
+    @staticmethod
+    def from_pb(event: PBCurrentStateEvent) -> 'RemoveCutEvent':
+        """
+        Creates a `RemoveCutEvent` object from protobuf `PBCurrentStateEvent`
+        """
+        return RemoveCutEvent(
+            event.eventId,
+            event.timestamp.ToDatetime(),
+            event.removeCut.mRID
+        )
+
+    def to_pb(self) -> PBCurrentStateEvent:
+        """
+        Creates a protobuf `PBCurrentStateEvent` object with `removeCut` from this `RemoveCutEvent`
+        """
+        return PBCurrentStateEvent(
+            eventId=self.event_id,
+            timestamp=datetime_to_timestamp(self.timestamp),
+            removeCut=PBRemoveCutEvent(mRID=self.mrid)
+        )
+
+
+@dataclass
+class AddJumperEvent(CurrentStateEvent):
+    """
+    An event to add a jumper to the network.
+
+    Attributes:
+        event_id: An identifier of this event. This must be unique across requests to allow detection of
+          duplicates when requesting events via dates vs those streamed via live updates.
+        timestamp: The timestamp when the event occurred. This is always handled as UTC (Coordinated Universal Time).
+        mrid: The mRID of the jumper affected by this event.
+        from_connection: Information on how this jumper is connected at one end of the jumper.
+        to_connection: Information on how this jumper is connected at the other end of the jumper.
+    """
+
+    def __init__(self, event_id: str, timestamp: datetime, mrid: str, from_connection: 'JumperConnection', to_connection: 'JumperConnection'):
+        super().__init__(event_id, timestamp)
+        self.mrid = mrid
+        self.from_connection = from_connection
+        self.to_connection = to_connection
+
+    @staticmethod
+    def from_pb(event: PBCurrentStateEvent) -> 'AddJumperEvent':
+        """
+        Creates an `AddJumperEvent` object from protobuf `PBCurrentStateEvent`
+        """
+        return AddJumperEvent(
+            event.eventId,
+            event.timestamp.ToDatetime(),
+            event.addJumper.mRID,
+            JumperConnection.from_pb(event.addJumper.fromConnection),
+            JumperConnection.from_pb(event.addJumper.toConnection)
+        )
+
+    def to_pb(self) -> PBCurrentStateEvent:
+        """
+        Creates a protobuf `PBCurrentStateEvent` object with `addJumper` from this `AddJumperEvent`
+        """
+        return PBCurrentStateEvent(
+            eventId=self.event_id,
+            timestamp=datetime_to_timestamp(self.timestamp),
+            addJumper=PBAddJumperEvent(mRID=self.mrid, fromConnection=self.from_connection.to_pb(), toConnection=self.to_connection.to_pb())
+        )
+
+
+@dataclass
+class RemoveJumperEvent(CurrentStateEvent):
+    """
+    An event to remove a jumper from the network.
+
+    Attributes:
+        event_id: An identifier of this event. This must be unique across requests to allow detection of
+          duplicates when requesting events via dates vs those streamed via live updates.
+        timestamp: The timestamp when the event occurred. This is always handled as UTC (Coordinated Universal Time).
+        mrid: The mRID of the jumper to remove. This should match a previously added jumper.
+    """
+
+    def __init__(self, event_id: str, timestamp: datetime, mrid: str):
+        super().__init__(event_id, timestamp)
+        self.mrid = mrid
+
+    @staticmethod
+    def from_pb(event: PBCurrentStateEvent) -> 'RemoveJumperEvent':
+        """
+        Creates a `RemoveJumperEvent` object from protobuf `PBCurrentStateEvent`
+        """
+        return RemoveJumperEvent(
+            event.eventId,
+            event.timestamp.ToDatetime(),
+            event.removeJumper.mRID
+        )
+
+    def to_pb(self) -> PBCurrentStateEvent:
+        """
+        Creates a protobuf `PBCurrentStateEvent` object with `removeJumper` from this `RemoveJumperEvent`
+        """
+        return PBCurrentStateEvent(
+            eventId=self.event_id,
+            timestamp=datetime_to_timestamp(self.timestamp),
+            removeJumper=PBRemoveJumperEvent(mRID=self.mrid)
+        )
+
+
+class SwitchAction(Enum):
+    """
+    Enum representing possible actions for a switch.
+    """
+    UNKNOWN = 0  # The specified action was unknown, or was not set.
+    OPEN = 1  # A request to open a switch.
+    CLOSE = 2  # A request to close a switch.
+
+    @property
+    def short_name(self):
+        return str(self)[13:]
+
+
+_map_switch_action = EnumMapper(SwitchAction, PBSwitchAction)
+
+
+class JumperConnection:
+    """
+    Information about how a jumper is connected to the network.
+
+    Attributes:
+        connected_mrid: The mRID of the conducting equipment (or terminal) connected to this end of the jumper.
+    """
+
+    def __init__(self, connected_mrid: str):
+        self.connected_mrid = connected_mrid
+
+    @staticmethod
+    def from_pb(connection: PBJumperConnection) -> 'JumperConnection':
+        """
+        Creates a `JumperConnection` object from protobuf `PBJumperConnection`
+        """
+        return JumperConnection(
+            connection.connectedMRID,
+        )
+
+    def to_pb(self) -> PBJumperConnection:
+        """
+        Creates a protobuf `PBJumperConnection` object from this `JumperConnection`
+        """
+        return PBJumperConnection(
+            connectedMRID=self.connected_mrid
+        )

zepben/ewb/streaming/data/current_state_event_batch.py

@@ -0,0 +1,25 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["CurrentStateEventBatch"]
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from zepben.ewb.streaming.data.current_state_event import CurrentStateEvent
+
+
+@dataclass
+class CurrentStateEventBatch:
+    """
+    A collection of events that should be operated on as a batch.
+
+    Attributes:
+        batch_id: A unique identifier for the batch of events being processed. This allows tracking or grouping multiple events under a single batch.
+        events: A list of `CurrentStateEvent` objects representing the state changes or events that are being submitted in the current batch.
+    """
+
+    batch_id: int
+    events: Iterable[CurrentStateEvent]

zepben/ewb/streaming/data/set_current_states_status.py

@@ -0,0 +1,286 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["SetCurrentStatesStatus", "BatchSuccessful", "BatchFailure", "BatchNotProcessed", "StateEventFailure", "StateEventInvalidMrid",
+           "StateEventUnknownMrid", "StateEventDuplicateMrid", "StateEventUnsupportedPhasing", "StateEventUnsupportedMrid"]
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Any
+
+from zepben.protobuf.ns.data.change_status_pb2 import BatchSuccessful as PBBatchSuccessful, BatchFailure as PBBatchFailure, \
+    BatchNotProcessed as PBBatchNotProcessed, StateEventFailure as PBStateEventFailure, StateEventUnknownMrid as PBStateEventUnknownMrid, \
+    StateEventDuplicateMrid as PBStateEventDuplicateMrid, StateEventInvalidMrid as PBStateEventInvalidMrid, \
+    StateEventUnsupportedPhasing as PBStateEventUnsupportedPhasing, StateEventUnsupportedMrid as PBStateEventUnsupportedMrid
+from zepben.protobuf.ns.network_state_responses_pb2 import SetCurrentStatesResponse as PBSetCurrentStatesResponse
+
+
+class SetCurrentStatesStatus(ABC):
+    """
+    The outcome of processing this batch of updates.
+
+    Attributes:
+        batch_id: The unique identifier of the batch that was processed. This matches the
+                  batch ID from the original request to allow correlation between request and response.
+    """
+
+    def __init__(self, batch_id: int):
+        self.batch_id = batch_id
+
+    @staticmethod
+    def from_pb(pb: PBSetCurrentStatesResponse) -> 'SetCurrentStatesStatus':
+        """
+        Creates a BatchSuccessful object from a protobuf SetCurrentStatesResponse.
+        """
+        status = pb.WhichOneof("status")
+        if status == "success":
+            return BatchSuccessful.from_pb(pb)
+        elif status == "failure":
+            return BatchFailure.from_pb(pb)
+        elif status == "notProcessed":
+            return BatchNotProcessed.from_pb(pb)
+
+    @abstractmethod
+    def to_pb(self) -> PBSetCurrentStatesResponse:
+        """
+        Creates a protobuf SetCurrentStatesResponse object with status.
+        """
+        pass
+
+
+@dataclass
+class BatchSuccessful(SetCurrentStatesStatus):
+    """
+    A response indicating all items in the batch were applied successfully.
+
+    Attributes:
+        batch_id: The unique identifier of the batch that was processed. This matches the
+                  batch ID from the original request to allow correlation between request and response.
+    """
+
+    def __init__(self, batch_id: int):
+        super().__init__(batch_id)
+
+    @staticmethod
+    def from_pb(pb: PBSetCurrentStatesResponse) -> 'BatchSuccessful':
+        """
+        Creates a BatchSuccessful object from a protobuf SetCurrentStatesResponse.
+        """
+        return BatchSuccessful(batch_id=pb.messageId)
+
+    def to_pb(self) -> PBSetCurrentStatesResponse:
+        """
+        Creates a protobuf SetCurrentStatesResponse object with success.
+        """
+        return PBSetCurrentStatesResponse(messageId=self.batch_id, success=PBBatchSuccessful())
+
+
+@dataclass
+class BatchFailure(SetCurrentStatesStatus):
+    """
+    A response indicating one or more items in the batch couldn't be applied.
+
+    Attributes:
+        batch_id: The unique identifier of the batch that was processed. This matches the
+                  batch ID from the original request to allow correlation between request and response.
+        partial_failure: Indicates if only some of the batch failed (True), or all entries in the batch failed (False).
+        failures: The status of each item processed in the batch that failed.
+    """
+
+    def __init__(self, batch_id: int, partial_failure: bool, failures: Tuple['StateEventFailure', Any]):
+        super().__init__(batch_id)
+        self.partial_failure = partial_failure
+        self.failures = failures
+
+    @staticmethod
+    def from_pb(pb: PBSetCurrentStatesResponse) -> 'BatchFailure':
+        """
+        Creates a BatchFailure object from a protobuf SetCurrentStatesResponse.
+        """
+        failures: List['StateEventFailure'] = []
+        for fail in pb.failure.failed:
+            event_failure = StateEventFailure.from_pb(fail)
+            if event_failure is not None:
+                failures.append(event_failure)
+
+        return BatchFailure(batch_id=pb.messageId, partial_failure=pb.failure.partialFailure, failures=tuple(failures))
+
+    def to_pb(self) -> PBSetCurrentStatesResponse:
+        """
+        Creates a protobuf SetCurrentStatesResponse object with failure.
+        """
+        return PBSetCurrentStatesResponse(messageId=self.batch_id,
+                                          failure=PBBatchFailure(partialFailure=self.partial_failure, failed=[fail.to_pb() for fail in self.failures]))
+
+
+@dataclass
+class BatchNotProcessed(SetCurrentStatesStatus):
+    """
+    A response indicating all items in the batch were ignored because the message ID of the batch was prior to the
+    last processed batch. This is expected when starting the service if the same item is sent to the current state
+    processing queue and is also included in the backlog processing response.
+
+    Attributes:
+        batch_id: The unique identifier of the batch that was processed. This matches the
+                  batch ID from the original request to allow correlation between request and response.
+    """
+
+    def __init__(self, batch_id: int):
+        super().__init__(batch_id)
+
+    @staticmethod
+    def from_pb(pb: PBSetCurrentStatesResponse) -> 'BatchNotProcessed':
+        """
+        Creates a BatchNotProcessed object from a protobuf SetCurrentStatesResponse.
+        """
+        return BatchNotProcessed(batch_id=pb.messageId)
+
+    def to_pb(self) -> PBSetCurrentStatesResponse:
+        """
+        Creates a protobuf SetCurrentStatesResponse object with notProcessed.
+        """
+        return PBSetCurrentStatesResponse(messageId=self.batch_id, notProcessed=PBBatchNotProcessed())
+
+
+class StateEventFailure(ABC):
+    """
+    A wrapper class for allowing a one-of to be repeated.
+
+    Attributes:
+        event_id: The event ID of the state event that failed.
+        message: A message describing why the event failed.
+    """
+
+    def __init__(self, event_id: str, message: str):
+        self.event_id = event_id
+        self.message = message
+
+    @staticmethod
+    def from_pb(pb: PBStateEventFailure) -> Optional['StateEventFailure']:
+        """
+        Creates a StateEventFailure object from a protobuf StateEventFailure.
+        """
+        reason_code = pb.WhichOneof('reason')
+        if reason_code == "unknownMrid":
+            return StateEventUnknownMrid.from_pb(pb)
+        elif reason_code == "duplicateMrid":
+            return StateEventDuplicateMrid.from_pb(pb)
+        elif reason_code == "invalidMrid":
+            return StateEventInvalidMrid.from_pb(pb)
+        elif reason_code == "unsupportedPhasing":
+            return StateEventUnsupportedPhasing.from_pb(pb)
+        elif reason_code == "unsupportedMrid":
+            return StateEventUnsupportedMrid.from_pb(pb)
+        else:
+            return None
+
+    @abstractmethod
+    def to_pb(self) -> PBStateEventFailure:
+        """
+        Creates a protobuf StateEventFailure of the appropriate type.
+        """
+        pass
+
+
+class StateEventUnknownMrid(StateEventFailure):
+    """
+    The requested mRID was not found in the network.
+    """
+
+    @staticmethod
+    def from_pb(pb: PBStateEventFailure) -> 'StateEventUnknownMrid':
+        """
+        Creates a StateEventUnknownMrid object from a protobuf StateEventFailure.
+        """
+        return StateEventUnknownMrid(pb.eventId, pb.message)
+
+    def to_pb(self) -> PBStateEventFailure:
+        return PBStateEventFailure(
+            eventId=self.event_id,
+            message=self.message,
+            unknownMrid=PBStateEventUnknownMrid()
+        )
+
+
+class StateEventDuplicateMrid(StateEventFailure):
+    """
+    The requested mRID already existed in the network and can't be used.
+    """
+
+    @staticmethod
+    def from_pb(pb: PBStateEventFailure) -> 'StateEventDuplicateMrid':
+        """
+        Creates a StateEventDuplicateMrid object from a protobuf StateEventFailure.
+        """
+        return StateEventDuplicateMrid(pb.eventId, pb.message)
+
+    def to_pb(self) -> PBStateEventFailure:
+        return PBStateEventFailure(
+            eventId=self.event_id,
+            message=self.message,
+            duplicateMrid=PBStateEventDuplicateMrid()
+        )
+
+
+class StateEventInvalidMrid(StateEventFailure):
+    """
+    The requested mRID was found in the network model, but was of an invalid type.
+    """
+
+    @staticmethod
+    def from_pb(pb: PBStateEventFailure) -> 'StateEventInvalidMrid':
+        """
+        Creates a StateEventInvalidMrid object from a protobuf StateEventFailure.
+        """
+        return StateEventInvalidMrid(pb.eventId, pb.message)
+
+    def to_pb(self) -> PBStateEventFailure:
+        return PBStateEventFailure(
+            eventId=self.event_id,
+            message=self.message,
+            invalidMrid=PBStateEventInvalidMrid()
+        )
+
+
+class StateEventUnsupportedPhasing(StateEventFailure):
+    """
+    The requested phasing was not available for the given operation. For example, an open state request was made with
+    unsupported phases.
+    """
+
+    @staticmethod
+    def from_pb(pb: PBStateEventFailure) -> 'StateEventUnsupportedPhasing':
+        """
+        Creates a StateEventUnsupportedPhasing object from a protobuf StateEventFailure.
+        """
+        return StateEventUnsupportedPhasing(pb.eventId, pb.message)
+
+    def to_pb(self) -> PBStateEventFailure:
+        return PBStateEventFailure(
+            eventId=self.event_id,
+            message=self.message,
+            unsupportedPhasing=PBStateEventUnsupportedPhasing()
+        )
+
+
+class StateEventUnsupportedMrid(StateEventFailure):
+    """
+    The mRID provided can't be used to perform the given action even though it is of the correct type. e.g. Trying to
+    open/close a switch in a voltage level that hasn't been implemented in the server.
+    """
+
+    @staticmethod
+    def from_pb(pb: PBStateEventFailure) -> 'StateEventUnsupportedMrid':
+        """
+        Creates a StateEventUnsupportedMrid object from a protobuf StateEventFailure.
+        """
+        return StateEventUnsupportedMrid(pb.eventId, pb.message)
+
+    def to_pb(self) -> PBStateEventFailure:
+        return PBStateEventFailure(
+            eventId=self.event_id,
+            message=self.message,
+            unsupportedMrid=PBStateEventUnsupportedMrid()
+        )