solax-py-library 1.0.0.23__py3-none-any.whl → 1.0.0.26__py3-none-any.whl

solax_py_library/smart_scene/core/service/runner.py

@@ -0,0 +1,156 @@
+import json
+import traceback
+from datetime import datetime
+from typing import List, Set
+
+from solax_py_library.smart_scene.core.condition import BaseCondition
+from solax_py_library.smart_scene.types.action import (
+    SmartSceneAction,
+)
+from solax_py_library.smart_scene.types.condition import (
+    ConditionType,
+    RepeatFunc,
+    LogicFunc,
+    SmartSceneCondition,
+    DateConditionType,
+    ConditionItem,
+)
+from solax_py_library.smart_scene.types.smart_scene_content import (
+    SmartSceneContent,
+    SmartSceneOtherInfo,
+)
+from tornado.log import app_log
+
+
+class SmartSceneRunner:
+    def __init__(self, condition_classes, action_classes):
+        self.condition_class_map = {}
+        self.action_class_map = {}
+
+        for condition_class in condition_classes:
+            if not isinstance(condition_class, BaseCondition):
+                raise ValueError(
+                    f"condition({condition_class}) is not derived from BaseCondition"
+                )
+            self.condition_class_map[condition_class.condition_type] = condition_class
+
+        for action_class in action_classes:
+            self.action_class_map[action_class.action_type] = action_class
+
+    @staticmethod
+    def _handle_repeat_info(scene_content: SmartSceneContent, once_flag):
+        # once_flag: 是否执行过
+        if scene_content.repeatFunction == RepeatFunc.ONCE:
+            return False if once_flag else True
+        week_list = scene_content.get_weekday_index()
+        if datetime.now().weekday() + 1 in week_list:
+            return True
+        return False
+
+    def smart_scene_handle(self, scene_instance):
+        other_info = SmartSceneOtherInfo.parse_raw(scene_instance.other)
+        try:
+            scene_data = SmartSceneContent.parse_raw(scene_instance.content)
+
+            # repeat，是否执行
+            if not self._handle_repeat_info(scene_data, other_info.once_flag):
+                app_log.info(
+                    f"场景名称: {scene_data.name}, 场景ID: {scene_instance.scene_id} 不符合重复条件，不执行"
+                )
+                return
+            scene_id = scene_instance.scene_id
+            app_log.info(
+                f"场景名称: {scene_data.name}, 场景ID: {scene_id}, 判断类型: {scene_data.conditions.operation}:"
+            )
+
+            # 条件判断
+            result = self._handle_conditions(
+                scene_data.conditions.operation,
+                scene_data.conditions,
+                other_info,
+            )
+
+            # 动作执行
+            new_exec_number = scene_instance.exec_number
+            if result:
+                self._handle_action(scene_id, scene_data.thenActions, log_prefix="THEN")
+                new_exec_number = 1
+                other_info.once_flag = True
+            elif scene_instance.exec_number == 1 and scene_data.elseThenActions:
+                self._handle_action(
+                    scene_id, scene_data.elseThenActions, log_prefix="ELSE THEN"
+                )
+                new_exec_number = 0
+                other_info.duration_times = 0
+
+            app_log.info(f"{scene_id} 执行完毕\n")
+            scene_instance.exec_number = new_exec_number
+            scene_instance.other = json.dumps(other_info.dict())
+            return scene_instance
+        except Exception:
+            app_log.error(
+                f"{scene_instance.scene_id} 执行智能场景异常 {traceback.format_exc()}"
+            )
+
+    def _handle_action(
+        self, scene_id, actions: List[SmartSceneAction], log_prefix="THEN"
+    ):
+        if not actions:
+            return
+        for action_info in actions:
+            action_class = self.action_class_map[action_info.type]
+            for child_info in action_info.data:
+                ret = action_class.do_func(scene_id=scene_id, data=child_info)
+                app_log.info(f"{log_prefix}条件 {child_info} 执行结果: {ret}")
+
+    def _handle_conditions(
+        self,
+        operation: LogicFunc,
+        conditions: SmartSceneCondition,
+        other_info: SmartSceneOtherInfo,
+    ):
+        need_duration_times = conditions.get_duration_info()
+        if not self._check_conditions(operation, conditions):
+            other_info.duration_times = 0
+            return False
+        if other_info.duration_times < need_duration_times:
+            other_info.duration_times += 1
+        app_log.info(
+            f"need times: {need_duration_times}, current times: {other_info.duration_times}"
+        )
+        return other_info.duration_times >= need_duration_times
+
+    def _check_conditions(self, operation, conditions):
+        ret_list = []
+        for cond in conditions.value:
+            parent_type = cond.type  # 父条件类型 (日期、天气、电价)
+            condition_class = self.condition_class_map[parent_type]
+            ctx = self._build_condition_ctx(cond)
+            for child_info in cond.data:
+                if child_info.childType == DateConditionType.duration:
+                    continue
+                ret = condition_class.meet_func(data=child_info, ctx=ctx)
+                app_log.info(f"IF条件 {child_info} 判断结果: {ret}")
+                ret_list.append(ret)
+                # 如果该条件判断不满足，并且客户设置为and,则无需继续判断，返回失败
+                if not ret and operation == LogicFunc.AND:
+                    return False
+                # 如果条件判断满足，并且客户设置为or,则无需继续判断，返回成功
+                if ret and operation == LogicFunc.OR:
+                    return True
+        if (operation == LogicFunc.AND and all(ret_list)) or (
+            operation == LogicFunc.OR and any(ret_list)
+        ):
+            return True
+        return False
+
+    @staticmethod
+    def _build_condition_ctx(condition_info: ConditionItem):
+        ctx = {}
+        if condition_info.type == ConditionType.cabinet:
+            ctx["cabinet"] = condition_info.cabinet
+        return ctx
+
+    def update_all_condition_data(self, condition_types: Set[ConditionType]):
+        for cond_type in condition_types:
+            self.condition_class_map[cond_type].update_value()

solax_py_library/smart_scene/exceptions/__init__.py

@@ -0,0 +1,7 @@
+from .price import ElectricityPriceFailure
+from .weather import WeatherFailure
+
+__all__ = [
+    "ElectricityPriceFailure",
+    "WeatherFailure",
+]

solax_py_library/smart_scene/exceptions/price.py

@@ -0,0 +1,5 @@
+from solax_py_library.exception import SolaxBaseError
+
+
+class ElectricityPriceFailure(SolaxBaseError):
+    message = "cloud__electricity_price_failure"

solax_py_library/smart_scene/exceptions/smart_scene.py

@@ -0,0 +1,82 @@
+from solax_py_library.exception import SolaxBaseError
+
+
+class MissParam(SolaxBaseError):
+    code = 0x2001
+    message = "smart_scene__miss_param"
+
+
+class OnlyPositive(MissParam):
+    message = "smart_scene__only_positive"
+
+
+class TimeRange(MissParam):
+    message = "smart_scene__time_range"
+
+
+class IrradianceOnlyPositive(MissParam):
+    message = "smart_scene__irradiance_only_positive"
+
+
+class ExportLimitNum(MissParam):
+    message = "smart_scene__export_limit_num"
+
+
+class ExportLimitPercent(MissParam):
+    message = "smart_scene__export_limit_percent"
+
+
+class ImportLimitNum(MissParam):
+    message = "smart_scene__import_limit_num"
+
+
+class ImportOnlyPositive(MissParam):
+    message = "smart_scene__import_only_positive"
+
+
+class SocLimit(MissParam):
+    message = "smart_scene__soc_limit"
+
+
+class ActivePowerLimitNum(MissParam):
+    message = "smart_scene__active_power_limit_num"
+
+
+class ReactivePowerLimitNum(MissParam):
+    message = "smart_scene__reactive_power_limit_num"
+
+
+class EnergyLimit(MissParam):
+    message = "smart_scene__energy_limit"
+
+
+class PowerLimitNum(MissParam):
+    message = "smart_scene__power_limit_num"
+
+
+class BatteryPowerLimitNum(MissParam):
+    message = "smart_scene__battery_power_limit_num"
+
+
+class PvOnlyGe0(MissParam):
+    message = "smart_scene__pv_only_ge_0"
+
+
+class CountLimit(MissParam):
+    message = "smart_scene__count_limit"
+
+
+class NameLengthLimit(MissParam):
+    message = "smart_scene__name_length_limit"
+
+
+class UniqueLimit(MissParam):
+    message = "smart_scene__unique_limit"
+
+
+class ElectricityPriceFailure(MissParam):
+    message = "cloud__electricity_price_failure"
+
+
+class WeatherFailure(MissParam):
+    message = "cloud__weather_failure"

solax_py_library/smart_scene/exceptions/weather.py

@@ -0,0 +1,5 @@
+from solax_py_library.exception import SolaxBaseError
+
+
+class WeatherFailure(SolaxBaseError):
+    message = "cloud__weather_failure"

solax_py_library/smart_scene/types/action.py

@@ -0,0 +1,164 @@
+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]