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

s2python/message.py

@@ -1,33 +1,86 @@
 from typing import Union
 
 from s2python.frbc import (
+    FRBCActuatorDescription,
     FRBCActuatorStatus,
     FRBCFillLevelTargetProfile,
+    FRBCFillLevelTargetProfileElement,
     FRBCInstruction,
     FRBCLeakageBehaviour,
+    FRBCLeakageBehaviourElement,
+    FRBCOperationMode,
+    FRBCOperationModeElement,
+    FRBCStorageDescription,
     FRBCStorageStatus,
     FRBCSystemDescription,
     FRBCTimerStatus,
-    FRBCUsageForecast
+    FRBCUsageForecast,
+    FRBCUsageForecastElement,
 )
 from s2python.ppbc import (
+    PPBCEndInterruptionInstruction,
+    PPBCPowerProfileDefinition,
+    PPBCPowerSequenceContainer,
+    PPBCPowerSequence,
+    PPBCPowerProfileStatus,
+    PPBCPowerSequenceContainerStatus,
+    PPBCPowerSequenceElement,
     PPBCScheduleInstruction,
+    PPBCStartInterruptionInstruction,
+)
+from s2python.ddbc import (
+    DDBCActuatorDescription,
+    DDBCActuatorStatus,
+    DDBCAverageDemandRateForecast,
+    DDBCAverageDemandRateForecastElement,
+    DDBCInstruction,
+    DDBCOperationMode,
+    DDBCSystemDescription,
+    DDBCTimerStatus,
+)
+from s2python.ombc import (
+    OMBCInstruction,
+    OMBCOperationMode,
+    OMBCTimerStatus,
+    OMBCStatus,
+    OMBCSystemDescription,
 )
 
+from s2python.pebc import (
+    PEBCAllowedLimitRange,
+    PEBCEnergyConstraint,
+    PEBCInstruction,
+    PEBCPowerConstraints,
+    PEBCPowerEnvelope,
+    PEBCPowerEnvelopeElement,
+)
 from s2python.common import (
+    Duration,
     Handshake,
     HandshakeResponse,
     InstructionStatusUpdate,
+    NumberRange,
     PowerForecast,
+    PowerForecastElement,
+    PowerForecastValue,
     PowerMeasurement,
+    PowerRange,
+    PowerValue,
     ReceptionStatus,
     ResourceManagerDetails,
     RevokeObject,
+    Role,
     SelectControlType,
-    SessionRequest
+    SessionRequest,
+    Timer,
+    Transition,
 )
 
 S2Message = Union[
+    DDBCAverageDemandRateForecast,
+    DDBCInstruction,
+    DDBCSystemDescription,
+    DDBCTimerStatus,
     FRBCActuatorStatus,
     FRBCFillLevelTargetProfile,
     FRBCInstruction,
@@ -36,15 +89,57 @@ S2Message = Union[
     FRBCSystemDescription,
     FRBCTimerStatus,
     FRBCUsageForecast,
+    OMBCSystemDescription,
+    OMBCStatus,
+    OMBCTimerStatus,
+    OMBCInstruction,
+    PEBCPowerConstraints,
+    PPBCEndInterruptionInstruction,
+    PPBCPowerProfileDefinition,
+    PPBCPowerProfileStatus,
     PPBCScheduleInstruction,
+    PPBCStartInterruptionInstruction,
+    ResourceManagerDetails,
+    RevokeObject,
+    SelectControlType,
+    SessionRequest,
+    DDBCActuatorStatus,
+    PEBCEnergyConstraint,
+    PEBCInstruction,
     Handshake,
     HandshakeResponse,
     InstructionStatusUpdate,
     PowerForecast,
     PowerMeasurement,
     ReceptionStatus,
-    ResourceManagerDetails,
-    RevokeObject,
-    SelectControlType,
-    SessionRequest,
+]
+
+S2MessageElement = Union[
+    DDBCActuatorDescription,
+    DDBCAverageDemandRateForecastElement,
+    DDBCOperationMode,
+    FRBCActuatorDescription,
+    FRBCFillLevelTargetProfileElement,
+    FRBCLeakageBehaviourElement,
+    FRBCOperationMode,
+    FRBCOperationModeElement,
+    FRBCStorageDescription,
+    FRBCUsageForecastElement,
+    OMBCOperationMode,
+    PEBCAllowedLimitRange,
+    PEBCPowerEnvelope,
+    PEBCPowerEnvelopeElement,
+    PPBCPowerSequenceContainer,
+    PPBCPowerSequence,
+    PPBCPowerSequenceContainerStatus,
+    PPBCPowerSequenceElement,
+    Duration,
+    NumberRange,
+    PowerForecastElement,
+    PowerForecastValue,
+    PowerRange,
+    PowerValue,
+    Role,
+    Timer,
+    Transition,
 ]

s2python/ombc/__init__.py

@@ -0,0 +1,5 @@
+from s2python.ombc.ombc_instruction import OMBCInstruction
+from s2python.ombc.ombc_operation_mode import OMBCOperationMode
+from s2python.ombc.ombc_status import OMBCStatus
+from s2python.ombc.ombc_system_description import OMBCSystemDescription
+from s2python.ombc.ombc_timer_status import OMBCTimerStatus

s2python/ombc/ombc_instruction.py

@@ -0,0 +1,19 @@
+import uuid
+
+from s2python.generated.gen_s2 import OMBCInstruction as GenOMBCInstruction
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class OMBCInstruction(GenOMBCInstruction, S2MessageComponent):
+    model_config = GenOMBCInstruction.model_config
+    model_config["validate_assignment"] = True
+
+    id: uuid.UUID = GenOMBCInstruction.model_fields["id"]  # type: ignore[assignment]
+    message_id: uuid.UUID = GenOMBCInstruction.model_fields["message_id"]  # type: ignore[assignment]
+    abnormal_condition: bool = GenOMBCInstruction.model_fields["abnormal_condition"]  # type: ignore[assignment]
+    operation_mode_factor: float = GenOMBCInstruction.model_fields["operation_mode_factor"]  # type: ignore[assignment]
+    operation_mode_id: uuid.UUID = GenOMBCInstruction.model_fields["operation_mode_id"]  # type: ignore[assignment]

s2python/ombc/ombc_operation_mode.py

@@ -0,0 +1,25 @@
+from typing import List
+import uuid
+
+from s2python.generated.gen_s2 import OMBCOperationMode as GenOMBCOperationMode
+from s2python.common.power_range import PowerRange
+
+
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class OMBCOperationMode(GenOMBCOperationMode, S2MessageComponent):
+    model_config = GenOMBCOperationMode.model_config
+    model_config["validate_assignment"] = True
+
+    id: uuid.UUID = GenOMBCOperationMode.model_fields["id"]  # type: ignore[assignment]
+    power_ranges: List[PowerRange] = GenOMBCOperationMode.model_fields[
+        "power_ranges"
+    ]  # type: ignore[assignment]
+    abnormal_condition_only: bool = GenOMBCOperationMode.model_fields[
+        "abnormal_condition_only"
+    ]  # type: ignore[assignment]

s2python/ombc/ombc_status.py

@@ -0,0 +1,17 @@
+import uuid
+
+from s2python.generated.gen_s2 import OMBCStatus as GenOMBCStatus
+
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class OMBCStatus(GenOMBCStatus, S2MessageComponent):
+    model_config = GenOMBCStatus.model_config
+    model_config["validate_assignment"] = True
+
+    message_id: uuid.UUID = GenOMBCStatus.model_fields["message_id"]  # type: ignore[assignment]
+    operation_mode_factor: float = GenOMBCStatus.model_fields["operation_mode_factor"]  # type: ignore[assignment]

s2python/ombc/ombc_system_description.py

@@ -0,0 +1,25 @@
+from typing import List
+import uuid
+
+from s2python.generated.gen_s2 import OMBCSystemDescription as GenOMBCSystemDescription
+from s2python.ombc.ombc_operation_mode import OMBCOperationMode
+from s2python.common.transition import Transition
+from s2python.common.timer import Timer
+
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class OMBCSystemDescription(GenOMBCSystemDescription, S2MessageComponent):
+    model_config = GenOMBCSystemDescription.model_config
+    model_config["validate_assignment"] = True
+
+    message_id: uuid.UUID = GenOMBCSystemDescription.model_fields["message_id"]  # type: ignore[assignment]
+    operation_modes: List[OMBCOperationMode] = GenOMBCSystemDescription.model_fields[
+        "operation_modes"
+    ]  # type: ignore[assignment]
+    transitions: List[Transition] = GenOMBCSystemDescription.model_fields["transitions"]  # type: ignore[assignment]
+    timers: List[Timer] = GenOMBCSystemDescription.model_fields["timers"]  # type: ignore[assignment]

s2python/ombc/ombc_timer_status.py

@@ -0,0 +1,17 @@
+from uuid import UUID
+
+from s2python.generated.gen_s2 import OMBCTimerStatus as GenOMBCTimerStatus
+
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class OMBCTimerStatus(GenOMBCTimerStatus, S2MessageComponent):
+    model_config = GenOMBCTimerStatus.model_config
+    model_config["validate_assignment"] = True
+
+    message_id: UUID = GenOMBCTimerStatus.model_fields["message_id"]  # type: ignore[assignment]
+    timer_id: UUID = GenOMBCTimerStatus.model_fields["timer_id"]  # type: ignore[assignment]

s2python/pebc/__init__.py

@@ -0,0 +1,21 @@
+from s2python.pebc.pebc_allowed_limit_range import PEBCAllowedLimitRange
+from s2python.pebc.pebc_power_constraints import PEBCPowerConstraints
+from s2python.pebc.pebc_power_envelope import PEBCPowerEnvelope
+from s2python.pebc.pebc_power_envelope_element import PEBCPowerEnvelopeElement
+from s2python.pebc.pebc_energy_constraint import PEBCEnergyConstraint
+from s2python.generated.gen_s2 import (
+    PEBCPowerEnvelopeConsequenceType,
+    PEBCPowerEnvelopeLimitType,
+)
+from s2python.pebc.pebc_instruction import PEBCInstruction
+
+__all__ = [
+    "PEBCAllowedLimitRange",
+    "PEBCPowerConstraints",
+    "PEBCPowerEnvelope",
+    "PEBCPowerEnvelopeElement",
+    "PEBCEnergyConstraint",
+    "PEBCPowerEnvelopeConsequenceType",
+    "PEBCPowerEnvelopeLimitType",
+    "PEBCInstruction",
+]

s2python/pebc/pebc_allowed_limit_range.py

@@ -0,0 +1,42 @@
+from typing_extensions import Self
+from pydantic import model_validator
+from s2python.generated.gen_s2 import (
+    PEBCAllowedLimitRange as GenPEBCAllowedLimitRange,
+    PEBCPowerEnvelopeLimitType as GenPEBCPowerEnvelopeLimitType,
+)
+from s2python.common import CommodityQuantity, NumberRange
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class PEBCAllowedLimitRange(GenPEBCAllowedLimitRange, S2MessageComponent):
+    model_config = GenPEBCAllowedLimitRange.model_config
+    model_config["validate_assignment"] = True
+
+    commodity_quantity: CommodityQuantity = GenPEBCAllowedLimitRange.model_fields[
+        "commodity_quantity"
+    ]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    limit_type: GenPEBCPowerEnvelopeLimitType = GenPEBCAllowedLimitRange.model_fields[
+        "limit_type"
+    ]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    range_boundary: NumberRange = GenPEBCAllowedLimitRange.model_fields["range_boundary"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    abnormal_condition_only: bool = [
+        GenPEBCAllowedLimitRange.model_fields["abnormal_condition_only"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    ]
+
+    @model_validator(mode="after")
+    def validate_range_boundary(self) -> Self:
+        # According to the specification "There must be at least one PEBC.AllowedLimitRange for the UPPER_LIMIT
+        # and at least one AllowedLimitRange for the LOWER_LIMIT." However for something that produces energy
+        # end_of_range=-2000 and start_of_range=0 is valid. Therefore absolute value used here.
+        if abs(self.range_boundary.start_of_range) > abs(
+            self.range_boundary.end_of_range
+        ):
+            raise ValueError(
+                self,
+                "The start of the range must be smaller or equal than the end of the range.",
+            )
+        return self

s2python/pebc/pebc_energy_constraint.py

@@ -0,0 +1,25 @@
+import uuid
+
+from s2python.generated.gen_s2 import (
+    PEBCEnergyConstraint as GenPEBCEnergyConstraint,
+)
+from s2python.common import CommodityQuantity
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class PEBCEnergyConstraint(GenPEBCEnergyConstraint, S2MessageComponent):
+    model_config = GenPEBCEnergyConstraint.model_config
+    model_config["validate_assignment"] = True
+
+    message_id: uuid.UUID = GenPEBCEnergyConstraint.model_fields["message_id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    id: uuid.UUID = GenPEBCEnergyConstraint.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+
+    upper_average_power: float = GenPEBCEnergyConstraint.model_fields["upper_average_power"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    lower_average_power: float = GenPEBCEnergyConstraint.model_fields["lower_average_power"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    commodity_quantity: CommodityQuantity = [
+        GenPEBCEnergyConstraint.model_fields["commodity_quantity"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    ]

s2python/pebc/pebc_instruction.py

@@ -0,0 +1,27 @@
+import uuid
+from typing import List
+
+from s2python.generated.gen_s2 import (
+    PEBCInstruction as GenPEBCInstruction,
+)
+from s2python.pebc.pebc_power_envelope import PEBCPowerEnvelope
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class PEBCInstruction(GenPEBCInstruction, S2MessageComponent):
+    model_config = GenPEBCInstruction.model_config
+    model_config["validate_assignment"] = True
+
+    message_id: uuid.UUID = GenPEBCInstruction.model_fields["message_id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    id: uuid.UUID = GenPEBCInstruction.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    power_constraints_id: uuid.UUID = [  # type: ignore[reportIncompatibleVariableOverride]
+        GenPEBCInstruction.model_fields["power_constraints_id"]  # type: ignore[assignment]
+    ]
+    power_envelopes: List[PEBCPowerEnvelope] = [  # type: ignore[reportIncompatibleVariableOverride]
+        GenPEBCInstruction.model_fields["power_envelopes"]  # type: ignore[assignment]
+    ]
+    abnormal_condition: bool = GenPEBCInstruction.model_fields["abnormal_condition"]  # type: ignore[assignment,reportIncompatibleVariableOverride]

s2python/pebc/pebc_power_constraints.py

@@ -0,0 +1,77 @@
+import uuid
+from typing import List, Dict, Tuple
+from typing_extensions import Self
+
+from pydantic import model_validator
+
+from s2python.common import CommodityQuantity
+from s2python.generated.gen_s2 import (
+    PEBCPowerConstraints as GenPEBCPowerConstraints,
+    PEBCPowerEnvelopeConsequenceType as GenPEBCPowerEnvelopeConsequenceType,
+    PEBCPowerEnvelopeLimitType,
+)
+from s2python.pebc.pebc_allowed_limit_range import PEBCAllowedLimitRange
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class PEBCPowerConstraints(GenPEBCPowerConstraints, S2MessageComponent):
+    model_config = GenPEBCPowerConstraints.model_config
+    model_config["validate_assignment"] = True
+
+    message_id: uuid.UUID = GenPEBCPowerConstraints.model_fields["message_id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    id: uuid.UUID = GenPEBCPowerConstraints.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    consequence_type: GenPEBCPowerEnvelopeConsequenceType = GenPEBCPowerConstraints.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
+        "consequence_type"
+    ]  # type: ignore[assignment]
+    allowed_limit_ranges: List[PEBCAllowedLimitRange] = GenPEBCPowerConstraints.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
+        "allowed_limit_ranges"
+    ]  # type: ignore[assignment]
+
+    @model_validator(mode="after")
+    def validate_has_one_upper_one_lower_limit_range(self) -> Self:
+
+        commodity_type_ranges: Dict[CommodityQuantity, Tuple[bool, bool]] = {}
+
+        for limit_range in self.allowed_limit_ranges:
+            current: Tuple[bool, bool] = commodity_type_ranges.get(
+                limit_range.commodity_quantity, (False, False)
+            )
+
+            if limit_range.limit_type == PEBCPowerEnvelopeLimitType.UPPER_LIMIT:
+                current = (
+                    True,
+                    current[1],
+                )
+
+            if limit_range.limit_type == PEBCPowerEnvelopeLimitType.LOWER_LIMIT:
+                current = (
+                    current[0],
+                    True,
+                )
+
+            commodity_type_ranges[limit_range.commodity_quantity] = current
+
+        valid = True
+
+        for upper, lower in commodity_type_ranges.values():
+            valid = valid and upper and lower
+
+        if not valid:
+            raise ValueError(
+                self,
+                "There shall be at least one PEBC.AllowedLimitRange for the UPPER_LIMIT and at least one AllowedLimitRange for the LOWER_LIMIT.",
+            )
+
+        return self
+
+    @model_validator(mode="after")
+    def validate_valid_until_after_valid_from(self) -> Self:
+        if self.valid_until is not None and self.valid_until < self.valid_from:
+            raise ValueError(
+                self, "valid_until cannot be set to a value that is before valid_from."
+            )
+        return self

s2python/pebc/pebc_power_envelope.py

@@ -0,0 +1,23 @@
+from typing import List
+from s2python.generated.gen_s2 import (
+    PEBCPowerEnvelope as GenPEBCPowerEnvelope,
+)
+from s2python.pebc.pebc_power_envelope_element import PEBCPowerEnvelopeElement
+from s2python.common import CommodityQuantity
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class PEBCPowerEnvelope(GenPEBCPowerEnvelope, S2MessageComponent):
+    model_config = GenPEBCPowerEnvelope.model_config
+    model_config["validate_assignment"] = True
+
+    commodity_quantity: CommodityQuantity = GenPEBCPowerEnvelope.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
+        "commodity_quantity"
+    ]  # type: ignore[assignment]
+    power_envelope_elements: List[PEBCPowerEnvelopeElement] = GenPEBCPowerEnvelope.model_fields[  # type: ignore[assignment,reportIncompatibleVariableOverride]
+        "power_envelope_elements"
+    ]  # type: ignore[assignment]

s2python/pebc/pebc_power_envelope_element.py

@@ -0,0 +1,16 @@
+from s2python.generated.gen_s2 import (
+    PEBCPowerEnvelopeElement as GenPEBCPowerEnvelopeElement,
+)
+from s2python.validate_values_mixin import (
+    catch_and_convert_exceptions,
+    S2MessageComponent,
+)
+
+
+@catch_and_convert_exceptions
+class PEBCPowerEnvelopeElement(GenPEBCPowerEnvelopeElement, S2MessageComponent):
+    model_config = GenPEBCPowerEnvelopeElement.model_config
+    model_config["validate_assignment"] = True
+
+    lower_limit: float = GenPEBCPowerEnvelopeElement.model_fields["lower_limit"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    upper_limit: float = GenPEBCPowerEnvelopeElement.model_fields["upper_limit"]  # type: ignore[assignment,reportIncompatibleVariableOverride]

s2python/ppbc/__init__.py

@@ -1,12 +1,21 @@
 from s2python.ppbc.ppbc_schedule_instruction import PPBCScheduleInstruction
-from s2python.ppbc.ppbc_end_interruption_instruction import (
-    PPBCEndInterruptionInstruction,
-)
+from s2python.ppbc.ppbc_end_interruption_instruction import PPBCEndInterruptionInstruction
 from s2python.ppbc.ppbc_power_profile_definition import PPBCPowerProfileDefinition
 from s2python.ppbc.ppbc_power_sequence_container import PPBCPowerSequenceContainer
 from s2python.ppbc.ppbc_power_sequence import PPBCPowerSequence
 from s2python.ppbc.ppbc_power_profile_status import PPBCPowerProfileStatus
-from s2python.ppbc.ppbc_power_sequence_container_status import (
-    PPBCPowerSequenceContainerStatus,
-)
+from s2python.ppbc.ppbc_power_sequence_container_status import PPBCPowerSequenceContainerStatus
 from s2python.ppbc.ppbc_power_sequence_element import PPBCPowerSequenceElement
+from s2python.ppbc.ppbc_start_interruption_instruction import PPBCStartInterruptionInstruction
+
+__all__ = [
+    "PPBCScheduleInstruction",
+    "PPBCEndInterruptionInstruction",
+    "PPBCPowerProfileDefinition",
+    "PPBCPowerSequenceContainer",
+    "PPBCPowerSequence",
+    "PPBCPowerProfileStatus",
+    "PPBCPowerSequenceContainerStatus",
+    "PPBCPowerSequenceElement",
+    "PPBCStartInterruptionInstruction",
+]

s2python/ppbc/ppbc_end_interruption_instruction.py

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

s2python/ppbc/ppbc_power_profile_definition.py

@@ -14,14 +14,12 @@ from s2python.ppbc.ppbc_power_sequence_container import PPBCPowerSequenceContain
 
 
 @catch_and_convert_exceptions
-class PPBCPowerProfileDefinition(
-    GenPPBCPowerProfileDefinition, S2MessageComponent["PPBCPowerProfileDefinition"]
-):
+class PPBCPowerProfileDefinition(GenPPBCPowerProfileDefinition, S2MessageComponent):
     model_config = GenPPBCPowerProfileDefinition.model_config
     model_config["validate_assignment"] = True
 
-    message_id: uuid.UUID = GenPPBCPowerProfileDefinition.model_fields["message_id"]  # type: ignore[assignment]
-    id: uuid.UUID = GenPPBCPowerProfileDefinition.model_fields["id"]  # type: ignore[assignment]
-    power_sequences_containers: List[PPBCPowerSequenceContainer] = (
+    message_id: uuid.UUID = GenPPBCPowerProfileDefinition.model_fields["message_id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    id: uuid.UUID = GenPPBCPowerProfileDefinition.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    power_sequences_containers: List[PPBCPowerSequenceContainer] = (  # type: ignore[reportIncompatibleVariableOverride]
         GenPPBCPowerProfileDefinition.model_fields["power_sequences_containers"]  # type: ignore[assignment]
     )

s2python/ppbc/ppbc_power_profile_status.py

@@ -15,12 +15,10 @@ from s2python.ppbc.ppbc_power_sequence_container_status import (
 
 
 @catch_and_convert_exceptions
-class PPBCPowerProfileStatus(
-    GenPPBCPowerProfileStatus, S2MessageComponent["PPBCPowerProfileStatus"]
-):
+class PPBCPowerProfileStatus(GenPPBCPowerProfileStatus, S2MessageComponent):
     model_config = GenPPBCPowerProfileStatus.model_config
     model_config["validate_assignment"] = True
 
-    sequence_container_status: List[PPBCPowerSequenceContainerStatus] = (
+    sequence_container_status: List[PPBCPowerSequenceContainerStatus] = (  # type: ignore[reportIncompatibleVariableOverride]
         GenPPBCPowerProfileStatus.model_fields["sequence_container_status"]  # type: ignore[assignment]
     )

s2python/ppbc/ppbc_power_sequence.py

@@ -15,16 +15,16 @@ from s2python.common import Duration
 
 
 @catch_and_convert_exceptions
-class PPBCPowerSequence(GenPPBCPowerSequence, S2MessageComponent["PPBCPowerSequence"]):
+class PPBCPowerSequence(GenPPBCPowerSequence, S2MessageComponent):
     model_config = GenPPBCPowerSequence.model_config
     model_config["validate_assignment"] = True
 
-    id: uuid.UUID = GenPPBCPowerSequence.model_fields["id"]  # type: ignore[assignment]
-    elements: List[PPBCPowerSequenceElement] = GenPPBCPowerSequence.model_fields[
+    id: uuid.UUID = GenPPBCPowerSequence.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    elements: List[PPBCPowerSequenceElement] = GenPPBCPowerSequence.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
         "elements"
     ]  # type: ignore[assignment]
-    is_interruptible: bool = GenPPBCPowerSequence.model_fields["is_interruptible"]  # type: ignore[assignment]
-    max_pause_before: Duration = GenPPBCPowerSequence.model_fields["max_pause_before"]  # type: ignore[assignment]
+    is_interruptible: bool = GenPPBCPowerSequence.model_fields["is_interruptible"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    max_pause_before: Duration = GenPPBCPowerSequence.model_fields["max_pause_before"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
     abnormal_condition_only: bool = GenPPBCPowerSequence.model_fields[
         "abnormal_condition_only"
-    ]  # type: ignore[assignment]
+    ]  # type: ignore[assignment,reportIncompatibleVariableOverride]

s2python/ppbc/ppbc_power_sequence_container.py

@@ -15,13 +15,11 @@ from s2python.ppbc.ppbc_power_sequence import PPBCPowerSequence
 
 
 @catch_and_convert_exceptions
-class PPBCPowerSequenceContainer(
-    GenPPBCPowerSequenceContainer, S2MessageComponent["PPBCPowerSequenceContainer"]
-):
+class PPBCPowerSequenceContainer(GenPPBCPowerSequenceContainer, S2MessageComponent):
     model_config = GenPPBCPowerSequenceContainer.model_config
     model_config["validate_assignment"] = True
 
-    id: uuid.UUID = GenPPBCPowerSequenceContainer.model_fields["id"]  # type: ignore[assignment]
-    power_sequences: List[PPBCPowerSequence] = (
-        GenPPBCPowerSequenceContainer.model_fields["power_sequences"]  # type: ignore[assignment]
-    )
+    id: uuid.UUID = GenPPBCPowerSequenceContainer.model_fields["id"]  # type: ignore[assignment,reportIncompatibleVariableOverride]
+    power_sequences: List[PPBCPowerSequence] = GenPPBCPowerSequenceContainer.model_fields[  # type: ignore[reportIncompatibleVariableOverride]
+        "power_sequences"
+    ]  # type: ignore[assignment]