solax-py-library 1.0.0.28__tar.gz → 1.0.0.29__tar.gz

{solax_py_library-1.0.0.28 → solax_py_library-1.0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: solax-py-library
-Version: 1.0.0.28
+Version: 1.0.0.29
 Summary: some common tool
 Author: shenlvyu
 Author-email: 13296718439@163.com

{solax_py_library-1.0.0.28 → solax_py_library-1.0.0.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "solax-py-library"
-version = "1.0.0.28"
+version = "1.0.0.29"
 description = "some common tool"
 authors = ["shenlvyu <13296718439@163.com>", "x5m8944pjl <371630856@qq.com>"]
 readme = "README.md"

{solax_py_library-1.0.0.28 → solax_py_library-1.0.0.29}/solax_py_library/smart_scene/constant/message_entry.py

@@ -156,8 +156,8 @@ MESSAGE_ENTRY = {
         "en_US": "PV power target is {}kW. Battery power target is {}kW. target SOC is {}%",
     },
     "DoControl": {"zh_CN": "DO{}: {};", "en_US": "DO{}: {};"},
-    "duration": {"zh_CN": "持续： {}秒", "en_US": "last: {} seconds"},
-    "systemSoc": {"zh_CN": "系统soc {} {}%", "en_US": "system soc {} {}%"},
+    "duration": {"zh_CN": "持续： {}秒", "en_US": "Last: {} seconds"},
+    "systemSoc": {"zh_CN": "系统soc {} {}%", "en_US": "System soc {} {}%"},
     "systemImportPower": {
         "zh_CN": "电网买电功率 {} {}KW",
         "en_US": "Grid import power {} {}KW",
@@ -166,7 +166,7 @@ MESSAGE_ENTRY = {
         "zh_CN": "电网馈电功率 {} {}KW",
         "en_US": "Grid export power {} {}KW",
     },
-    "cabinetSoc": {"zh_CN": "机柜soc {} {}%", "en_US": "cabinet soc {} {}%"},
+    "cabinetSoc": {"zh_CN": "机柜soc {} {}%", "en_US": "Cabinet soc {} {}%"},
     "EMERGENCY": {"zh_CN": "紧急告警", "en_US": "Emergency alarm"},
     "TIPS": {"zh_CN": "状态提醒", "en_US": "State Tips"},
     "NORMAL": {"zh_CN": "普通告警", "en_US": "Normal alarm"},

solax_py_library-1.0.0.29/solax_py_library/smart_scene/core/service/check.py

@@ -0,0 +1,33 @@
+from typing import List, Dict, Any
+
+from solax_py_library.smart_scene.types.action import SmartSceneAction, ActionType
+from solax_py_library.smart_scene.types.condition import (
+    SmartSceneCondition,
+    ConditionType,
+)
+
+
+def action_param_check(actions: List[SmartSceneAction], ctx: Dict[str, Any]):
+    """动作里的参数范围判定"""
+    for action in actions:
+        if action.type != ActionType.system:
+            continue
+        for action_data in action.data:
+            ret = action_data.check_param(ctx)
+            if ret is not None:
+                return ret
+    return True
+
+
+def condition_param_check(condition: SmartSceneCondition, ctx: Dict[str, Any]):
+    for condition_data in condition.value:
+        if condition_data.type not in [
+            ConditionType.systemCondition,
+            ConditionType.cabinet,
+        ]:
+            continue
+        for data in condition_data.data:
+            ret = data.check_param(ctx)
+            if ret is not None:
+                return ret
+    return True

solax_py_library-1.0.0.29/solax_py_library/smart_scene/types/action.py

@@ -0,0 +1,334 @@
+from enum import Enum, IntEnum
+from typing import List, Union, Any
+
+from pydantic import BaseModel
+
+from solax_py_library.device.constant.cabinet import TRENE_CABINET_ENUM
+from solax_py_library.smart_scene.constant.message_entry import MESSAGE_ENTRY
+from solax_py_library.smart_scene.exceptions.smart_scene import (
+    ExportLimitNum,
+    ImportLimitNum,
+    ImportOnlyPositive,
+    PowerLimitNum,
+    SocLimit,
+    ActivePowerLimitNum,
+    ReactivePowerLimitNum,
+    EnergyLimit,
+    BatteryPowerLimitNum,
+    PvOnlyGe0,
+    ExportLimitPercent,
+)
+
+
+class SmartSceneUnit(IntEnum):
+    PERCENT = 1
+    NUM = 2
+
+
+class ActionType(str, Enum):
+    EMS1000 = "EMS1000"
+    system = "system"
+
+
+class EmsActionType(str, Enum):
+    DoControl = "DoControl"
+
+
+class SystemActionType(str, Enum):
+    systemSwitch = "systemSwitch"
+    exportControl = "exportControl"
+    importControl = "importControl"
+    workMode = "workMode"
+
+
+class DoControl(BaseModel):
+    DoNumber: int
+    DoValue: int
+
+
+class ActionChildData(BaseModel):
+    data: List[Any]
+
+
+class SystemActionChildData(ActionChildData):
+    ...
+
+
+class ActionItemData(BaseModel):
+    def check_param(self, ctx):
+        ...
+
+
+class SystemActionItemData(ActionItemData):
+    childType: SystemActionType
+    childData: SystemActionChildData
+
+    def to_text(self, lang, cabinet_type):
+        if self.childType == SystemActionType.systemSwitch:
+            switch = "off" if self.childData.data[0] == 0 else "on"
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[switch][lang]
+            )
+        elif self.childType == SystemActionType.exportControl:
+            if self.childData.data[0] == 0:
+                return MESSAGE_ENTRY["exportControlOff"][lang]
+            else:
+                switch = "on"
+                mode = "total" if self.childData.data[1] == 1 else "per phase"
+                unit = "kW" if self.childData.data[3] == 2 else "%"
+                return MESSAGE_ENTRY[self.childType][lang].format(
+                    MESSAGE_ENTRY[switch][lang],
+                    MESSAGE_ENTRY[mode][lang],
+                    self.childData.data[2],
+                    unit,
+                )
+        elif self.childType == SystemActionType.importControl:
+            if self.childData.data[0] == 0:
+                return MESSAGE_ENTRY["importControlOff"][lang]
+            else:
+                if cabinet_type in TRENE_CABINET_ENUM:
+                    msg = (
+                        "importControl_standby"
+                        if self.childData.data[1] == 0
+                        else "importControl_discharge"
+                    )
+                    return MESSAGE_ENTRY[self.childType][lang].format(
+                        MESSAGE_ENTRY["on"][lang],
+                        MESSAGE_ENTRY[msg][lang],
+                        self.childData.data[2],
+                    )
+                else:
+                    return MESSAGE_ENTRY["importControl_AELIO"][lang].format(
+                        MESSAGE_ENTRY["on"][lang], self.childData.data[1]
+                    )
+        elif self.childType == SystemActionType.workMode:
+            return self.work_mode_to_text(lang)
+
+    def work_mode_to_text(self, lang):
+        work_mode = {
+            0: "Self-use",
+            1: "Feedin priority",
+            2: "Back up mode",
+            3: "Manual mode",
+            4: "Peak Shaving",
+            16: "VPP",
+        }
+        # 3: 手动（3 强充，4 强放，5 停止充放电）
+        manual_mode = {
+            3: "Forced charging",
+            4: "Forced discharging",
+            5: "Stop charging and discharging",
+        }
+        vpp_mode = {
+            1: "Power Control Mode",
+            2: "Electric Quantity Target Control Mode",
+            3: "SOC Target Control Mode",
+            4: "Push Power - Positive/Negative Mode",
+            5: "Push Power - Zero Mode",
+            6: "Self-Consume - Charge/Discharge Mode",
+            7: "Self-Consume - Charge Only Mode",
+            8: "PV&BAT Individual Setting – Duration Mode",
+            9: "PV&BAT Individual Setting – Target SOC Mode",
+        }
+        value_data = self.childData.data
+        # 手动模式
+        if value_data[0] in [3]:
+            if value_data[1] in [3, 4]:
+                return MESSAGE_ENTRY[work_mode[value_data[0]]][lang].format(
+                    MESSAGE_ENTRY[manual_mode[value_data[1]]][lang].format(
+                        value_data[2], value_data[3]
+                    )
+                )
+            else:
+                return MESSAGE_ENTRY[work_mode[value_data[0]]][lang].format(
+                    MESSAGE_ENTRY[manual_mode[value_data[1]]][lang]
+                )
+        elif value_data[0] in [16]:
+            mode = vpp_mode[value_data[1]]
+            if value_data[1] in [1, 2, 3, 8]:
+                return MESSAGE_ENTRY[mode][lang].format(value_data[2], value_data[3])
+            elif value_data[1] in [4]:
+                return MESSAGE_ENTRY[mode][lang].format(value_data[2])
+            elif value_data[1] in [5, 6, 7]:
+                return MESSAGE_ENTRY[mode][lang]
+            elif value_data[1] in [9]:
+                return MESSAGE_ENTRY[mode][lang].format(
+                    value_data[2], value_data[3], value_data[4]
+                )
+        else:
+            return MESSAGE_ENTRY[work_mode[value_data[0]]][lang]
+        return ""
+
+    def check_param(self, ctx):
+        if self.childType == SystemActionType.exportControl:
+            export_power_top_limit = ctx.pop("export_power_top_limit")
+            switch = self.childData.data[0]
+            if not switch:
+                return
+            _, _, value, unit = self.childData.data
+            if unit == SmartSceneUnit.NUM:
+                if value > export_power_top_limit or value < 0:
+                    return ExportLimitNum, {"up_limit": export_power_top_limit}
+            else:
+                if value > 0 or value < 110:
+                    return ExportLimitPercent, {}
+        elif self.childType == SystemActionType.importControl:
+            import_power_top_limit = ctx.pop("import_power_top_limit", None)
+            switch = self.childData.data[0]
+            if not switch:
+                return
+            value = self.childData.data[-1]
+            if import_power_top_limit is not None:
+                if value > import_power_top_limit or value < 0:
+                    return (
+                        ImportLimitNum,
+                        {"up_limit": import_power_top_limit},
+                    )
+            else:
+                if value < 0:
+                    return ImportOnlyPositive, {}
+        elif self.childType == SystemActionType.workMode:
+            work_mode = self.childData.data[0]
+            total_power_top_limit = ctx.pop("total_power_top_limit")
+            total_energy_top_limit = ctx.pop("total_energy_top_limit")
+            soc_low_limit = ctx.pop("soc_low_limit")
+            if work_mode == 3:  # 手动模式
+                if self.childData.data[1] in [3, 4]:  # 强充或强放
+                    _, _, power, soc = self.childData.data
+                    if power <= 0 or power > total_power_top_limit:
+                        return PowerLimitNum, {
+                            "low_limit": 0,
+                            "up_limit": total_power_top_limit,
+                        }
+                    if soc > 100 or soc < soc_low_limit:
+                        return SocLimit, {"low_limit": soc_low_limit}
+            elif work_mode == 16:  # VPP模式
+                vpp_mode = self.childData.data[1]
+                if vpp_mode == 1:
+                    (
+                        _,
+                        _,
+                        active_power,
+                        reactive_power,
+                    ) = self.childData.data
+                    if (
+                        active_power < -total_power_top_limit
+                        or active_power > total_power_top_limit
+                    ):
+                        return (
+                            ActivePowerLimitNum,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                    if (
+                        reactive_power < -total_power_top_limit
+                        or reactive_power > total_power_top_limit
+                    ):
+                        return (
+                            ReactivePowerLimitNum,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                elif vpp_mode == 2:
+                    _, _, energy, power = self.childData.data
+                    if energy < 0 or energy > total_energy_top_limit:
+                        return (
+                            EnergyLimit,
+                            {"up_limit": total_energy_top_limit},
+                        )
+                    if power < -total_power_top_limit or power > total_power_top_limit:
+                        return (
+                            PowerLimitNum,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                elif vpp_mode == 3:
+                    _, _, soc, power = self.childData.data
+                    if soc < soc_low_limit or soc > 100:
+                        return (
+                            SocLimit,
+                            {"low_limit": soc_low_limit},
+                        )
+                    if power < -total_power_top_limit or power > total_power_top_limit:
+                        return (
+                            PowerLimitNum,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                elif vpp_mode == 4:
+                    _, _, power = self.childData.data
+                    if power < -total_power_top_limit or power > total_power_top_limit:
+                        return (
+                            BatteryPowerLimitNum,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                elif vpp_mode == 8:
+                    _, _, pv_power, bms_power = self.childData.data
+                    if pv_power < 0:
+                        return PvOnlyGe0, {}
+                    elif (
+                        bms_power < -total_power_top_limit
+                        or bms_power > total_power_top_limit
+                    ):
+                        return (
+                            BatteryPowerLimitNum,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                elif vpp_mode == 9:
+                    _, _, pv_power, bms_power, soc = self.childData.data
+                    if pv_power < 0:
+                        return PvOnlyGe0, {}
+                    if (
+                        bms_power < -total_power_top_limit
+                        or bms_power > total_power_top_limit
+                    ):
+                        return (
+                            BatteryPowerLimitNum,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                    if soc < soc_low_limit or soc > 100:
+                        return SocLimit, {"low_limit": soc_low_limit}
+
+
+class EmsActionChildData(ActionChildData):
+    data: List[DoControl]
+
+
+class EmsActionItemData(ActionItemData):
+    childType: EmsActionType
+    childData: EmsActionChildData
+
+    def to_text(self, lang, cabinet_type):
+        if self.childType == EmsActionType.DoControl:
+            message = ""
+            for do_info in self.childData.data:
+                message += MESSAGE_ENTRY[self.childType][lang].format(
+                    do_info.DoNumber,
+                    do_info.DoValue,
+                )
+            return message
+
+
+class SmartSceneAction(BaseModel):
+    type: ActionType
+    data: List[Union[EmsActionItemData, SystemActionItemData]]
+
+    def to_text(self, lang, cabinet_type):
+        return [item.to_text(lang, cabinet_type) for item in self.data]

{solax_py_library-1.0.0.28 → solax_py_library-1.0.0.29}/solax_py_library/smart_scene/types/condition.py

@@ -2,11 +2,12 @@ import operator
 from enum import IntEnum, Enum
 from typing import Optional, List, Union, Any
 
-from pydantic import BaseModel, validator, root_validator
+from pydantic import BaseModel, validator
 
 from solax_py_library.device.types.alarm import AlarmLevel
 from solax_py_library.device.types.device import DeviceType
 from solax_py_library.smart_scene.constant.message_entry import MESSAGE_ENTRY
+from solax_py_library.smart_scene.exceptions.smart_scene import SocLimit
 
 
 class LogicFunc(IntEnum):
@@ -83,7 +84,12 @@ class ConditionItemChildData(BaseModel):
     data: List[Any]
 
 
-class PriceConditionItemData(BaseModel):
+class ConditionItemData(BaseModel):
+    def check_param(self, ctx):
+        ...
+
+
+class PriceConditionItemData(ConditionItemData):
     childType: PriceConditionType
     childData: ConditionItemChildData
 
@@ -123,7 +129,7 @@ class PriceConditionItemData(BaseModel):
             return MESSAGE_ENTRY[self.childType][lang].format(data[0], data[1], data[2])
 
 
-class SystemConditionItemData(BaseModel):
+class SystemConditionItemData(ConditionItemData):
     childType: SystemConditionType
     childData: ConditionItemChildData
 
@@ -136,8 +142,6 @@ class SystemConditionItemData(BaseModel):
         }:
             assert 0 <= value.data[0] <= 100000, ValueError
             value.data[0] = round(value.data[0], 2)  # 功率保留两位小数
-        elif child_type == SystemConditionType.systemSoc:
-            assert 5 <= value.data[0] <= 100, ValueError
         return value
 
     def to_text(self, lang, unit):
@@ -155,8 +159,15 @@ class SystemConditionItemData(BaseModel):
                 MESSAGE_ENTRY[str(func.value)][lang], data[0]
             )
 
+    def check_param(self, ctx):
+        soc_low_limit = ctx.pop("soc_low_limit", 5)
+        if self.childType == SystemConditionType.systemSoc:
+            soc = self.childData.data[0]
+            if soc < soc_low_limit or soc > 100:
+                return SocLimit.message, {"low_limit": soc_low_limit}
+
 
-class CabinetConditionItemData(BaseModel):
+class CabinetConditionItemData(ConditionItemData):
     childType: CabinetConditionType
     childData: ConditionItemChildData
 
@@ -169,8 +180,6 @@ class CabinetConditionItemData(BaseModel):
                 AlarmLevel.NORMAL,
                 AlarmLevel.EMERGENCY,
             }, ValueError
-        if child_type == CabinetConditionType.cabinetSoc:
-            assert 0 <= value.data[0] <= 100, ValueError
         return value
 
     def to_text(self, lang, unit):
@@ -191,13 +200,20 @@ class CabinetConditionItemData(BaseModel):
                 MESSAGE_ENTRY[str(AlarmLevel(data[-1]))][lang],
             )
 
+    def check_param(self, ctx):
+        soc_low_limit = ctx.pop("soc_low_limit", 5)
+        if self.childType == CabinetConditionType.cabinetSoc:
+            soc = self.childData.data[0]
+            if soc < soc_low_limit or soc > 100:
+                return SocLimit.message, {"low_limit": soc_low_limit}
+
 
-class DateConditionItemData(BaseModel):
+class DateConditionItemData(ConditionItemData):
     childType: DateConditionType
     childData: ConditionItemChildData
 
     @validator("childData", always=True)
-    def check_param(cls, value, values):
+    def _check_child_data(cls, value, values):
         child_type = values.get("childType")
         data = value.data
         if child_type == DateConditionType.time:
@@ -213,7 +229,7 @@ class DateConditionItemData(BaseModel):
             return MESSAGE_ENTRY[self.childType][lang] + "/" + self.childData.data[0]
 
 
-class WeatherConditionItemData(BaseModel):
+class WeatherConditionItemData(ConditionItemData):
     childType: WeatherConditionType
     childData: ConditionItemChildData
 
@@ -272,24 +288,6 @@ class SmartSceneCondition(BaseModel):
     operation: LogicFunc
     value: List[ConditionItem]
 
-    @root_validator
-    def _root_check(cls, values):
-        if values.get("operation") == LogicFunc.OR:
-            new_value = []
-            for item in values.get("value"):
-                if item.type != ConditionType.date:
-                    new_value.append(item)
-                    continue
-                new_data = []
-                for date_item in item.data:
-                    if date_item.childType != DateConditionType.duration:
-                        new_data.append(date_item)
-                item.data = new_data
-                if item.data:
-                    new_value.append(item)
-            values["value"] = new_value
-        return values
-
     def to_text(self, lang, unit):
         ret = {"operation": [MESSAGE_ENTRY[self.operation.name][lang]]}
         for v in self.value:

solax_py_library-1.0.0.29/solax_py_library/test/test_smart_scene/test_check_func.py

@@ -0,0 +1,83 @@
+from unittest import TestCase
+
+from solax_py_library.smart_scene.core.service.check import (
+    condition_param_check,
+    action_param_check,
+)
+from solax_py_library.smart_scene.types.action import (
+    SmartSceneAction,
+    ActionType,
+    SystemActionType,
+    SystemActionItemData,
+    SystemActionChildData,
+)
+from solax_py_library.smart_scene.types.condition import (
+    SmartSceneCondition,
+    ConditionItem,
+    ConditionType,
+    SystemConditionItemData,
+    LogicFunc,
+    SystemConditionType,
+    ConditionItemChildData,
+    CabinetConditionItemData,
+    CabinetConditionType,
+    ConditionFunc,
+)
+
+
+class TestCheckFunc(TestCase):
+    def test_check_condition_func(self):
+        con = SmartSceneCondition(
+            operation=LogicFunc.AND,
+            value=[
+                ConditionItem(
+                    type=ConditionType.systemCondition,
+                    data=[
+                        SystemConditionItemData(
+                            childType=SystemConditionType.systemSoc,
+                            childData=ConditionItemChildData(
+                                data=[101], function=ConditionFunc.EQ
+                            ),
+                        ),
+                    ],
+                    cabinet=None,
+                ),
+                ConditionItem(
+                    type=ConditionType.cabinet,
+                    data=[
+                        CabinetConditionItemData(
+                            childType=CabinetConditionType.cabinetSoc,
+                            childData=ConditionItemChildData(
+                                data=[4], function=ConditionFunc.EQ
+                            ),
+                        )
+                    ],
+                    cabinet=["1", "2"],
+                ),
+            ],
+        )
+        ret = condition_param_check(con, ctx={"soc_low_limit": 10})
+        assert ret is not None
+
+    def test_check_action_func(self):
+        action = [
+            SmartSceneAction(
+                type=ActionType.system,
+                data=[
+                    SystemActionItemData(
+                        childType=SystemActionType.importControl,
+                        childData=SystemActionChildData(data=[1, -10]),
+                    )
+                ],
+            )
+        ]
+        ret = action_param_check(
+            actions=action,
+            ctx={
+                "cabinet_type": 3,
+                "total_power": 1,
+                "total_power_except_solar_inv": 1,
+                "total_energy": 1,
+            },
+        )
+        assert ret is not None

solax_py_library-1.0.0.28/solax_py_library/smart_scene/types/action.py

@@ -1,164 +0,0 @@
-from enum import Enum
-from typing import List, Union, Any
-
-from pydantic import BaseModel
-
-from solax_py_library.device.constant.cabinet import TRENE_CABINET_ENUM
-from solax_py_library.smart_scene.constant.message_entry import MESSAGE_ENTRY
-
-
-class ActionType(str, Enum):
-    EMS1000 = "EMS1000"
-    system = "system"
-
-
-class EmsActionType(str, Enum):
-    DoControl = "DoControl"
-
-
-class SystemActionType(str, Enum):
-    systemSwitch = "systemSwitch"
-    exportControl = "exportControl"
-    importControl = "importControl"
-    workMode = "workMode"
-
-
-class DoControl(BaseModel):
-    DoNumber: int
-    DoValue: int
-
-
-class ActionChildData(BaseModel):
-    data: List[Any]
-
-
-class SystemActionChildData(ActionChildData):
-    ...
-
-
-class SystemActionItemData(BaseModel):
-    childType: SystemActionType
-    childData: SystemActionChildData
-
-    def to_text(self, lang, cabinet_type):
-        if self.childType == SystemActionType.systemSwitch:
-            switch = "off" if self.childData.data[0] == 0 else "on"
-            return MESSAGE_ENTRY[self.childType][lang].format(
-                MESSAGE_ENTRY[switch][lang]
-            )
-        elif self.childType == SystemActionType.exportControl:
-            if self.childData.data[0] == 0:
-                return MESSAGE_ENTRY["exportControlOff"][lang]
-            else:
-                switch = "on"
-                mode = "total" if self.childData.data[1] == 1 else "per phase"
-                unit = "kW" if self.childData.data[3] == 2 else "%"
-                return MESSAGE_ENTRY[self.childType][lang].format(
-                    MESSAGE_ENTRY[switch][lang],
-                    MESSAGE_ENTRY[mode][lang],
-                    self.childData.data[2],
-                    unit,
-                )
-        elif self.childType == SystemActionType.importControl:
-            if self.childData.data[0] == 0:
-                return MESSAGE_ENTRY["importControlOff"][lang]
-            else:
-                if cabinet_type in TRENE_CABINET_ENUM:
-                    msg = (
-                        "importControl_standby"
-                        if self.childData.data[1] == 0
-                        else "importControl_discharge"
-                    )
-                    return MESSAGE_ENTRY[self.childType][lang].format(
-                        MESSAGE_ENTRY["on"][lang],
-                        MESSAGE_ENTRY[msg][lang],
-                        self.childData.data[2],
-                    )
-                else:
-                    return MESSAGE_ENTRY["importControl_AELIO"][lang].format(
-                        MESSAGE_ENTRY["on"][lang], self.childData.data[1]
-                    )
-        elif self.childType == SystemActionType.workMode:
-            return self.work_mode_to_text(lang)
-
-    def work_mode_to_text(self, lang):
-        work_mode = {
-            0: "Self-use",
-            1: "Feedin priority",
-            2: "Back up mode",
-            3: "Manual mode",
-            4: "Peak Shaving",
-            16: "VPP",
-        }
-        # 3: 手动（3 强充，4 强放，5 停止充放电）
-        manual_mode = {
-            3: "Forced charging",
-            4: "Forced discharging",
-            5: "Stop charging and discharging",
-        }
-        vpp_mode = {
-            1: "Power Control Mode",
-            2: "Electric Quantity Target Control Mode",
-            3: "SOC Target Control Mode",
-            4: "Push Power - Positive/Negative Mode",
-            5: "Push Power - Zero Mode",
-            6: "Self-Consume - Charge/Discharge Mode",
-            7: "Self-Consume - Charge Only Mode",
-            8: "PV&BAT Individual Setting – Duration Mode",
-            9: "PV&BAT Individual Setting – Target SOC Mode",
-        }
-        value_data = self.childData.data
-        # 手动模式
-        if value_data[0] in [3]:
-            if value_data[1] in [3, 4]:
-                return MESSAGE_ENTRY[work_mode[value_data[0]]][lang].format(
-                    MESSAGE_ENTRY[manual_mode[value_data[1]]][lang].format(
-                        value_data[2], value_data[3]
-                    )
-                )
-            else:
-                return MESSAGE_ENTRY[work_mode[value_data[0]]][lang].format(
-                    MESSAGE_ENTRY[manual_mode[value_data[1]]][lang]
-                )
-        elif value_data[0] in [16]:
-            mode = vpp_mode[value_data[1]]
-            if value_data[1] in [1, 2, 3, 8]:
-                return MESSAGE_ENTRY[mode][lang].format(value_data[2], value_data[3])
-            elif value_data[1] in [4]:
-                return MESSAGE_ENTRY[mode][lang].format(value_data[2])
-            elif value_data[1] in [5, 6, 7]:
-                return MESSAGE_ENTRY[mode][lang]
-            elif value_data[1] in [9]:
-                return MESSAGE_ENTRY[mode][lang].format(
-                    value_data[2], value_data[3], value_data[4]
-                )
-        else:
-            return MESSAGE_ENTRY[work_mode[value_data[0]]][lang]
-        return ""
-
-
-class EmsActionChildData(ActionChildData):
-    data: List[DoControl]
-
-
-class EmsActionItemData(BaseModel):
-    childType: EmsActionType
-    childData: EmsActionChildData
-
-    def to_text(self, lang, cabinet_type):
-        if self.childType == EmsActionType.DoControl:
-            message = ""
-            for do_info in self.childData.data:
-                message += MESSAGE_ENTRY[self.childType][lang].format(
-                    do_info.DoNumber,
-                    do_info.DoValue,
-                )
-            return message
-
-
-class SmartSceneAction(BaseModel):
-    type: ActionType
-    data: List[Union[EmsActionItemData, SystemActionItemData]]
-
-    def to_text(self, lang, cabinet_type):
-        return [item.to_text(lang, cabinet_type) for item in self.data]