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

solax_py_library/exception.py

@@ -1,10 +1,10 @@
-class SolaxBaseError(Exception):
-    code = 0x1000
-    message = "upload error"
-
-    def __init__(self, *args, message=None):
-        super().__init__(*args)
-        self.message = message or self.message
-
-    def __str__(self):
-        return self.message
+class SolaxBaseError(Exception):
+    code = 0x1000
+    message = "upload error"
+
+    def __init__(self, *args, message=None):
+        super().__init__(*args)
+        self.message = message or self.message
+
+    def __str__(self):
+        return self.message

solax_py_library/smart_scene/constant/message_entry.py

@@ -0,0 +1,179 @@
+MESSAGE_ENTRY = {
+    "rec_name_01": {
+        "zh_CN": "负买电电价收益优化",
+        "en_US": "Optimization of the revenue from negative import electricity prices.",
+    },
+    "rec_name_02": {
+        "zh_CN": "负卖电电价收益优化",
+        "en_US": "Optimization of the revenue from negative export electricity prices.",
+    },
+    "instruction_01": {
+        "zh_CN": "当买电电价为负时，调整光伏和储能功率，将光伏功率降为最低，尽量从市电买电为电池充电",
+        "en_US": "When the electricity purchase price is negative, adjust the power of the photovoltaic system and the energy storage system. Reduce the photovoltaic power to the minimum and try to purchase electricity from the municipal power grid as much as possible to charge the battery.",
+    },
+    "instruction_02": {
+        "zh_CN": "当卖电电价为负时，调整系统馈网功率，不向电网馈电",
+        "en_US": "When the electricity selling price is negative, adjust the power fed back to the grid by the system and refrain from feeding power back to the grid.",
+    },
+    "IF": {"zh_CN": "IF条件", "en_US": "IF"},
+    "THEN": {"zh_CN": "THEN动作", "en_US": "THEN"},
+    "date": {"zh_CN": "日期: \n\t", "en_US": "Date: \n\t"},
+    "time": {"zh_CN": "时间", "en_US": "Time"},
+    "103": {"zh_CN": "仅一次", "en_US": "Once"},
+    "104": {"zh_CN": "每天", "en_US": "Everyday"},
+    "105": {"zh_CN": "工作日", "en_US": "Weekdays"},
+    "106": {"zh_CN": "周末", "en_US": "Weekends"},
+    "1": {"zh_CN": "周一", "en_US": "Mon"},
+    "2": {"zh_CN": "周二", "en_US": "Tues"},
+    "3": {"zh_CN": "周三", "en_US": "Wed"},
+    "4": {"zh_CN": "周四", "en_US": "Thur"},
+    "5": {"zh_CN": "周五", "en_US": "Fri"},
+    "6": {"zh_CN": "周六", "en_US": "Sat"},
+    "7": {"zh_CN": "周日", "en_US": "Sun"},
+    "weather": {"zh_CN": "天气: \n\t", "en_US": "Weather: \n\t"},
+    "irradiance": {
+        "zh_CN": "太阳辐照度 {} {}W/m² 且一天内累计有 {} 小时大于200W/m²",
+        "en_US": "The solar irradiance {} {}W/m², and totally there are {} hours in a day with a solar irradiance greater than 200W/m²",
+    },
+    "temperature": {"zh_CN": "温度 {} {} ℃", "en_US": "Temperature {} {} ℃"},
+    "humidity": {"zh_CN": "湿度 {} {} %RH", "en_US": "Humidity {} {} %RH"},
+    "wind": {"zh_CN": "风速 {} {} m/s", "en_US": "Wind speed {} {} m/s"},
+    "barometricPressure": {
+        "zh_CN": "气压 {} {} hPa",
+        "en_US": "Air pressure {} {} hPa",
+    },
+    "rain": {"zh_CN": "{} 下雨", "en_US": "It {} rain"},
+    "108": {"zh_CN": "会", "en_US": "will"},
+    "109": {"zh_CN": "不会", "en_US": "won''t"},
+    "forcastRain": {
+        "zh_CN": "未来 {} 小时会下雨",
+        "en_US": "It will rain in the next {} hours",
+    },
+    "100": {"zh_CN": "大于", "en_US": "is greater than"},
+    "101": {"zh_CN": "小于", "en_US": "is less than"},
+    "102": {"zh_CN": "等于", "en_US": "is equal to"},
+    "electricityPrice": {"zh_CN": "电价: \n\t", "en_US": "Electricity price: \n\t"},
+    "buyingPrice": {"zh_CN": "买电电价\n\t", "en_US": "Import price\n\t"},
+    "sellingPrice": {"zh_CN": "卖电电价\n\t", "en_US": "Export price\n\t"},
+    "price": {"zh_CN": "电价 {} {}{}", "en_US": "Electricity price {} {}{}"},
+    "lowerPrice": {
+        "zh_CN": "比最高的电价低 {}{}",
+        "en_US": "Lower than the highest electricity price by {}{} ",
+    },
+    "higherPrice": {
+        "zh_CN": "比最低的电价高 {}{}",
+        "en_US": "Higher than the lowest electricity price by {}{} ",
+    },
+    "expensiveHours": {
+        "zh_CN": "在 {} 到 {} 期间，电价最高的 {}小时",
+        "en_US": "During the period from {} to {}, the {}h with the highest electricity price",
+    },
+    "cheapestHours": {
+        "zh_CN": "在 {} 到 {} 期间，电价最低的 {} 小时",
+        "en_US": "During the period from {} to {}, the {}h with the lowest electricity price",
+    },
+    "system": {"zh_CN": "系统动作\n\t", "en_US": "System\n\t"},
+    "systemSwitch": {"zh_CN": "系统开关 {}", "en_US": "System {}"},
+    "on": {"zh_CN": "开", "en_US": "ON"},
+    "off": {"zh_CN": "关", "en_US": "OFF"},
+    "exportControl": {
+        "zh_CN": "馈网控制 {}, {}, 设置值为 {}{}",
+        "en_US": "Export_control {}, the mode is {}, the value is {}{}",
+    },
+    "exportControlOff": {"zh_CN": "馈网控制 关", "en_US": "Export_control off"},
+    "total": {"zh_CN": "总和方式", "en_US": "Total"},
+    "per phase": {"zh_CN": "分相模式", "en_US": "Per phase"},
+    "importControl_AELIO": {
+        "zh_CN": "需量控制 {}, 设置值为 {} kW",
+        "en_US": "Import_control {}, the value is {} kW",
+    },
+    "importControl": {
+        "zh_CN": "需量控制 {}, 模式: {}, 设置值为 {} kW",
+        "en_US": "Import_control {}, Control mode: {}, the value is {} kW",
+    },
+    "importControl_standby": {
+        "zh_CN": "降低储能充电功率，直到待机",
+        "en_US": "Reduce battery charge power until standby",
+    },
+    "importControl_discharge": {
+        "zh_CN": "降低储能充电功率，必要时储能放电",
+        "en_US": "Reduce battery charge power and discharge battery if necessary",
+    },
+    "importControlOff": {"zh_CN": "需量控制 关", "en_US": "Import_control off"},
+    "workMode": {"zh_CN": "工作模式为 {}", "en_US": "Work_mode is {}"},
+    "Self-use": {"zh_CN": "自发自用", "en_US": "Self-use"},
+    "Feedin priority": {"zh_CN": "并网优先", "en_US": "Feedin priority"},
+    "Back up mode": {"zh_CN": "备用模式", "en_US": "Back up mode"},
+    "Manual mode": {"zh_CN": "手动模式 - {}", "en_US": "Manual mode - {}"},
+    "Forced charging": {
+        "zh_CN": "以{}kW的功率充电至{}%",
+        "en_US": "Charge at a power of {} kW until it reaches {}%",
+    },
+    "Forced discharging": {
+        "zh_CN": "以{}kW的功率放电至{}%",
+        "en_US": "Discharge at a power of {} kW until it reaches {}%",
+    },
+    "Stop charging and discharging": {
+        "zh_CN": "停止充放电",
+        "en_US": "Stop charging and discharging",
+    },
+    "Peak Shaving": {"zh_CN": "削峰填谷", "en_US": "Peak Shaving"},
+    "VPP": {"zh_CN": "VPP", "en_US": "VPP"},
+    "Power Control Mode": {
+        "zh_CN": "有功功率目标为 {}kW，无功功率目标为 {}kVar",
+        "en_US": "Active power target is {}kW. Reactive power target is {}kVar",
+    },
+    "Electric Quantity Target Control Mode": {
+        "zh_CN": "电能目标 {}kWh, 充放电功率目标 {}kW",
+        "en_US": "Energy target is {}kWh, Charge or Discharge power target is {}kW",
+    },
+    "SOC Target Control Mode": {
+        "zh_CN": "目标SOC {}%, 充放电功率目标 {}kW",
+        "en_US": "target SOC is {}%, Charge or Discharge power target is {}kW",
+    },
+    "Push Power - Positive/Negative Mode": {
+        "zh_CN": "电池功率目标 {}kW",
+        "en_US": "Battery power target is {}kW",
+    },
+    "Push Power - Zero Mode": {
+        "zh_CN": "电池不充放",
+        "en_US": "Battery not charging or discharging",
+    },
+    "Self-Consume - Charge/Discharge Mode": {
+        "zh_CN": "自发自用，电池仅从PV充电",
+        "en_US": "Self-use. The battery can be charged from PV only",
+    },
+    "Self-Consume - Charge Only Mode": {
+        "zh_CN": "自发自用，电池仅从PV充电并且不可放电",
+        "en_US": "Self-use. The battery can be charged from PV only, and battery discharge is not allowed",
+    },
+    "PV&BAT Individual Setting – Duration Mode": {
+        "zh_CN": "光伏功率目标 {}kW, 电池功率目标 {}kW",
+        "en_US": "PV power target is {}kW. Battery power target is {}kW",
+    },
+    "PV&BAT Individual Setting – Target SOC Mode": {
+        "zh_CN": "光伏功率目标 {}kW, 电池功率目标 {}kW, 目标SOC {}%",
+        "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 {} {}%"},
+    "systemImportPower": {
+        "zh_CN": "电价买电功率 {} {}KW",
+        "en_US": "system soc {} {}KW",
+    },
+    "systemExportPower": {
+        "zh_CN": "电价馈电功率 {} {}KW",
+        "en_US": "system soc {} {}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 {}"},
+    "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"},
+}

solax_py_library/smart_scene/core/action/base.py

@@ -0,0 +1,10 @@
+class BaseAction(object):
+    def __init__(self, smart_scene_service, do_funcs, **kwargs):
+        self.smart_scene_service = smart_scene_service
+        self.do_func_map = do_funcs
+
+    def do_func(self, scene_id, data):
+        child_data = data.childData
+        child_type = data.childType
+        do_func = self.do_func_map.get(child_type)
+        return do_func(scene_id, child_data.data)

solax_py_library/smart_scene/core/action/ems_action.py

@@ -0,0 +1,6 @@
+from solax_py_library.smart_scene.core.action.base import BaseAction
+from solax_py_library.smart_scene.types.action import ActionType
+
+
+class EMS1000Action(BaseAction):
+    action_type = ActionType.EMS1000

solax_py_library/smart_scene/core/action/system_action.py

@@ -0,0 +1,6 @@
+from solax_py_library.smart_scene.core.action.base import BaseAction
+from solax_py_library.smart_scene.types.action import ActionType
+
+
+class SystemAction(BaseAction):
+    action_type = ActionType.system

solax_py_library/smart_scene/core/condition/__init__.py

@@ -0,0 +1,17 @@
+from .base import BaseCondition
+from .cabinet_condition import CabinetCondition
+from .date_condition import DateCondition
+from .weather_condition import WeatherCondition
+from .price_condition import EleSellPriceCondition, ElsBuyPriceCondition
+from .system_condition import SystemCondition
+
+
+__all__ = [
+    "BaseCondition",
+    "CabinetCondition",
+    "DateCondition",
+    "WeatherCondition",
+    "ElsBuyPriceCondition",
+    "EleSellPriceCondition",
+    "SystemCondition",
+]

solax_py_library/smart_scene/core/condition/base.py

@@ -0,0 +1,17 @@
+class BaseCondition(object):
+    condition_type = None
+
+    def __init__(self, update_value_function, **kwargs):
+        self.value = {}
+        if not callable(update_value_function):
+            raise ValueError("update_value_function must be callable")
+        self.update_value_function = update_value_function
+
+    def update_value(self):
+        new_value = self.update_value_function()
+        if not isinstance(new_value, dict):
+            raise ValueError("update_value_function must return a dict")
+        self.value.update(new_value)
+
+    def meet_func(self, data, ctx):
+        ...

solax_py_library/smart_scene/core/condition/cabinet_condition.py

@@ -0,0 +1,44 @@
+from collections import defaultdict
+
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import (
+    CabinetConditionItemData,
+    CabinetConditionType,
+    ConditionType,
+)
+from solax_py_library.device.types.alarm import AlarmLevel
+
+
+class CabinetCondition(BaseCondition):
+    condition_type = ConditionType.cabinet
+
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+        self.value = defaultdict(
+            lambda: {
+                "soc": 0,
+                "alarm_level": {
+                    AlarmLevel.EMERGENCY: False,
+                    AlarmLevel.NORMAL: False,
+                    AlarmLevel.TIPS: False,
+                },
+            }
+        )
+
+    def meet_func(self, data: CabinetConditionItemData, ctx):
+        if not self.value:
+            return False
+        cabinet = ctx["cabinet"] or []
+        for cabinet_sn in cabinet:
+            if data.childType == CabinetConditionType.cabinetSoc:
+                if self.value[cabinet_sn]["soc"] is None:
+                    return False
+                if data.childData.function.function()(
+                    compare_value=self.value[cabinet_sn]["soc"],
+                    base_value=data.childData.data[0],
+                ):
+                    return True
+            elif data.childType == CabinetConditionType.cabinetAlarm:
+                if self.value[cabinet_sn]["alarm_level"][data.childData.data[0]]:
+                    return True
+        return False

solax_py_library/smart_scene/core/condition/date_condition.py

@@ -0,0 +1,23 @@
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import (
+    DateConditionItemData,
+    DateConditionType,
+    ConditionType,
+)
+
+
+class DateCondition(BaseCondition):
+    condition_type = ConditionType.date
+
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+
+    def meet_func(self, data: DateConditionItemData, ctx):
+        if data.childType == DateConditionType.time:
+            date = data.childData.data[0]
+            hour, minute = date.split(":")
+            if int(hour) == self.value.get("hour") and int(minute) == self.value.get(
+                "minute"
+            ):
+                return True
+        return False

solax_py_library/smart_scene/core/condition/price_condition.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import (
+    PriceConditionItemData,
+    PriceConditionType,
+    SmartSceneUnit,
+    ConditionFunc,
+    ConditionType,
+)
+from solax_py_library.utils.time_util import (
+    trans_str_time_to_index,
+    get_highest_or_lowest_value,
+)
+
+
+class ElePriceCondition(BaseCondition):
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+        self.buy = None
+
+    def meet_func_price(self, function_value: ConditionFunc, data_value, index) -> bool:
+        """电价条件的判定"""
+        price = self.value["price"]
+        if index < 0 or index > len(price):
+            return False
+        if price[index] is None:
+            return False
+        return function_value.function()(price[index], data_value[0])
+
+    def meet_func_highest_price(self, data_value, index) -> bool:
+        value, unit = data_value
+        price = self.value["price"]
+        if None in price[0:96]:
+            return False
+        if unit == SmartSceneUnit.NUM:  # 比最高电价低X元
+            base = max(price[0:96]) - value
+        else:  # 比最高电价低X%
+            base = round(max(price[0:96]) * (1 - value / 100), 4)
+        if self.value[index] <= base:
+            return True
+        else:
+            return False
+
+    def meet_func_lowest_price(self, data_value, index) -> bool:
+        value, unit = data_value
+        price = self.value["price"]
+        if None in price[0:96]:
+            return False
+        if unit == SmartSceneUnit.NUM:  # 比最低电价高X元
+            base = value - min(price[0:96])
+        else:  # 比最低电价高X%
+            base = round(min(price[0:96]) * (1 + value / 100), 4)
+        if price[index] >= base:
+            return True
+        else:
+            return False
+
+    def meet_func_highest_or_lowest_hours(self, data_value, index, reverse) -> bool:
+        sort_index, start_index = get_highest_or_lowest_value(
+            data_value[0],
+            data_value[1],
+            data_value[2],
+            self.value["price"],
+            reverse=reverse,
+        )
+        if sort_index and index - start_index in sort_index:
+            return True
+        return False
+
+    def meet_func(self, data: PriceConditionItemData, ctx):
+        if not self.value or not self.value.get("price"):
+            # 未获取到价格数据，直接返回
+            return False
+        child_data = data.childData
+        child_type = data.childType
+        data_value = child_data.data
+        now_time = datetime.strftime(datetime.now(), "%H:%M")
+        index = trans_str_time_to_index(now_time)
+        if child_type == PriceConditionType.price:
+            return self.meet_func_price(child_data.function, data_value, index)
+        elif child_type == PriceConditionType.lowerPrice:
+            return self.meet_func_highest_price(data_value, index)
+        elif child_type == PriceConditionType.higherPrice:
+            return self.meet_func_lowest_price(data_value, index)
+        elif child_type == PriceConditionType.expensiveHours:
+            return self.meet_func_highest_or_lowest_hours(
+                data_value, index, reverse=True
+            )
+        elif child_type == PriceConditionType.cheapestHours:
+            return self.meet_func_highest_or_lowest_hours(
+                data_value, index, reverse=False
+            )
+        return False
+
+
+class EleSellPriceCondition(ElePriceCondition):
+    condition_type = ConditionType.sellingPrice
+
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+        self.buy = False
+
+
+class ElsBuyPriceCondition(ElePriceCondition):
+    condition_type = ConditionType.buyingPrice
+
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+        self.buy = True

solax_py_library/smart_scene/core/condition/system_condition.py

@@ -0,0 +1,35 @@
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import (
+    SystemConditionItemData,
+    SystemConditionType,
+    ConditionType,
+)
+
+
+class SystemCondition(BaseCondition):
+    condition_type = ConditionType.systemCondition
+
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+
+    def meet_func(self, data: SystemConditionItemData, ctx):
+        if not self.value:
+            return False
+        child_data = data.childData
+        function_value = child_data.function
+        compare_value = None
+        if data.childType == SystemConditionType.systemExportPower:
+            compare_value = self.value.get("grid_active_power")
+            if compare_value < 0:
+                return False
+        elif data.childType == SystemConditionType.systemImportPower:
+            compare_value = self.value.get("grid_active_power")
+            if compare_value > 0:
+                return False
+        elif data.childType == SystemConditionType.systemSoc:
+            compare_value = self.value.get("system_soc")
+        if compare_value is None:
+            return False
+        return function_value.function()(
+            compare_value=abs(compare_value), base_value=child_data.data[0]
+        )

solax_py_library/smart_scene/core/condition/weather_condition.py

@@ -0,0 +1,61 @@
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import (
+    WeatherConditionItemData,
+    WeatherConditionType,
+    ConditionType,
+)
+from solax_py_library.utils.time_util import get_rounded_times
+
+
+class WeatherCondition(BaseCondition):
+    condition_type = ConditionType.weather
+
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+
+    def meet_func(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 = 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)
+        if child_type == WeatherConditionType.irradiance:
+            return self.meet_func_irradiance(function_value, data_value, index)
+        elif child_type == WeatherConditionType.temperature:
+            return function_value.function()(
+                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 function_value.function()(
+            self.value["irradiance"]["valueList"][index], irradiance
+        )

solax_py_library/smart_scene/core/service/__init__.py

@@ -0,0 +1,3 @@
+from .runner import SmartSceneRunner
+
+__all__ = ["SmartSceneRunner"]