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

solax_py_library/smart_scene/core/action/system_action.py

@@ -0,0 +1,241 @@
+# from solax_py_library.smart_scene.core.action.base import BaseAction
+# from solax_py_library.smart_scene.types.action import SystemActionType
+# from solax_py_library.smart_scene.types.condition import SystemConditionItemData
+#
+#
+# class SystemAction(BaseAction):
+#     def __init__(self, smart_scene_service, app_log):
+#         super().__init__(smart_scene_service)
+#         self.log = app_log
+#         self.do_func = self.do_system_action
+#         self.cabinet_type = None
+#
+#     def do_system_action(self, scene_id, data: SystemConditionItemData):
+#         child_data = data.childData
+#         child_type = data.childType
+#         data = child_data.data
+#         if self.cabinet_type is None:
+#             self.cabinet_type = self.smart_scene_service.get_cabinet_type()
+#         if child_type == SystemActionType.systemSwitch:
+#             return self.system_switch(data[0], scene_id)
+#         elif child_type == SystemActionType.exportControl:
+#             return self.export_control(data, scene_id)
+#         elif child_type == SystemActionType.importControl:
+#             return self.import_control(data, scene_id)
+#         elif child_type == SystemActionType.workMode:
+#             return self.work_mode(data, scene_id)
+#         return False
+#
+#
+# class SystemSwitchAction(SystemAction):
+#     def system_switch(self, value, scene_id) -> bool:
+#         """系统开关机"""
+#         if value not in [0, 1]:
+#             value = 1
+#         if self.cabinet_type in ["TRENE"]:
+#             self.ems_tcp_service.set_trene_switch(value)
+#             return True
+#         else:
+#             master_sn = self.device_service.get_master_inv_by_device()
+#             # 如果为AELIO，则只需要操控主机
+#             if master_sn:
+#                 data = {"sn": master_sn, "switch": value}
+#                 self.log.info(f"执行: 系统开关机, data: {data}")
+#                 t = threading.Thread(
+#                     target=self.smart_scene_service.request_local_server,
+#                     args=("setSystemSwitch", data, scene_id),
+#                     daemon=True,
+#                 )
+#                 t.start()
+#         return True
+#
+#
+# class ExportControlAction(SystemAction):
+#     def export_control(self, value, scene_id) -> bool:
+#         """零输出控制"""
+#         if len(value) != 4:
+#             value.extend([1, 0, 1])
+#         data = {
+#             "isEnable": value[0],
+#             "controlMode": value[1],
+#             "exportValue": value[2],
+#             "unitType": value[3],
+#         }
+#         self.log.info(f"执行: 馈网控制, data: {data}")
+#         ret = self.smart_scene_service.request_local_server(
+#             "editOutputControl", data, scene_id
+#         )
+#         if not ret or ret["success"] is False:
+#             return False
+#         return True
+#
+#
+# class ImportControlAction(SystemAction):
+#     def import_control(self, value, scene_id) -> bool:
+#         """需量控制"""
+#         if self.cabinet_type in ["TRENE"]:
+#             if len(value) != 3:
+#                 value.extend([1, 0])
+#             data = {
+#                 "isAllowDischarge": value[1],
+#                 "demandLimitValue": value[2],
+#                 "isEnable": value[0],
+#             }
+#         else:
+#             if len(value) != 2:
+#                 value.append(0)
+#             data = {
+#                 "isAllowDischarge": 1,
+#                 "demandLimitValue": value[1],
+#                 "isEnable": value[0],
+#             }
+#         self.log.info(f"执行: 需量控制, data: {data}")
+#         ret = self.smart_scene_service.request_local_server(
+#             "editDemandControl", data, scene_id
+#         )
+#         if not ret or ret["success"] is False:
+#             return False
+#         return True
+#
+#
+# class WorkModeAction(SystemAction):
+#     def work_mode(self, value, scene_id) -> bool:
+#         # 0: self use; 1: 并网优先; 2: 备用模式; 3: 手动； 4： 削峰填谷 5： TOU（暂不用）; 16: VPP
+#         if value[0] not in [0, 1, 2, 3, 4, 16]:
+#             return False
+#         data = None
+#         if self.cabinet_type in ["AELIO"]:
+#             if value[0] in [0, 1, 2, 3, 4]:
+#                 data = {"useMode": value[0]}
+#         elif self.cabinet_type in ["TRENE"]:
+#             if value[0] in [0, 1, 3, 4]:
+#                 data = {"useMode": value[0]}
+#         else:
+#             return False
+#         if data is not None:  # 普通模式
+#             self.log.info(f"普通模式控制 data: {data}")
+#             # 手动模式
+#             if data["useMode"] == 3:
+#                 if value[1] == 5:
+#                     value.extend([0, 10])
+#                 self.smart_scene_service.set_manual_mode(
+#                     value[1], value[2], value[3], self.cabinet_type
+#                 )
+#             else:
+#                 self.smart_scene_service.request_local_server(
+#                     "setAelioUseMode", data, scene_id
+#                 )
+#         else:  # VPP模式
+#             if self.cabinet_type in ["AELIO"]:
+#                 if value[1] == 1:
+#                     reg_value_list = [1]
+#                     # 有功功率
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[2] * 1000, "int32", "little"
+#                         )
+#                     )
+#                     # 无功功率
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[3] * 1000, "int32", "little"
+#                         )
+#                     )
+#                     # 持续时间35秒, 控制超时 35s,控制类型为set
+#                     reg_value_list.extend([35, 35, 1])
+#                 elif value[1] == 2:
+#                     reg_value_list = [2, 1]
+#                     # 能量目标
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[2] * 1000, "uint32", "little"
+#                         )
+#                     )
+#                     # 功率目标
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[3] * 1000, "int32", "little"
+#                         )
+#                     )
+#                     # 控制超时 35s
+#                     reg_value_list.extend([35])
+#                 elif value[1] == 3:
+#                     # 控制类型为set，SOC：value[2]
+#                     reg_value_list = [3, 1, value[2]]
+#                     # 充放电功率目标
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[3] * 1000, "int32", "little"
+#                         )
+#                     )
+#                     # 控制超时 35s
+#                     reg_value_list.extend([35])
+#                 elif value[1] == 4:
+#                     reg_value_list = [4]
+#                     # 电池功率目标
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[2] * 1000, "int32", "little"
+#                         )
+#                     )
+#                     # 控制超时 35s, # 远程控制超时后需设备执行的模式 0xA0 关闭VPP，0xA1 默认的VPP模式
+#                     reg_value_list.extend([35, 0xA0])
+#                 elif value[1] == 5:
+#                     reg_value_list = [5]
+#                     # 控制超时 35s, # 远程控制超时后需设备执行的模式 0xA0 关闭VPP，0xA1 默认的VPP模式
+#                     reg_value_list.extend([35, 0xA0])
+#                 elif value[1] == 6:
+#                     reg_value_list = [6]
+#                     # 控制超时 35s, # 远程控制超时后需设备执行的模式 0xA0 关闭VPP，0xA1 默认的VPP模式
+#                     reg_value_list.extend([35, 0xA0])
+#                 elif value[1] == 7:
+#                     reg_value_list = [7]
+#                     # 控制超时 35s, # 远程控制超时后需设备执行的模式 0xA0 关闭VPP，0xA1 默认的VPP模式
+#                     reg_value_list.extend([35, 0xA0])
+#                 elif value[1] == 8:
+#                     # 控制类型为set，
+#                     reg_value_list = [8, 1]
+#                     # PV功率限制
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[2] * 1000, "uint32", "little"
+#                         )
+#                     )
+#                     # 电池功率限制
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[3] * 1000, "int32", "little"
+#                         )
+#                     )
+#                     # 控制超时 35s, # 远程控制超时后需设备执行的模式 0xA0 关闭VPP，0xA1 默认的VPP模式
+#                     reg_value_list.extend([35, 0xA0])
+#                 elif value[1] == 9:
+#                     # 控制类型为set，
+#                     reg_value_list = [9, 1]
+#                     # PV功率限制
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[2] * 1000, "uint32", "little"
+#                         )
+#                     )
+#                     # 电池功率限制
+#                     reg_value_list.extend(
+#                         self.smart_scene_service.struct_transform(
+#                             value[3] * 1000, "int32", "little"
+#                         )
+#                     )
+#                     # 控制超时 35s, # 远程控制超时后需设备执行的模式 0xA0 关闭VPP，0xA1 默认的VPP模式
+#                     reg_value_list.extend([value[4], 35, 0xA0])
+#                 else:
+#                     reg_value_list = []
+#                 func_name = PCSOperateFunctionName.SET_AELIO_VPP_MODE
+#                 channel = options.REDIS_WRITE_SERIAL_DEVICE
+#                 future_data = {}
+#                 future_data["func_name"] = func_name
+#                 future_data["operationMode"] = Enumeration.SINGLE_DEVICE_MODE
+#                 future_data["data"] = {"value_list": reg_value_list}
+#                 app_log.info(f"VPP模式控制 data: {future_data}")
+#                 self.smart_scene_service.request_local_redis(
+#                     channel, json.dumps(future_data)
+#                 )
+#         return True

solax_py_library/smart_scene/core/condition/base.py

@@ -1,12 +1,13 @@
 class BaseCondition(object):
-    def __init__(self):
-        # 子条件类型
-        self.child_type_list = []
-        # 各子条件的值
+    def __init__(self, update_value_function, **kwargs):
         self.value = {}
-        # 判断是否满足条件的子条件-判断函数的映射
-        self.meet_func_dict = {}
+        if callable(update_value_function):
+            raise ValueError("update_value_function must be callable")
+        self.update_value_function = update_value_function
 
     def update_value(self):
-        """更新条件值"""
+        self.update_value_function()
+        print(self.value)
+
+    def meet_func(self, data, ctx):
         ...

solax_py_library/smart_scene/core/condition/cabinet_condition.py

@@ -1,11 +1,16 @@
+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
+from solax_py_library.device.types.alarm import AlarmLevel
+
 
 class CabinetCondition(BaseCondition):
-    def __init__(self, smart_scene_service):
-        super().__init__(smart_scene_service)
-        self.type = IF_ELE_TYPE
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
         self.value = defaultdict(
             lambda: {
-                "soc": None,
+                "soc": 0,
                 "alarm_level": {
                     AlarmLevel.EMERGENCY: False,
                     AlarmLevel.NORMAL: False,
@@ -13,78 +18,8 @@ class CabinetCondition(BaseCondition):
                 },
             }
         )
-        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):
+    def meet_func(self, data: CabinetConditionItemData, ctx):
         if not self.value:
             return False
         cabinet = ctx["cabinet"] or []
@@ -92,8 +27,7 @@ class CabinetCondition(BaseCondition):
             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,
+                if data.childData.function.function()(
                     compare_value=self.value[cabinet_sn]["soc"],
                     base_value=data.childData.data[0],
                 ):

solax_py_library/smart_scene/core/condition/date_condition.py

@@ -1,15 +1,17 @@
 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
+from solax_py_library.smart_scene.types.condition import (
+    DateConditionItemData,
+    DateConditionType,
+)
 
 
 class DateCondition(BaseCondition):
-    def __init__(self):
-        super().__init__()
-        self.value = {}
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
 
-    def update_value(self):
+    def _update_value(self):
         """获取time 类型需要的数据"""
         now = datetime.now()
         self.hour = now.hour
@@ -17,10 +19,8 @@ class DateCondition(BaseCondition):
 
     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:
+            hour, minute = date.split(":")
+            if int(hour) == self.hour and int(minute) == self.minute:
                 return True
         return False

solax_py_library/smart_scene/core/condition/price_condition.py

@@ -1,34 +1,31 @@
 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
+from solax_py_library.smart_scene.types.condition import (
+    PriceConditionItemData,
+    PriceConditionType,
+    SmartSceneUnit,
+    ConditionFunc,
+)
+from solax_py_library.utils.time_util import (
+    trans_str_time_to_index,
+    get_highest_or_lowest_value,
+)
 
 
 class ElePriceCondition(BaseCondition):
-    def __init__(self):
-        super().__init__()
-        self.buy = True
-        self.value = {}
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+        self.buy = None
         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:
+    def meet_func_price(self, function_value: ConditionFunc, 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]
-        )
+        return function_value.function()(self.value[index], data_value[0])
 
     def meet_func_highest_price(self, data_value, index) -> bool:
         value, unit = data_value
@@ -56,16 +53,13 @@ class ElePriceCondition(BaseCondition):
         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
+    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, reverse=reverse
         )
-        if not sort_index:
-            return False
-        if index - start_index in sort_index:
+        if sort_index and index - start_index in sort_index:
             return True
-        else:
-            return False
+        return False
 
     def meet_func(self, data: PriceConditionItemData, ctx):
         if not self.value:
@@ -75,7 +69,7 @@ class ElePriceCondition(BaseCondition):
         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)
+        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:
@@ -84,22 +78,22 @@ class ElePriceCondition(BaseCondition):
             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"
+                data_value, index, reverse=True
             )
         elif child_type == PriceConditionType.cheapestHours:
             return self.meet_func_highest_or_lowest_hours(
-                data_value, index, "cheapest_hours"
+                data_value, index, reverse=False
             )
         return False
 
 
 class EleSellPriceCondition(ElePriceCondition):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
         self.buy = False
 
 
 class ElsBuyPriceCondition(ElePriceCondition):
-    def __init__(self):
-        super().__init__()
+    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

@@ -1,18 +1,15 @@
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import (
+    SystemConditionItemData,
+    SystemConditionType,
+)
 
 
 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 __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
+        self.grid_active_power = None
+        self.system_soc = None
 
     def meet_system_condition(self, data: SystemConditionItemData, ctx):
         if not self.value:
@@ -20,22 +17,18 @@ class SystemCondition(BaseCondition):
         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"]
+            compare_value = self.grid_active_power
             if compare_value < 0:
                 return False
         elif data.childType == SystemConditionType.systemImportPower:
-            compare_value = self.value["grid_active_power"]
+            compare_value = self.grid_active_power
             if compare_value > 0:
                 return False
         elif data.childType == SystemConditionType.systemSoc:
-            compare_value = self.value["system_soc"]
+            compare_value = self.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],
+        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

@@ -1,18 +1,14 @@
+from solax_py_library.smart_scene.core.condition.base import BaseCondition
+from solax_py_library.smart_scene.types.condition import (
+    WeatherConditionItemData,
+    WeatherConditionType,
+)
+from solax_py_library.utils.time_util import get_rounded_times
 
-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()
+class WeatherCondition(BaseCondition):
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
 
     def meet_weather_condition(self, data: WeatherConditionItemData, ctx):
         if not self.value:
@@ -21,21 +17,16 @@ class WeatherCondition(BaseCondition):
         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()
+        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)
-        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,
+            return function_value.function()(
                 self.value[child_type]["valueList"][index],
                 data_value[0],
             )
@@ -62,6 +53,6 @@ class WeatherCondition(BaseCondition):
         if not meet_flag:
             return False
         # 2. 再判断当前太阳辐照度
-        return self.smart_scene_service.compare_the_magnitudes(
-            function_value, self.value["irradiance"]["valueList"][index], irradiance
+        return function_value.function()(
+            self.value["irradiance"]["valueList"][index], irradiance
         )