solax-py-library 1.0.0.24__py3-none-any.whl → 1.0.0.2501__py3-none-any.whl

solax_py_library/smart_scene/core/condition/weather_condition.py

@@ -0,0 +1,67 @@
+
+class WeatherCondition(BaseCondition):
+    def __init__(self, smart_scene_service):
+        super().__init__(smart_scene_service)
+        self.type = IF_ELE_TYPE
+        self.buy = True
+        self.child_type_list = ["irradiance", "temperature"]
+        self.value = {}
+        self.unit = ""
+        self.meet_func = self.meet_weather_condition
+
+    def update_value(
+        self,
+    ):
+        self.value = self.smart_scene_service.get_weather_data_from_redis()
+
+    def meet_weather_condition(self, data: WeatherConditionItemData, ctx):
+        if not self.value:
+            return False
+        child_data = data.childData
+        child_type = data.childType
+        function_value = child_data.function
+        data_value = child_data.data
+        nearest_time, right_time = self.smart_scene_service.get_rounded_times()
+        if nearest_time not in self.value["timeList"]:
+            time_now = right_time
+        else:
+            time_now = nearest_time
+        index = self.value["timeList"].index(time_now)
+        app_log.info(
+            f"最近时间点为: {nearest_time}, 右侧时间点为: {right_time}, 数组索引为: {index}"
+        )
+        if child_type == WeatherConditionType.irradiance:
+            return self.meet_func_irradiance(function_value, data_value, index)
+        elif child_type == WeatherConditionType.temperature:
+            app_log.info(f"当前实际值为: {self.value[child_type]['valueList'][index]}")
+            return self.smart_scene_service.compare_the_magnitudes(
+                function_value,
+                self.value[child_type]["valueList"][index],
+                data_value[0],
+            )
+        return False
+
+    def meet_func_irradiance(self, function_value, data_value, index):
+        """太阳辐照度判断"""
+        irradiance = data_value[0]
+        duration = data_value[1]
+        meet_num = 0
+        meet_flag = False
+        if duration == 0:
+            meet_flag = True
+        elif duration > 24:
+            pass
+        else:
+            # 1. 保证累计duration个小时大于200,
+            for value in self.value["irradiance"]["valueList"]:
+                if value > 200:
+                    meet_num += 1
+                    if meet_num >= duration * 4:
+                        meet_flag = True
+                        break
+        if not meet_flag:
+            return False
+        # 2. 再判断当前太阳辐照度
+        return self.smart_scene_service.compare_the_magnitudes(
+            function_value, self.value["irradiance"]["valueList"][index], irradiance
+        )

solax_py_library/smart_scene/exceptions/price.py

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

solax_py_library/smart_scene/exceptions/smart_scene.py

@@ -0,0 +1,81 @@
+from solax_py_library.exception import SolaxBaseError
+
+
+class OnlyPositive(SolaxBaseError):
+    message = "smart_scene__time_range"
+
+
+class TimeRange(SolaxBaseError):
+    message = "smart_scene__irradiance_only_positive"
+
+
+class IrradianceOnlyPositive(SolaxBaseError):
+    message = "smart_scene__export_limit_num"
+
+
+class ExportLimitNum(SolaxBaseError):
+    message = "smart_scene__export_limit_percent"
+
+
+class ExportLimitPercent(SolaxBaseError):
+    message = "smart_scene__import_limit_num"
+
+
+class ImportLimitNum(SolaxBaseError):
+    message = "smart_scene__import_only_positive"
+
+
+class ImportOnlyPositive(SolaxBaseError):
+    message = "smart_scene__soc_limit"
+
+
+class SocLimit(SolaxBaseError):
+    message = "smart_scene__active_power_limit_num"
+
+
+class ActivePowerLimitNum(SolaxBaseError):
+    message = "smart_scene__reactive_power_limit_num"
+
+
+class ReactivePowerLimitNum(SolaxBaseError):
+    message = "smart_scene__energy_limit"
+
+
+class EnergyLimit(SolaxBaseError):
+    message = "smart_scene__power_limit_num"
+
+
+class PowerLimitNum(SolaxBaseError):
+    message = "smart_scene__battery_power_limit_num"
+
+
+class BatteryPowerLimitNum(SolaxBaseError):
+    message = "smart_scene__pv_only_ge_0"
+
+
+class PvOnlyGe0(SolaxBaseError):
+    message = "smart_scene__miss_param"
+
+
+class MissParam(SolaxBaseError):
+    message = "smart_scene__count_limit"
+
+
+class CountLimit(SolaxBaseError):
+    message = "smart_scene__name_length_limit"
+
+
+class NameLengthLimit(SolaxBaseError):
+    message = "smart_scene__unique_limit"
+
+
+class UniqueLimit(SolaxBaseError):
+    message = "cloud__electricity_price_failure"
+
+
+class ElectricityPriceFailure(SolaxBaseError):
+    message = "cloud__weather_failure"
+
+
+class WeatherFailure(SolaxBaseError):
+    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,156 @@
+from enum import Enum
+from typing import List, Union
+
+from pydantic import BaseModel
+
+from domain.ems_enum.smart_scene.base import MESSAGE_ENTRY
+from settings.const import DeviceInfo
+
+
+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[Union[int, float, DoControl]]
+
+
+class SystemActionItemData(BaseModel):
+    childType: SystemActionType
+    childData: ActionChildData
+
+    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 DeviceInfo.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 EmsActionItemData(BaseModel):
+    childType: EmsActionType
+    childData: ActionChildData
+
+    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/smart_scene/types/condition.py

@@ -0,0 +1,293 @@
+from enum import IntEnum, Enum
+from typing import Optional, List, Union, Any
+
+from pydantic import BaseModel, validator, root_validator
+
+from solax_py_library.smart_scene.constant.message_entry import MESSAGE_ENTRY
+
+
+class LogicFunc(IntEnum):
+    OR = 0
+    AND = 1
+
+
+class ConditionFunc(IntEnum):
+    GT = 100
+    LT = 101
+    EQ = 102
+
+
+class RepeatFunc(IntEnum):
+    ONCE = 103
+    EVERYDAY = 104
+    WEEKDAY = 105
+    WEEKEND = 106
+    CUSTOM = 107
+
+
+class ConditionType(str, Enum):
+    date = "date"
+    weather = "weather"
+    buyingPrice = "buyingPrice"
+    sellingPrice = "sellingPrice"
+    systemCondition = "systemCondition"
+    cabinet = "cabinet"
+
+
+class WeatherConditionType(str, Enum):
+    irradiance = "irradiance"
+    temperature = "temperature"
+
+
+class PriceConditionType(str, Enum):
+    price = "price"
+    lowerPrice = "lowerPrice"
+    higherPrice = "higherPrice"
+    expensiveHours = "expensiveHours"
+    cheapestHours = "cheapestHours"
+
+
+class DateConditionType(str, Enum):
+    time = "time"
+    duration = "duration"
+
+
+class SystemConditionType(str, Enum):
+    systemSoc = "systemSoc"
+    systemImportPower = "systemImportPower"  # 买电功率
+    systemExportPower = "systemExportPower"  # 馈电功率
+
+
+class CabinetConditionType(str, Enum):
+    cabinetAlarm = "cabinetAlarm"
+    cabinetSoc = "cabinetSoc"
+
+
+class SmartSceneUnit(IntEnum):
+    PERCENT = 1
+    NUM = 2
+
+
+class ConditionItemChildData(BaseModel):
+    function: Optional[ConditionFunc]
+    data: List[Any]
+
+
+class PriceConditionItemData(BaseModel):
+    childType: PriceConditionType
+    childData: ConditionItemChildData
+
+    @validator("childData", always=True)
+    def _check_child_data(cls, value, values):
+        childType = values.get("childType")
+        if childType in {
+            PriceConditionType.lowerPrice,
+            PriceConditionType.higherPrice,
+        }:
+            assert value.data[0] > 0, ValueError
+        elif childType in {
+            PriceConditionType.expensiveHours,
+            PriceConditionType.cheapestHours,
+        }:
+            assert 1 <= value.data[2] <= 24, ValueError
+        return value
+
+    def to_text(self, lang, unit):
+        data = self.childData.data
+        func = self.childData.function
+        if self.childType == PriceConditionType.price:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[str(func.value)][lang], data[0], unit
+            )
+        elif self.childType in {
+            PriceConditionType.lowerPrice,
+            PriceConditionType.higherPrice,
+        }:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                data[0], "%" if data[1] == 1 else unit
+            )
+        elif self.childType in {
+            PriceConditionType.expensiveHours,
+            PriceConditionType.cheapestHours,
+        }:
+            return MESSAGE_ENTRY[self.childType][lang].format(data[0], data[1], data[2])
+
+
+class SystemConditionItemData(BaseModel):
+    childType: SystemConditionType
+    childData: ConditionItemChildData
+
+    @validator("childData", always=True)
+    def _check_child_data(cls, value, values):
+        childType = values.get("childType")
+        if childType in {
+            SystemConditionType.systemExportPower,
+            SystemConditionType.systemImportPower,
+        }:
+            assert 0 <= value.data[0] <= 100000, ValueError
+            value.data[0] = round(value.data[0], 2)  # 功率保留两位小数
+        elif childType == SystemConditionType.systemSoc:
+            assert 5 <= value.data[0] <= 100, ValueError
+        return value
+
+    def to_text(self, lang, unit):
+        data = self.childData.data
+        func = self.childData.function
+        if self.childType == SystemConditionType.systemSoc:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[str(func.value)][lang], data[0]
+            )
+        elif self.childType in {
+            SystemConditionType.systemImportPower,
+            SystemConditionType.systemExportPower,
+        }:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[str(func.value)][lang], data[0]
+            )
+
+
+class CabinetConditionItemData(BaseModel):
+    childType: CabinetConditionType
+    childData: ConditionItemChildData
+
+    @validator("childData", always=True)
+    def _check_child_data(cls, value, values):
+        childType = values.get("childType")
+        # if childType == CabinetConditionType.cabinetAlarm:
+        #     assert value.data[0] in {
+        #         AlarmLevel.TIPS,
+        #         AlarmLevel.NORMAL,
+        #         AlarmLevel.EMERGENCY,
+        #     }, ValueError
+        if childType == CabinetConditionType.cabinetSoc:
+            assert 0 <= value.data[0] <= 100, ValueError
+        return value
+
+    def to_text(self, lang, unit):
+        data = self.childData.data
+        func = self.childData.function
+        if self.childType == CabinetConditionType.cabinetSoc:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[str(func.value)][lang], data[0]
+            )
+        elif self.childType == CabinetConditionType.cabinetAlarm:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[str(data[0])][lang], lang
+            )
+
+
+class DateConditionItemData(BaseModel):
+    childType: DateConditionType
+    childData: ConditionItemChildData
+
+    @validator("childData", always=True)
+    def check_param(cls, value, values):
+        childType = values.get("childType")
+        data = value.data
+        if childType == DateConditionType.time:
+            assert isinstance(data[0], str), ValueError
+        elif childType == DateConditionType.duration:
+            assert isinstance(data[0], int), ValueError
+        return value
+
+    def to_text(self, lang, unit):
+        if self.childType == DateConditionType.duration:
+            return MESSAGE_ENTRY[self.childType][lang].format(self.childData.data[0])
+        elif self.childType == DateConditionType.time:
+            return MESSAGE_ENTRY[self.childType][lang] + "/" + self.childData.data[0]
+
+
+class WeatherConditionItemData(BaseModel):
+    childType: WeatherConditionType
+    childData: ConditionItemChildData
+
+    @validator("childData", always=True)
+    def _check_child_data(cls, value, values):
+        childType = values.get("childType")
+        if childType == WeatherConditionType.irradiance:
+            assert value.data[0] > 0, ValueError
+            assert 0 <= value.data[1] <= 24, ValueError
+        return value
+
+    def to_text(self, lang, unit):
+        func = self.childData.function
+        data = self.childData.data
+        if self.childType == WeatherConditionType.irradiance:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[str(func.value)][lang], data[0], data[1]
+            )
+        else:
+            return MESSAGE_ENTRY[self.childType][lang].format(
+                MESSAGE_ENTRY[str(func.value)][lang], data[0]
+            )
+
+
+class ConditionItem(BaseModel):
+    type: ConditionType
+    cabinet: Optional[List[str]]
+    data: List[
+        Union[
+            DateConditionItemData,
+            WeatherConditionItemData,
+            PriceConditionItemData,
+            SystemConditionItemData,
+            CabinetConditionItemData,
+        ]
+    ]
+
+    @validator("cabinet")
+    def _check_cabinet(cls, value, values):
+        condition_type = values.get("type")
+        if condition_type == ConditionType.cabinet:
+            assert value, "cabinet is None"
+        return value
+
+    def to_text(self, lang, unit):
+        if self.type != ConditionType.cabinet:
+            return {self.type: [d.to_text(lang, unit) for d in self.data]}
+        elif self.type == ConditionType.cabinet:
+            cabinet_sns = ",".join(self.cabinet)
+            return {self.type: [d.to_text(lang, unit) for d in self.data] + [cabinet_sns]}
+
+
+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],
+        #     "value": {}
+        # }
+        ret = {}
+        for v in self.value:
+            # ret["value"].update(v.to_text(lang, unit))
+            ret.update(v.to_text(lang, unit))
+        return ret
+
+    def get_duration_info(self):
+        for item in self.value:
+            if item.type != ConditionType.date:
+                continue
+            for date_item in item.data:
+                if date_item.childType == DateConditionType.duration:
+                    return (date_item.childData.data[0] // 10) + 1
+        return 1