s2-python 0.4.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

s2python/ppbc/ppbc_power_sequence_container_status.py

@@ -12,21 +12,19 @@ from s2python.validate_values_mixin import (
 
 
 @catch_and_convert_exceptions
-class PPBCPowerSequenceContainerStatus(
-    GenPPBCPowerSequenceContainerStatus, S2MessageComponent["PPBCPowerSequenceContainerStatus"]
-):
+class PPBCPowerSequenceContainerStatus(GenPPBCPowerSequenceContainerStatus, S2MessageComponent):
     model_config = GenPPBCPowerSequenceContainerStatus.model_config
     model_config["validate_assignment"] = True
 
-    power_profile_id: uuid.UUID = GenPPBCPowerSequenceContainerStatus.model_fields[
+    power_profile_id: uuid.UUID = GenPPBCPowerSequenceContainerStatus.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "power_profile_id"  # type: ignore[assignment]
     ]
-    sequence_container_id: uuid.UUID = GenPPBCPowerSequenceContainerStatus.model_fields[
+    sequence_container_id: uuid.UUID = GenPPBCPowerSequenceContainerStatus.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "sequence_container_id"  # type: ignore[assignment]
     ]
-    selected_sequence_id: Union[uuid.UUID, None] = (
-        GenPPBCPowerSequenceContainerStatus.model_fields["selected_sequence_id"]  # type: ignore[assignment]
-    )
-    progress: Union[uuid.UUID, None] = GenPPBCPowerSequenceContainerStatus.model_fields[
+    selected_sequence_id: Union[uuid.UUID, None] = GenPPBCPowerSequenceContainerStatus.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
+        "selected_sequence_id"
+    ]  # type: ignore[assignment]
+    progress: Union[uuid.UUID, None] = GenPPBCPowerSequenceContainerStatus.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "progress"  # type: ignore[assignment]
     ]

s2python/ppbc/ppbc_power_sequence_element.py

@@ -13,13 +13,11 @@ from s2python.common import Duration, PowerForecastValue
 
 
 @catch_and_convert_exceptions
-class PPBCPowerSequenceElement(
-    GenPPBCPowerSequenceElement, S2MessageComponent["PPBCPowerSequenceElement"]
-):
+class PPBCPowerSequenceElement(GenPPBCPowerSequenceElement, S2MessageComponent):
     model_config = GenPPBCPowerSequenceElement.model_config
     model_config["validate_assignment"] = True
 
-    duration: Duration = GenPPBCPowerSequenceElement.model_fields["duration"]  # type: ignore[assignment]
-    power_values: List[PowerForecastValue] = GenPPBCPowerSequenceElement.model_fields[
+    duration: Duration = GenPPBCPowerSequenceElement.model_fields["duration"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    power_values: List[PowerForecastValue] = GenPPBCPowerSequenceElement.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "power_values"
     ]  # type: ignore[assignment]

s2python/ppbc/ppbc_schedule_instruction.py

@@ -10,24 +10,22 @@ from s2python.validate_values_mixin import (
 
 
 @catch_and_convert_exceptions
-class PPBCScheduleInstruction(
-    GenPPBCScheduleInstruction, S2MessageComponent["PPBCScheduleInstruction"]
-):
+class PPBCScheduleInstruction(GenPPBCScheduleInstruction, S2MessageComponent):
     model_config = GenPPBCScheduleInstruction.model_config
     model_config["validate_assignment"] = True
 
-    id: uuid.UUID = GenPPBCScheduleInstruction.model_fields["id"]  # type: ignore[assignment]
+    id: uuid.UUID = GenPPBCScheduleInstruction.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
 
-    power_profile_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields[
+    power_profile_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "power_profile_id"
     ]  # type: ignore[assignment]
 
-    message_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields["message_id"]  # type: ignore[assignment]
+    message_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields["message_id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
 
-    sequence_container_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields[
+    sequence_container_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "sequence_container_id"
     ]  # type: ignore[assignment]
 
-    power_sequence_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields[
+    power_sequence_id: uuid.UUID = GenPPBCScheduleInstruction.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "power_sequence_id"
     ]  # type: ignore[assignment]

s2python/ppbc/ppbc_start_interruption_instruction.py

@@ -11,22 +11,20 @@ from s2python.validate_values_mixin import (
 
 
 @catch_and_convert_exceptions
-class PPBCStartInterruptionInstruction(
-    GenPPBCStartInterruptionInstruction, S2MessageComponent["PPBCStartInterruptionInstruction"]
-):
+class PPBCStartInterruptionInstruction(GenPPBCStartInterruptionInstruction, S2MessageComponent):
     model_config = GenPPBCStartInterruptionInstruction.model_config
     model_config["validate_assignment"] = True
 
-    id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields["id"]  # type: ignore[assignment]
-    power_profile_id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields[
+    id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    power_profile_id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "power_profile_id"
     ]  # type: ignore[assignment]
-    sequence_container_id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields[
+    sequence_container_id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "sequence_container_id"
     ]  # type: ignore[assignment]
-    power_sequence_id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields[
+    power_sequence_id: uuid.UUID = GenPPBCStartInterruptionInstruction.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "power_sequence_id"
     ]  # type: ignore[assignment]
-    abnormal_condition: bool = GenPPBCStartInterruptionInstruction.model_fields[
+    abnormal_condition: bool = GenPPBCStartInterruptionInstruction.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "abnormal_condition"
     ]  # type: ignore[assignment]

s2python/s2_connection.py

@@ -1,14 +1,24 @@
+try:
+    import websockets
+except ImportError as exc:
+    raise ImportError(
+        "The 'websockets' package is required. Run 'pip install s2-python[ws]' to use this feature."
+    ) from exc
+
 import asyncio
 import json
 import logging
 import time
 import threading
 import uuid
+import ssl
 from dataclasses import dataclass
-from typing import Optional, List, Type, Dict, Callable, Awaitable, Union
+from typing import Any, Optional, List, Type, Dict, Callable, Awaitable, Union
 
-import websockets
-from websockets.asyncio.client import ClientConnection as WSConnection, connect as ws_connect
+from websockets.asyncio.client import (
+    ClientConnection as WSConnection,
+    connect as ws_connect,
+)
 
 from s2python.common import (
     ReceptionStatusValues,
@@ -35,7 +45,7 @@ logger = logging.getLogger("s2python")
 
 @dataclass
 class AssetDetails:  # pylint: disable=too-many-instance-attributes
-    resource_id: str
+    resource_id: uuid.UUID
 
     provides_forecast: bool
     provides_power_measurements: List[CommodityQuantity]
@@ -55,7 +65,8 @@ class AssetDetails:  # pylint: disable=too-many-instance-attributes
     ) -> ResourceManagerDetails:
         return ResourceManagerDetails(
             available_control_types=[
-                control_type.get_protocol_control_type() for control_type in control_types
+                control_type.get_protocol_control_type()
+                for control_type in control_types
             ],
             currency=self.currency,
             firmware_version=self.firmware_version,
@@ -92,7 +103,7 @@ class SendOkay:
         self.status_is_send.set()
 
         await self.connection.respond_with_reception_status(
-            subject_message_id=str(self.subject_message_id),
+            subject_message_id=self.subject_message_id,
             status=ReceptionStatusValues.OK,
             diagnostic_label="Processed okay.",
         )
@@ -101,7 +112,7 @@ class SendOkay:
         self.status_is_send.set()
 
         self.connection.respond_with_reception_status_sync(
-            subject_message_id=str(self.subject_message_id),
+            subject_message_id=self.subject_message_id,
             status=ReceptionStatusValues.OK,
             diagnostic_label="Processed okay.",
         )
@@ -158,7 +169,7 @@ class MessageHandlers:
             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, union-attr]
+                        subject_message_id=msg.message_id,  # type: ignore[attr-defined, union-attr]
                         status=ReceptionStatusValues.PERMANENT_ERROR,
                         diagnostic_label=f"While processing message {msg.message_id} "  # type: ignore[attr-defined, union-attr]  # pylint: disable=line-too-long
                         f"an unrecoverable error occurred.",
@@ -170,7 +181,9 @@ class MessageHandlers:
                 type(msg),
             )
 
-    def register_handler(self, msg_type: Type[S2Message], handler: S2MessageHandler) -> None:
+    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.
@@ -198,6 +211,8 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
     _eventloop: asyncio.AbstractEventLoop
     _stop_event: asyncio.Event
     _restart_connection_event: asyncio.Event
+    _verify_certificate: bool
+    _bearer_token: Optional[str]
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -206,6 +221,8 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
         control_types: List[S2ControlType],
         asset_details: AssetDetails,
         reconnect: bool = False,
+        verify_certificate: bool = True,
+        bearer_token: Optional[str] = None,
     ) -> None:
         self.url = url
         self.reconnect = reconnect
@@ -221,10 +238,14 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
         self.control_types = control_types
         self.role = role
         self.asset_details = asset_details
+        self._verify_certificate = verify_certificate
 
-        self._handlers.register_handler(SelectControlType, self.handle_select_control_type_as_rm)
+        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)
+        self._bearer_token = bearer_token
 
     def start_as_rm(self) -> None:
         self._run_eventloop(self._run_as_rm())
@@ -247,8 +268,7 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
         """
         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!"
+                "Do not call stop from the thread running the S2 connection. This results in an infinite block!"
             )
         if self._eventloop.is_running():
             asyncio.run_coroutine_threadsafe(self._do_stop(), self._eventloop).result()
@@ -304,7 +324,10 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
                     await task
                 except asyncio.CancelledError:
                     pass
-                except (websockets.ConnectionClosedError, websockets.ConnectionClosedOK):
+                except (
+                    websockets.ConnectionClosedError,
+                    websockets.ConnectionClosedOK,
+                ):
                     logger.info("The other party closed the websocket connection.")
 
             for task in pending:
@@ -319,17 +342,33 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
 
     async def _connect_ws(self) -> None:
         try:
-            self.ws = await ws_connect(uri=self.url)
+            # set up connection arguments for SSL and bearer token, if required
+            connection_kwargs: Dict[str, Any] = {}
+            if self.url.startswith("wss://") and not self._verify_certificate:
+                connection_kwargs["ssl"] = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+                connection_kwargs["ssl"].check_hostname = False
+                connection_kwargs["ssl"].verify_mode = ssl.CERT_NONE
+
+            if self._bearer_token:
+                connection_kwargs["additional_headers"] = {
+                    "Authorization": f"Bearer {self._bearer_token}"
+                }
+
+            self.ws = await ws_connect(uri=self.url, **connection_kwargs)
         except (EOFError, OSError) as e:
             logger.info("Could not connect due to: %s", str(e))
 
     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]
+                message_id=uuid.uuid4(),
+                role=self.role,
+                supported_protocol_versions=[S2_VERSION],
             )
         )
-        logger.debug("Send handshake to CEM. Expecting Handshake and HandshakeResponse from CEM.")
+        logger.debug(
+            "Send handshake to CEM. Expecting Handshake and HandshakeResponse from CEM."
+        )
 
         await self._handle_received_messages()
 
@@ -338,7 +377,8 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
     ) -> None:
         if not isinstance(message, Handshake):
             logger.error(
-                "Handler for Handshake received a message of the wrong type: %s", type(message)
+                "Handler for Handshake received a message of the wrong type: %s",
+                type(message),
             )
             return
 
@@ -361,7 +401,9 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
 
         logger.debug("Received HandshakeResponse %s", message.to_json())
 
-        logger.debug("CEM selected to use version %s", message.selected_protocol_version)
+        logger.debug(
+            "CEM selected to use version %s", message.selected_protocol_version
+        )
         await send_okay
         logger.debug("Handshake complete. Sending first ResourceManagerDetails.")
 
@@ -381,22 +423,29 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
 
         await send_okay
 
-        logger.debug("CEM selected control type %s. Activating control type.", message.control_type)
+        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
+        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)
+            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)
+            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:
@@ -418,7 +467,7 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
             except json.JSONDecodeError:
                 await self._send_and_forget(
                     ReceptionStatus(
-                        subject_message_id="00000000-0000-0000-0000-000000000000",
+                        subject_message_id=uuid.UUID("00000000-0000-0000-0000-000000000000"),
                         status=ReceptionStatusValues.INVALID_DATA,
                         diagnostic_label="Not valid json.",
                     )
@@ -434,7 +483,7 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
                     )
                 else:
                     await self.respond_with_reception_status(
-                        subject_message_id="00000000-0000-0000-0000-000000000000",
+                        subject_message_id=uuid.UUID("00000000-0000-0000-0000-000000000000"),
                         status=ReceptionStatusValues.INVALID_DATA,
                         diagnostic_label="Message appears valid json but could not find a message_id field.",
                     )
@@ -465,9 +514,11 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
             self._restart_connection_event.set()
 
     async def respond_with_reception_status(
-        self, subject_message_id: str, status: ReceptionStatusValues, diagnostic_label: str
+        self, subject_message_id: uuid.UUID, status: ReceptionStatusValues, diagnostic_label: str
     ) -> None:
-        logger.debug("Responding to message %s with status %s", subject_message_id, status)
+        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,
@@ -477,15 +528,20 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
         )
 
     def respond_with_reception_status_sync(
-        self, subject_message_id: str, status: ReceptionStatusValues, diagnostic_label: str
+        self, subject_message_id: uuid.UUID, status: ReceptionStatusValues, diagnostic_label: str
     ) -> None:
         asyncio.run_coroutine_threadsafe(
-            self.respond_with_reception_status(subject_message_id, status, diagnostic_label),
+            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
+        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(
@@ -506,12 +562,17 @@ class S2Connection:  # pylint: disable=too-many-instance-attributes
             raise
 
         if reception_status.status != ReceptionStatusValues.OK and raise_on_error:
-            raise RuntimeError(f"ReceptionStatus was not OK but rather {reception_status.status}")
+            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
+        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(

s2python/s2_control_type.py

@@ -4,6 +4,7 @@ import typing
 from s2python.common import ControlType as ProtocolControlType
 from s2python.frbc import FRBCInstruction
 from s2python.ppbc import PPBCScheduleInstruction
+from s2python.ombc import OMBCInstruction
 from s2python.message import S2Message
 
 if typing.TYPE_CHECKING:
@@ -66,6 +67,41 @@ class PPBCControlType(S2ControlType):
         """Overwrite with the actual deactivation logic of your Resource Manager for this particular control type."""
 
 
+class OMBCControlType(S2ControlType):
+    def get_protocol_control_type(self) -> ProtocolControlType:
+        return ProtocolControlType.OPERATION_MODE_BASED_CONTROL
+
+    def register_handlers(self, handlers: "MessageHandlers") -> None:
+        handlers.register_handler(OMBCInstruction, 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:
+        """Overwrite with the actual dctivation logic of your Resource Manager for this particular control type."""
+
+    @abc.abstractmethod
+    def deactivate(self, conn: "S2Connection") -> None:
+        """Overwrite with the actual deactivation logic of your Resource Manager for this particular control type."""
+
+
+class PEBCControlType(S2ControlType):
+    def get_protocol_control_type(self) -> ProtocolControlType:
+        return ProtocolControlType.POWER_ENVELOPE_BASED_CONTROL
+
+    def register_handlers(self, handlers: "MessageHandlers") -> None:
+        pass
+
+    @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

s2python/s2_parser.py

@@ -24,6 +24,7 @@ from s2python.frbc import (
     FRBCTimerStatus,
     FRBCUsageForecast,
 )
+from s2python.pebc import PEBCPowerConstraints, PEBCEnergyConstraint, PEBCInstruction
 from s2python.ppbc import PPBCScheduleInstruction
 
 from s2python.message import S2Message
@@ -48,6 +49,9 @@ TYPE_TO_MESSAGE_CLASS: Dict[str, Type[S2Message]] = {
     "FRBC.TimerStatus": FRBCTimerStatus,
     "FRBC.UsageForecast": FRBCUsageForecast,
     "PPBC.ScheduleInstruction": PPBCScheduleInstruction,
+    "PEBC.PowerConstraints": PEBCPowerConstraints,
+    "PEBC.Instruction": PEBCInstruction,
+    "PEBC.EnergyConstraint": PEBCEnergyConstraint,
     "Handshake": Handshake,
     "HandshakeResponse": HandshakeResponse,
     "InstructionStatusUpdate": InstructionStatusUpdate,

s2python/s2_validation_error.py

@@ -10,4 +10,6 @@ class S2ValidationError(Exception):
     class_: Optional[Type]
     obj: object
     msg: str
-    pydantic_validation_error: Union[ValidationErrorV1, ValidationError, TypeError, None]
+    pydantic_validation_error: Union[
+        ValidationErrorV1, ValidationError, TypeError, None
+    ]

s2python/validate_values_mixin.py

@@ -1,22 +1,34 @@
-from typing import TypeVar, Generic, Type, Callable, Any, Union, AbstractSet, Mapping, List, Dict
+from typing import (
+    TypeVar,
+    Type,
+    Callable,
+    Any,
+    Union,
+    AbstractSet,
+    Mapping,
+    List,
+    Dict,
+)
+
+from typing_extensions import Self
 
-from pydantic import BaseModel, ValidationError  # pylint: disable=no-name-in-module
 from pydantic.v1.error_wrappers import display_errors  # pylint: disable=no-name-in-module
 
+from pydantic import (  # pylint: disable=no-name-in-module
+    BaseModel,
+    ValidationError,
+)
+
 from s2python.s2_validation_error import S2ValidationError
 
-B_co = TypeVar("B_co", bound=BaseModel, covariant=True)
 
 IntStr = Union[int, str]
 AbstractSetIntStr = AbstractSet[IntStr]
 MappingIntStrAny = Mapping[IntStr, Any]
 
 
-C = TypeVar("C", bound="BaseModel")
-
-
-class S2MessageComponent(BaseModel, Generic[C]):
-    def to_json(self: C) -> str:
+class S2MessageComponent(BaseModel):
+    def to_json(self) -> str:
         try:
             return self.model_dump_json(by_alias=True, exclude_none=True)
         except (ValidationError, TypeError) as e:
@@ -24,17 +36,17 @@ class S2MessageComponent(BaseModel, Generic[C]):
                 type(self), self, "Pydantic raised a format validation error.", e
             ) from e
 
-    def to_dict(self: C) -> Dict:
+    def to_dict(self) -> Dict[str, Any]:
         return self.model_dump()
 
     @classmethod
-    def from_json(cls: Type[C], json_str: str) -> C:
-        gen_model: C = cls.model_validate_json(json_str)
+    def from_json(cls, json_str: str) -> Self:
+        gen_model = cls.model_validate_json(json_str)
         return gen_model
 
     @classmethod
-    def from_dict(cls: Type[C], json_dict: dict) -> C:
-        gen_model: C = cls.model_validate(json_dict)
+    def from_dict(cls, json_dict: Dict[str, Any]) -> Self:
+        gen_model = cls.model_validate(json_dict)
         return gen_model
 
 
@@ -59,7 +71,10 @@ def convert_to_s2exception(f: Callable) -> Callable:
     return inner
 
 
-def catch_and_convert_exceptions(input_class: Type[S2MessageComponent[B_co]]) -> Type[S2MessageComponent[B_co]]:
+S = TypeVar("S", bound=S2MessageComponent)
+
+
+def catch_and_convert_exceptions(input_class: Type[S]) -> Type[S]:
     input_class.__init__ = convert_to_s2exception(input_class.__init__)  # type: ignore[method-assign]
     input_class.__setattr__ = convert_to_s2exception(input_class.__setattr__)  # type: ignore[method-assign]
     input_class.model_validate_json = convert_to_s2exception(  # type: ignore[method-assign]

s2_python-0.4.1.dist-info/RECORD

@@ -1,66 +0,0 @@
-s2python/__init__.py,sha256=e5lwvqsPl-z7IfEd0hRQhLBRKBYcuw2eqrecXnMfLdg,384
-s2python/message.py,sha256=Id-CleYk6ClVh3o5meVtRECLNwQHlyddNSOq0-d2bZk,1027
-s2python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-s2python/reception_status_awaiter.py,sha256=jKMliFk1XxwsEGtx3vFESbJhUtClB7cTu-td90-qBN8,2137
-s2python/s2_connection.py,sha256=CTTTGzJ6IG9PcQpC5XtnThaYQRpp66gQrauPK8KygOE,20166
-s2python/s2_control_type.py,sha256=4L6o_QG9ilYA8c3QWpSjc77xwxEHHsAGZO8WQDgxDr0,2860
-s2python/s2_parser.py,sha256=x2JSCSEvXMCt-0kPDH4zER--CsyFYyRAaezr76V_8Qc,4354
-s2python/s2_validation_error.py,sha256=BkOLoNsrcQ3MzdCYaPDgs1Wu6lPdlQDpZsTpykKGQmE,384
-s2python/utils.py,sha256=QX9b-mi-H_YUGTmGmJsrAbaWWM3dgaoaRLRXHHlaZDE,212
-s2python/validate_values_mixin.py,sha256=3WbauPprzWpGdyDUYPoELICi2NbHrCFzlQ7AtrpDSis,2568
-s2python/version.py,sha256=IBzoytgbYYYekQnSTfSmWeYAZ4c_yUFU2oLIAG4UYjs,45
-s2python/common/__init__.py,sha256=yEAXCS59XpNOEXbEXoN04SwultP-3evgVzFuEUSgB5I,1345
-s2python/common/duration.py,sha256=5_zi0wv98dr8lHXh2RdHATzW4Un8ZNUx4-zaI1t77Ak,667
-s2python/common/handshake.py,sha256=bsx64flKxVUUMT18O47pV1pnnpXcAGXMJbRi9q4GjwU,467
-s2python/common/handshake_response.py,sha256=5cAbtLTZ8fkhUw-XdMlGBro3XKWqXXLw3YUavvwLYNg,523
-s2python/common/instruction_status_update.py,sha256=lo5HxoEGFp8bU0-AQ7bNxuDj1StZ73GE_2sGDA7o5vI,692
-s2python/common/number_range.py,sha256=N0OUoGtkdYg4GDUwvVHKLjdXxcy9mijgwqmmA079P6k,741
-s2python/common/power_forecast.py,sha256=C0D6XOphdcEVjfb0py-l2zLnNC-udWmlDD7g2Hre2uo,704
-s2python/common/power_forecast_element.py,sha256=M3weDKlBASjS_VHt4XKdms2fpxEZy17kWuLTUXsFibU,805
-s2python/common/power_forecast_value.py,sha256=im5kLyTfDjLuODFWoIuVgVxKjX2FpyPXYoxonjuOpu0,411
-s2python/common/power_measurement.py,sha256=mMVpe3T86Xu6ctA2Rpc50aB4WS7xuLXgGVSbB4lykHQ,693
-s2python/common/power_range.py,sha256=FKhJRkT3dzUCeK8P3mrcRVtJHPf2WH-eQDottvEMpBs,686
-s2python/common/power_value.py,sha256=ujo0yxHnAd-LCIQQuIpNU01jv611UCbcXKl8ilQIILY,363
-s2python/common/reception_status.py,sha256=HXdaTu5B2iuHb1pg8d5TMprfi80rUmCgCxrrDFLJB0w,525
-s2python/common/resource_manager_details.py,sha256=QTW6VTn-Y_fvVKX6qGgDMuvry5twmDqHjRvOZXgkuLI,1044
-s2python/common/revoke_object.py,sha256=7OVNuwu5aMfZ3GJ_b_SRNoTxiX80FY9obp7JHIySzaY,585
-s2python/common/role.py,sha256=eHKwnie_7eK8k1CNA7S0TbwmkQR84Pzkwdk8aUaUldw,327
-s2python/common/select_control_type.py,sha256=Rbvem30LrrPYTSjwspc-PJyxoNScv9XRVXJ58-WRotk,523
-s2python/common/session_request.py,sha256=ztbvGjMwiEmdJ_ToFuPV9Lj_IHJ78fP7IsCt8rMvMu8,502
-s2python/common/support.py,sha256=Kbrf_KGB45Wfr8j2pqDe1lLde6CIr3nl_LYkWnilmV0,1015
-s2python/common/timer.py,sha256=PWJjHXfL6yr2VQ8O2HwtYB0o3Jw4TdP2iMX2Wdp7Ic4,556
-s2python/common/transition.py,sha256=2v0fkxudPhVqmnd-WajJhBsYRnJLAqJU9z1eqQJy8zw,1064
-s2python/frbc/__init__.py,sha256=ROV3qZoldPkdgVFfMQr5Mf3GDfBzXaMfhNNCuXY6T0s,1104
-s2python/frbc/frbc_actuator_description.py,sha256=fsgYdKvxZnUCuUuyoN0Ibu5FoA0vUBSrKy6WQJGBfGk,6166
-s2python/frbc/frbc_actuator_status.py,sha256=cPyAz0B0rThfueKr3CWx61E3eJ8Lp29a-nJPyTPpbls,973
-s2python/frbc/frbc_fill_level_target_profile.py,sha256=suRBgT8b9HQjfafW-sjqzjFpgJ2vOf73nmL5-Q6WhOo,880
-s2python/frbc/frbc_fill_level_target_profile_element.py,sha256=V7O7oDDfifLcJsSXYWEd00X3C2TPoU8TcrRu2yLWVVU,1280
-s2python/frbc/frbc_instruction.py,sha256=Q8w9KB4x6mGsLR-3ADzsyWWf0-uTWGZ31rnKGC9TkIc,809
-s2python/frbc/frbc_leakage_behaviour.py,sha256=E23McMu4zbjDIUR_MNBlyUuh1chGM-EKTMuiHqjV_wg,794
-s2python/frbc/frbc_leakage_behaviour_element.py,sha256=B3Tzlu3iMVV3NA1WJds_LDl3T_lBGL3HjGiEin02_pQ,1103
-s2python/frbc/frbc_operation_mode.py,sha256=w0--55ZByWQukbotR6VpoL9GvNbeNyHcs3NqHAzjq6w,1899
-s2python/frbc/frbc_operation_mode_element.py,sha256=64_FJzfCRoUgRCdfA1HpLO9lTE1WBxL3Pbn0vaNeX8c,1073
-s2python/frbc/frbc_storage_description.py,sha256=Jc0zpAwf3E7Grl6v0fkSa4yA8-2-klO1aY-50l-u56E,622
-s2python/frbc/frbc_storage_status.py,sha256=h6cHTb7Msw5TckPzKsiI3KTSa7Hr5BcXIelF8gmFIdw,523
-s2python/frbc/frbc_system_description.py,sha256=_scCAVe4sHEhQMHkDvD2pKGnGLzdnm4uARbdcw0inKk,980
-s2python/frbc/frbc_timer_status.py,sha256=sRsvXxsT_TDlPiacLkZlCZM3y36NZRGqj6RKJeil-yc,711
-s2python/frbc/frbc_usage_forecast.py,sha256=MWY4Nr2T9NGjQhf7rxTtkqnuSdApTjro81-o_buLABk,747
-s2python/frbc/frbc_usage_forecast_element.py,sha256=wQJCBoYFt2HXNaKNL3vK_FpTx5wXvRH03NOw_JWOal8,601
-s2python/frbc/rm.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-s2python/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-s2python/generated/gen_s2.py,sha256=eg9J0pcWxCy0oXO8eq9AtoB-GONHZLNd8JANpMhKQCQ,63573
-s2python/ppbc/__init__.py,sha256=Rnfl_1n0gkc9mASSzBBMFEKYzJqugV5POtttjLWx_pI,665
-s2python/ppbc/ppbc_end_interruption_instruction.py,sha256=0ZXQATN8L35xm9-QWCU8ftnU1_Na9Oq3HzSYna_SMcU,1197
-s2python/ppbc/ppbc_power_profile_definition.py,sha256=3y5lw7eeDVVa6JecoGlZrqr6bcQRaDoLO9EISPle3ks,991
-s2python/ppbc/ppbc_power_profile_status.py,sha256=E-mNhdaPiuB6qFsG_F1ftIlwaxF75972nvIHKSpau5w,767
-s2python/ppbc/ppbc_power_sequence.py,sha256=DCeNstEAUvwCiN1bKDd85gE6pgiataJbwGui6pEk5_M,1158
-s2python/ppbc/ppbc_power_sequence_container.py,sha256=L0kD7zkJj9OBafzzA6zcUgFnn5wCx6VzlGoLX3GDf9U,829
-s2python/ppbc/ppbc_power_sequence_container_status.py,sha256=3Wq3NasIh_mLDEZvnNsgB8AY8CSd4qQKpPJxXwS7ZiA,1160
-s2python/ppbc/ppbc_power_sequence_element.py,sha256=sQMJlIRhMhj_crpaRFDWhbP4eCCw4haFq5sD-ptQsS0,797
-s2python/ppbc/ppbc_schedule_instruction.py,sha256=yHDO5omwKYV_P_v70D4gZ26K5MEIFFboX1sp3J6_atA,1098
-s2python/ppbc/ppbc_start_interruption_instruction.py,sha256=6Atu6E-Hfs8S2KIdHdGJd9F5gRFqZLNb-dpnphj8hNU,1219
-s2_python-0.4.1.dist-info/METADATA,sha256=CJILWeqNUp0VSPUdlLafySNPJag6SvoeYAPO9b5_cQs,3595
-s2_python-0.4.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-s2_python-0.4.1.dist-info/entry_points.txt,sha256=feX-xmgJZgSe5-jxMgFKPKCJz4Ys3eQcGrsXsirNZyM,61
-s2_python-0.4.1.dist-info/top_level.txt,sha256=OLFq0oDhr77Mp-EYLEcWk5P3jvooOt4IHkTI5KYJMc8,9
-s2_python-0.4.1.dist-info/RECORD,,