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

solax_py_library/smart_scene/constant/message_entry.py

@@ -0,0 +1,338 @@
+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"
+  }
+}

solax_py_library/smart_scene/core/condition/base.py

@@ -0,0 +1,12 @@
+class BaseCondition(object):
+    def __init__(self):
+        # 子条件类型
+        self.child_type_list = []
+        # 各子条件的值
+        self.value = {}
+        # 判断是否满足条件的子条件-判断函数的映射
+        self.meet_func_dict = {}
+
+    def update_value(self):
+        """更新条件值"""
+        ...

solax_py_library/smart_scene/core/condition/cabinet_condition.py

@@ -0,0 +1,104 @@
+
+class CabinetCondition(BaseCondition):
+    def __init__(self, smart_scene_service):
+        super().__init__(smart_scene_service)
+        self.type = IF_ELE_TYPE
+        self.value = defaultdict(
+            lambda: {
+                "soc": None,
+                "alarm_level": {
+                    AlarmLevel.EMERGENCY: False,
+                    AlarmLevel.NORMAL: False,
+                    AlarmLevel.TIPS: False,
+                },
+            }
+        )
+        self.meet_func = self.meet_cabinet_condition
+
+    def update_value(self):
+        # 查询实时数据
+        cabinet_sns = [c.SN for c in self.db_service.get_all_cabinet()]
+        self._update_cabinet_soc(cabinet_sns)
+        self._update_cabinet_alarm(cabinet_sns)
+
+    def _update_cabinet_alarm(self, cabinet_sns):
+        all_alarm_code = self.redis_service.get_all_device_alarm_code()
+        if not all_alarm_code:
+            return
+
+        cabinet_sn_pcs_sn_map = defaultdict(list)
+        for pcs in self.db_service.get_pcs_by_cabinet(cabinet_sns):
+            cabinet_sn_pcs_sn_map[pcs.cabinetSN].append(pcs.SN)
+
+        cabinet_sn_bms_sn_map = defaultdict(list)
+        for bms in self.db_service.get_bms_by_cabinet(cabinet_sns):
+            cabinet_sn_bms_sn_map[bms.cabinetSN].append(bms.SN)
+
+        cabinet_sn_io_sn_map = defaultdict(list)
+        for io in self.db_service.get_io_by_cabinet(cabinet_sns):
+            cabinet_sn_io_sn_map[io.cabinetSN].append(io.SN)
+
+        for sn in cabinet_sns:
+            cabinet_alarm = set(all_alarm_code.get(sn, []))
+            pcs_alarm = set()
+            for pcs_sn in cabinet_sn_pcs_sn_map.get(sn, []):
+                pcs_alarm.update(all_alarm_code.get(pcs_sn, []))
+
+            bms_alarm = set()
+            for bms_sn in cabinet_sn_bms_sn_map.get(sn, []):
+                bms_alarm.update(all_alarm_code.get(bms_sn, []))
+
+            io_alarm = set()
+            for io_sn in cabinet_sn_io_sn_map.get(sn, []):
+                io_alarm.update(all_alarm_code.get(io_sn, []))
+
+            self.value[sn]["alarm_level"][AlarmLevel.TIPS] = any(
+                [
+                    bool(cabinet_alarm & set(AlarmPointInfo.CABINET_TIPS_ALARM_DATA)),
+                    bool(pcs_alarm & set(AlarmPointInfo.PCS_TIPS_ALARM_DATA)),
+                    bool(bms_alarm & set(AlarmPointInfo.BMS_TIPS_ALARM_DATA)),
+                    bool(io_alarm & set(AlarmPointInfo.IO_TIPS_ALARM_DATA)),
+                ]
+            )
+            self.value[sn]["alarm_level"][AlarmLevel.NORMAL] = any(
+                [
+                    bool(cabinet_alarm & set(AlarmPointInfo.CABINET_NORMAL_ALARM_DATA)),
+                    bool(pcs_alarm & set(AlarmPointInfo.PCS_NORMAL_ALARM_DATA)),
+                    bool(bms_alarm & set(AlarmPointInfo.BMS_NORMAL_ALARM_DATA)),
+                    bool(io_alarm & set(AlarmPointInfo.IO_NORMAL_ALARM_DATA)),
+                ]
+            )
+            self.value[sn]["alarm_level"][AlarmLevel.EMERGENCY] = any(
+                [
+                    bool(
+                        cabinet_alarm & set(AlarmPointInfo.CABINET_EMERGENCY_ALARM_DATA)
+                    ),
+                    bool(pcs_alarm & set(AlarmPointInfo.PCS_EMERGENCY_ALARM_DATA)),
+                    bool(bms_alarm & set(AlarmPointInfo.BMS_EMERGENCY_ALARM_DATA)),
+                    bool(io_alarm & set(AlarmPointInfo.IO_EMERGENCY_ALARM_DATA)),
+                ]
+            )
+
+    def _update_cabinet_soc(self, cabinet_sns):
+        for sn in cabinet_sns or []:
+            result = self.smart_scene_service.redis_service.get_bms_current_data(sn)
+            self.value[sn]["soc"] = result[14] if result else 0
+
+    def meet_cabinet_condition(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 self.smart_scene_service.compare_the_magnitudes(
+                    data.childData.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,26 @@
+from datetime import datetime
+
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import DateConditionItemData, DateConditionType
+
+
+class DateCondition(BaseCondition):
+    def __init__(self):
+        super().__init__()
+        self.value = {}
+
+    def update_value(self):
+        """获取time 类型需要的数据"""
+        now = datetime.now()
+        self.hour = now.hour
+        self.minute = now.minute
+
+    def meet_func(self, data: DateConditionItemData, ctx):
+        if data.childType == DateConditionType.time:
+            """判断是否满足日期时间类条件"""
+            date = data.childData.data[0]
+            hour = int(date.split(":")[0])
+            minute = int(date.split(":")[1])
+            if hour == self.hour and minute == self.minute:
+                return True
+        return False

solax_py_library/smart_scene/core/condition/price_condition.py

@@ -0,0 +1,105 @@
+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
+
+
+class ElePriceCondition(BaseCondition):
+    def __init__(self):
+        super().__init__()
+        self.buy = True
+        self.value = {}
+        self.unit = None
+
+    def update_value(self):
+        """获取电价 类型需要的数据"""
+        ele_info = self.smart_scene_service.get_electrovalence_data()
+        if self.buy:
+            self.value = ele_info.get("buy", [])
+        else:
+            self.value = ele_info.get("sell", [])
+        self.unit = ele_info.get("ele_unit", " ")
+
+    def meet_func_price(self, function_value, data_value, index) -> bool:
+        """电价条件的判定"""
+        if index < 0 or index > len(self.value):
+            return False
+        if self.value[index] is None:
+            return False
+        return self.smart_scene_service.compare_the_magnitudes(
+            function_value, self.value[index], data_value[0]
+        )
+
+    def meet_func_highest_price(self, data_value, index) -> bool:
+        value, unit = data_value
+        if None in self.value[0:96]:
+            return False
+        if unit == SmartSceneUnit.NUM:  # 比最高电价低X元
+            base = max(self.value[0:96]) - value
+        else:  # 比最高电价低X%
+            base = round(max(self.value[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
+        if None in self.value[0:96]:
+            return False
+        if unit == SmartSceneUnit.NUM:  # 比最低电价高X元
+            base = value - min(self.value[0:96])
+        else:  # 比最低电价高X%
+            base = round(min(self.value[0:96]) * (1 + value / 100), 4)
+        if self.value[index] >= base:
+            return True
+        else:
+            return False
+
+    def meet_func_highest_or_lowest_hours(self, data_value, index, func) -> bool:
+        sort_index, start_index = self.smart_scene_service.get_highest_or_lowest_price(
+            data_value[0], data_value[1], data_value[2], self.value, func=func
+        )
+        if not sort_index:
+            return False
+        if index - start_index in sort_index:
+            return True
+        else:
+            return False
+
+    def meet_func(self, data: PriceConditionItemData, ctx):
+        if not self.value:
+            # 未获取到价格数据，直接返回
+            return False
+        child_data = data.childData
+        child_type = data.childType
+        data_value = child_data.data
+        now_time = datetime.strftime(datetime.now(), "%H:%M")
+        index = self.smart_scene_service.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, "expensive_hours"
+            )
+        elif child_type == PriceConditionType.cheapestHours:
+            return self.meet_func_highest_or_lowest_hours(
+                data_value, index, "cheapest_hours"
+            )
+        return False
+
+
+class EleSellPriceCondition(ElePriceCondition):
+    def __init__(self):
+        super().__init__()
+        self.buy = False
+
+
+class ElsBuyPriceCondition(ElePriceCondition):
+    def __init__(self):
+        super().__init__()
+        self.buy = True

solax_py_library/smart_scene/core/condition/system_condition.py

@@ -0,0 +1,41 @@
+
+
+class SystemCondition(BaseCondition):
+    def __init__(self, smart_scene_service):
+        super().__init__(smart_scene_service)
+        self.type = IF_ELE_TYPE
+        self.value = {}
+        self.meet_func = self.meet_system_condition
+
+    def update_value(self):
+        overview_statistic_data = (
+            self.smart_scene_service.redis_service.get_overview_statistic_data()
+        )
+        self.value["grid_active_power"] = overview_statistic_data[8]
+        self.value["system_soc"] = overview_statistic_data[16]
+
+    def meet_system_condition(self, data: SystemConditionItemData, ctx):
+        if not self.value:
+            return False
+        child_data = data.childData
+        function_value = child_data.function
+        compare_value = None
+        app_log.info(self.value)
+        if data.childType == SystemConditionType.systemExportPower:
+            compare_value = self.value["grid_active_power"]
+            if compare_value < 0:
+                return False
+        elif data.childType == SystemConditionType.systemImportPower:
+            compare_value = self.value["grid_active_power"]
+            if compare_value > 0:
+                return False
+        elif data.childType == SystemConditionType.systemSoc:
+            compare_value = self.value["system_soc"]
+        if compare_value is None:
+            return False
+        return self.smart_scene_service.compare_the_magnitudes(
+            function_value,
+            compare_value=abs(compare_value),
+            base_value=child_data.data[0],
+        )
+