solax-py-library 1.0.0.2601__tar.gz → 1.0.0.2901__tar.gz

{solax_py_library-1.0.0.2601 → solax_py_library-1.0.0.2901}/PKG-INFO

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

{solax_py_library-1.0.0.2601 → solax_py_library-1.0.0.2901}/pyproject.toml

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

solax_py_library-1.0.0.2901/solax_py_library/device/types/device.py

@@ -0,0 +1,26 @@
+from enum import IntEnum
+
+
+class DeviceType(IntEnum):
+    EMS_TYPE = 100
+    PCS_TYPE = 1
+    BMS_TYPE = 2  # 电池簇
+    ELM_TYPE = 3
+    EVC_TYPE = 4
+    IO_TYPE = 5
+    ESS_TYPE = 6  # 机柜
+    CELL_TYPE = 7  # 单体
+    AIRCONDITIONER_TYPE = 501
+    FIRE_SAFETY_TYPE = 502
+    COLD_TYPE = 503
+    DEHUMIDIFY_TYPE = 504
+
+    def __str__(self):
+        return {
+            DeviceType.PCS_TYPE: "pcs",
+            DeviceType.BMS_TYPE: "bms",
+            DeviceType.ELM_TYPE: "elm",
+            DeviceType.IO_TYPE: "io",
+            DeviceType.AIRCONDITIONER_TYPE: "air_conditioner",
+            DeviceType.COLD_TYPE: "liquid_cooling_unit",
+        }.get(self)

{solax_py_library-1.0.0.2601 → solax_py_library-1.0.0.2901}/solax_py_library/smart_scene/constant/message_entry.py

@@ -159,21 +159,33 @@ MESSAGE_ENTRY = {
     "duration": {"zh_CN": "持续： {}秒", "en_US": "last: {} seconds"},
     "systemSoc": {"zh_CN": "系统soc {} {}%", "en_US": "system soc {} {}%"},
     "systemImportPower": {
-        "zh_CN": "电价买电功率 {} {}KW",
-        "en_US": "system soc {} {}KW",
+        "zh_CN": "电网买电功率 {} {}KW",
+        "en_US": "Grid import power {} {}KW",
     },
     "systemExportPower": {
-        "zh_CN": "电价馈电功率 {} {}KW",
-        "en_US": "system soc {} {}KW",
+        "zh_CN": "电网馈电功率 {} {}KW",
+        "en_US": "Grid export power {} {}KW",
     },
     "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"},
-    "cabinetAlarm": {"zh_CN": "机柜发生{}", "en_US": "cabinet occurs {}"},
+    "cabinetAlarm": {
+        "zh_CN": "机柜下属({})设备发生{}",
+        "en_US": "The equipments({}) under the cabinet occurs {}",
+    },
     "OR": {"zh_CN": "满足任一条件", "en_US": "Meet any of the conditions"},
     "AND": {"zh_CN": "满足所有条件", "en_US": "Meet all conditions"},
     "tips_alarm": {"zh_CN": "状态提醒", "en_US": "Alarm tips"},
     "normal_alarm": {"zh_CN": "普通告警", "en_US": "Normal alarm"},
     "emergency_alarm": {"zh_CN": "紧急告警", "en_US": "Emergency alarm"},
+    "pcs": {"zh_CN": "逆变器", "en_US": "Inverter"},
+    "bms": {"zh_CN": "电池", "en_US": "Battery"},
+    "elm": {
+        "zh_CN": "电表",
+        "en_US": "Meter",
+    },
+    "io": {"zh_CN": "IO模块", "en_US": "IO Module"},
+    "air_conditioner": {"zh_CN": "空调", "en_US": "Air conditioner"},
+    "liquid_cooling_unit": {"zh_CN": "液冷机组", "en_US": "Liquid Cooling Unit"},
 }

{solax_py_library-1.0.0.2601 → solax_py_library-1.0.0.2901}/solax_py_library/smart_scene/core/action/base.py

@@ -1,6 +1,5 @@
 class BaseAction(object):
-    def __init__(self, smart_scene_service, do_funcs, **kwargs):
-        self.smart_scene_service = smart_scene_service
+    def __init__(self, do_funcs, **kwargs):
         self.do_func_map = do_funcs
 
     def do_func(self, scene_id, data):

{solax_py_library-1.0.0.2601 → solax_py_library-1.0.0.2901}/solax_py_library/smart_scene/core/condition/cabinet_condition.py

@@ -6,7 +6,6 @@ from solax_py_library.smart_scene.types.condition import (
     CabinetConditionType,
     ConditionType,
 )
-from solax_py_library.device.types.alarm import AlarmLevel
 from solax_py_library.smart_scene.types.condition_value import CabinetValue
 
 
@@ -15,9 +14,7 @@ class CabinetCondition(BaseCondition):
 
     def __init__(self, update_value_function, **kwargs):
         super().__init__(update_value_function, **kwargs)
-        self.value = defaultdict(
-            lambda: CabinetValue
-        )
+        self.value = defaultdict(lambda: CabinetValue)
 
     def meet_func(self, data: CabinetConditionItemData, ctx):
         if not self.value:
@@ -42,6 +39,6 @@ class CabinetCondition(BaseCondition):
                     alarm_info = cabinet_value.alarm_info(device_type)
                     if not alarm_info:
                         continue
-                    if alarm_info[alarm_type-1] is True:
+                    if alarm_info[alarm_type - 1] is True:
                         return True
         return False

{solax_py_library-1.0.0.2601 → solax_py_library-1.0.0.2901}/solax_py_library/smart_scene/core/condition/weather_condition.py

@@ -21,10 +21,14 @@ class WeatherCondition(BaseCondition):
         function_value = child_data.function
         data_value = child_data.data
         nearest_time, right_time = get_rounded_times()
-        if nearest_time not in self.value["timeList"]:
-            time_now = right_time
-        else:
-            time_now = nearest_time
+        if (
+            nearest_time not in self.value["timeList"]
+            and right_time not in self.value["timeList"]
+        ):
+            return False
+        time_now = (
+            right_time if nearest_time not in self.value["timeList"] else nearest_time
+        )
         index = self.value["timeList"].index(time_now)
         if child_type == WeatherConditionType.irradiance:
             return self.meet_func_irradiance(function_value, data_value, index)

solax_py_library-1.0.0.2901/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.2901/solax_py_library/smart_scene/types/action.py

@@ -0,0 +1,338 @@
+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)
+            total_power_top_limit = ctx.pop("total_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 > total_power_top_limit or value < 0:
+                    return (
+                        ImportLimitNum.message,
+                        {"up_limit": import_power_top_limit},
+                    )
+            else:
+                if value < 0:
+                    return ImportOnlyPositive.message, {}
+        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.message,
+                            {"low_limit": 0, "up_limit": total_power_top_limit},
+                        )
+                    if soc > 100 or soc < soc_low_limit:
+                        return (
+                            SocLimit.message,
+                            {"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.message,
+                            {
+                                "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.message,
+                            {
+                                "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.message,
+                            {"up_limit": total_energy_top_limit},
+                        )
+                    if power < -total_power_top_limit or power > total_power_top_limit:
+                        return (
+                            PowerLimitNum.message,
+                            {
+                                "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.message,
+                            {"low_limit": soc_low_limit},
+                        )
+                    if power < -total_power_top_limit or power > total_power_top_limit:
+                        return (
+                            PowerLimitNum.message,
+                            {
+                                "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.message,
+                            {
+                                "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.message, {})
+                    elif (
+                        bms_power < -total_power_top_limit
+                        or bms_power > total_power_top_limit
+                    ):
+                        return (
+                            BatteryPowerLimitNum.message,
+                            {
+                                "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.message, {})
+                    if (
+                        bms_power < -total_power_top_limit
+                        or bms_power > total_power_top_limit
+                    ):
+                        return (
+                            BatteryPowerLimitNum.message,
+                            {
+                                "low_limit": -total_power_top_limit,
+                                "up_limit": total_power_top_limit,
+                            },
+                        )
+                    if soc < soc_low_limit or soc > 100:
+                        return SocLimit.message, {"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.2601 → solax_py_library-1.0.0.2901}/solax_py_library/smart_scene/types/condition.py

@@ -2,10 +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):
@@ -82,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
 
@@ -122,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
 
@@ -135,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):
@@ -154,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
 
@@ -168,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):
@@ -181,16 +191,29 @@ class CabinetConditionItemData(BaseModel):
             )
         elif self.childType == CabinetConditionType.cabinetAlarm:
             return MESSAGE_ENTRY[self.childType][lang].format(
-                MESSAGE_ENTRY[str(AlarmLevel(data[0]))][lang], lang
+                ",".join(
+                    [
+                        MESSAGE_ENTRY[str(DeviceType(device_type))][lang]
+                        for device_type in data[:-1]
+                    ]
+                ),
+                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:
@@ -206,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
 
@@ -265,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.2601 → solax_py_library-1.0.0.2901}/solax_py_library/smart_scene/types/condition_value.py

@@ -7,12 +7,12 @@ from solax_py_library.device.types.device import DeviceType
 
 class CabinetValue(BaseModel):
     soc: int = None
-    cabinet_alarm: List[bool] = Field(default_factory=lambda :[False, False, False])
-    pcs_alarm:  List[bool] = Field(default_factory=lambda :[False, False, False])
-    io_alarm:  List[bool] = Field(default_factory=lambda :[False, False, False])
-    bms_alarm:  List[bool] = Field(default_factory=lambda :[False, False, False])
-    air_alarm:  List[bool] = Field(default_factory=lambda :[False, False, False])
-    liquid_alarm:  List[bool] = Field(default_factory=lambda :[False, False, False])
+    cabinet_alarm: List[bool] = Field(default_factory=lambda: [False, False, False])
+    pcs_alarm: List[bool] = Field(default_factory=lambda: [False, False, False])
+    io_alarm: List[bool] = Field(default_factory=lambda: [False, False, False])
+    bms_alarm: List[bool] = Field(default_factory=lambda: [False, False, False])
+    air_alarm: List[bool] = Field(default_factory=lambda: [False, False, False])
+    liquid_alarm: List[bool] = Field(default_factory=lambda: [False, False, False])
 
     def alarm_info(self, device_type):
         if device_type == DeviceType.EMS_TYPE: