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

solax_py_library/smart_scene/core/condition/base.py

@@ -1,9 +1,13 @@
 class BaseCondition(object):
-    def __init__(self, **kwargs):
+    def __init__(self, update_value_function, **kwargs):
         self.value = {}
+        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,16 +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
+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, **kwargs):
-        super().__init__()
+    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,
@@ -18,11 +18,21 @@ class CabinetCondition(BaseCondition):
                 },
             }
         )
-        self.redis_service = kwargs.get("redis_service")
-        self.db_service = kwargs.get("db_service")
-
-    def update_value(self):
-        ...
 
     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

@@ -8,13 +8,10 @@ from solax_py_library.smart_scene.types.condition import (
 
 
 class DateCondition(BaseCondition):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        now = datetime.now()
-        self.hour = now.hour
-        self.minute = now.minute
+    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

solax_py_library/smart_scene/core/condition/price_condition.py

@@ -7,7 +7,6 @@ from solax_py_library.smart_scene.types.condition import (
     SmartSceneUnit,
     ConditionFunc,
 )
-from solax_py_library.utils.cloud_client import CloudClient
 from solax_py_library.utils.time_util import (
     trans_str_time_to_index,
     get_highest_or_lowest_value,
@@ -15,23 +14,10 @@ from solax_py_library.utils.time_util import (
 
 
 class ElePriceCondition(BaseCondition):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self, update_value_function, **kwargs):
+        super().__init__(update_value_function, **kwargs)
         self.buy = None
         self.unit = None
-        self.cloud_url = kwargs.pop("cloud_url")
-        self.sn = kwargs.pop("ems_sn")
-        self.secret = kwargs.pop("secret")
-        self.client = CloudClient(base_url=self.cloud_url)
-
-    def update_value(self):
-        """获取电价 类型需要的数据"""
-        ele_info = self.client.get_electrovalence_data_from_cloud()
-        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: ConditionFunc, data_value, index) -> bool:
         """电价条件的判定"""
@@ -102,12 +88,12 @@ class ElePriceCondition(BaseCondition):
 
 
 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

@@ -6,14 +6,10 @@ from solax_py_library.smart_scene.types.condition import (
 
 
 class SystemCondition(BaseCondition):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.redis_service = kwargs.pop("redis_service")
-
-    def update_value(self):
-        overview_statistic_data = self.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:
@@ -22,15 +18,15 @@ class SystemCondition(BaseCondition):
         function_value = child_data.function
         compare_value = None
         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 function_value.function()(

solax_py_library/smart_scene/core/condition/weather_condition.py

@@ -3,20 +3,12 @@ from solax_py_library.smart_scene.types.condition import (
     WeatherConditionItemData,
     WeatherConditionType,
 )
-from solax_py_library.utils.cloud_client import CloudClient
 from solax_py_library.utils.time_util import get_rounded_times
 
 
 class WeatherCondition(BaseCondition):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.cloud_url = kwargs.pop("cloud_url")
-        self.sn = kwargs.pop("ems_sn")
-        self.secret = kwargs.pop("secret")
-        self.client = CloudClient(base_url=self.cloud_url)
-
-    def update_value(self):
-        self.value = self.client.get_weather_data_from_redis()
+    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:
@@ -32,7 +24,7 @@ class WeatherCondition(BaseCondition):
             time_now = nearest_time
         index = self.value["timeList"].index(time_now)
         if child_type == WeatherConditionType.irradiance:
-            return function_value.function()(function_value, data_value, index)
+            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],

solax_py_library/smart_scene/core/service/smart_scene_service.py

@@ -0,0 +1,411 @@
+import json
+import os.path
+import struct
+import traceback
+import threading
+import subprocess as sp
+
+import requests
+from datetime import datetime, timedelta
+
+from tornado.log import app_log
+
+from domain.ems_enum.smart_scene.condition import ConditionFunc
+from settings.const import (
+    RedisKey,
+    Role,
+    DeviceInfo,
+    PCSOperateFunctionName,
+    Enumeration,
+    FilePath,
+)
+from web.web_ext import config_json
+from models.tables import Device
+from utils.common import options, get_logger_sn, md5_encrypt, read_write_json_file
+from services.redis_service import RedisService
+from models.sqlite_db import session_maker
+from utils.redis_utils import RedisProducer
+from services.strategy_control_service import StrategyControlService
+from solax_py_library.utils.cloud_client import CloudClient
+
+redis_host = options.REDIS_HOST
+redis_port = options.REDIS_PORT
+db = options.REDIS_DB
+LOCAL_URL = "http://127.0.0.1:8000/ems/cloud/"
+
+
+class SmartSceneService(object):
+    def __init__(self):
+        self.ems_sn = get_logger_sn()
+        self.redis_service = RedisService()
+        self.redis_producer = RedisProducer().producer
+        self.strategy_control_service = StrategyControlService()
+
+    def request_local_redis(self, redis_topic, payload):
+        """本地redis分发任务"""
+        try:
+            self.redis_producer.publish(redis_topic, payload)
+        except Exception:
+            app_log.info(traceback.format_exc())
+
+    def request_local_server(self, apiName, apiPostData, scene_id=None):
+        """
+        访问本地接口, 调用server8000
+        需要使用admin权限
+        :param apiName: 接口名称
+        :param apiPostData: 请求参数
+        :param scene_id: 请求标识
+        :return:
+        """
+        username = Role.SUPER_ADMIN
+        user_info = {"username": username, "password": md5_encrypt(self.ems_sn)}
+        token = self.redis_service.make_token(username, user_info)
+        url = LOCAL_URL + apiName
+        headers = {"token": token}
+        try:
+            response = requests.post(url, json=apiPostData, headers=headers, timeout=5)
+            app_log.info(
+                f"scene_id: {scene_id}, request apiName: {apiName}, response: {response.text}"
+            )
+            return json.loads(response.text)
+        except Exception:
+            app_log.info(traceback.format_exc())
+            return False
+
+    def get_token(self):
+        token = self.redis_service.get_token()
+        if not token:
+            client = CloudClient(base_url=config_json.get("CLOUD_URL", ""))
+            token = client.get_token(
+                ems_sn=self.ems_sn, sn_secret=config_json.get("MQTT_PASSWORD")
+            )
+            if not token:
+                app_log.info("访问token接口失败")
+                return False
+            self.redis_service.set_token(token)
+            return token
+        else:
+            return token
+
+    def get_weather_data_from_redis(self):
+        try:
+            weather_info = self.redis_service.get_ele_price_info() or {}
+            return weather_info
+        except Exception:
+            app_log.error(traceback.format_exc())
+            return {}
+
+    def get_weather_data_from_cloud(self):
+        """获取未来24小时天气数据"""
+        try:
+            token = self.get_token()
+            client = CloudClient(base_url=config_json.get("CLOUD_URL", ""))
+            weather_info = client.get_weather_data_from_cloud(
+                ems_sn=self.ems_sn,
+                token=token,
+            )
+            if not weather_info:
+                app_log.error(f"获取天气数据失败 异常 {traceback.format_exc()}")
+                return False
+            app_log.info(f"获取天气数据成功: {weather_info}")
+            self.redis_service.set_weather_info(weather_info)
+        except Exception:
+            app_log.error(f"获取天气数据失败 异常 {traceback.format_exc()}")
+            return False
+
+    def trans_str_time_to_index(self, now_time, minute=15):
+        """将时间按照minute切换为索引，时间格式为 %H-%M"""
+        time_list = [int(i) for i in now_time.split(":")]
+        time_int = time_list[0] * 4 + time_list[1] // minute
+        return time_int
+
+    def get_electrovalence_data_from_cloud(self):
+        try:
+            token = self.get_token()
+            client = CloudClient(base_url=config_json.get("CLOUD_URL", ""))
+            ele_price_info = client.get_electrovalence_data_from_cloud(
+                ems_sn=self.ems_sn, token=token
+            )
+            app_log.info(f"获取电价数据成功: {ele_price_info}")
+            self.redis_service.set_ele_price_info(ele_price_info)
+        except Exception:
+            app_log.error(f"获取电价数据失败 异常 {traceback.format_exc()}")
+            return False
+
+    def get_electrovalence_data_from_redis(self):
+        """从自定义电价的缓存中获取"""
+        month_temp = self.redis_service.hget(
+            RedisKey.MONTH_TEMPLATE, RedisKey.MONTH_TEMPLATE
+        )
+        month_temp = json.loads(month_temp) if month_temp else {}
+        if month_temp == {}:
+            return {}
+        month = datetime.strftime(datetime.now(), "%m")
+        month_map = {
+            "01": "Jan",
+            "02": "Feb",
+            "03": "Mar",
+            "04": "Apr",
+            "05": "May",
+            "06": "Jun",
+            "07": "Jul",
+            "08": "Aug",
+            "09": "Sep",
+            "10": "Oct",
+            "11": "Nov",
+            "12": "Dec",
+        }
+        month = month_map.get(month, None)
+        if month is None:
+            return {}
+        template_id = str(month_temp.get(month, 0))
+        price_info = self.redis_service.hget(
+            RedisKey.ELECTRICITY_PRICE_TEMPLATE, template_id
+        )
+        price_info = json.loads(price_info) if price_info else {}
+        if price_info == {}:
+            return {}
+
+        stationInfo = self.redis_service.get(RedisKey.STATION_INFO)
+        stationInfo = json.loads(stationInfo) if stationInfo else {}
+        currencyCode = stationInfo.get("currencyCode")
+        currency_file = read_write_json_file(FilePath.CURRENCY_PATH)
+        ele_unit = False
+        try:
+            for j in currency_file["list"]:
+                if currencyCode == j["code"]:
+                    ele_unit = j["unit"].split(":")[-1] + "/kWh"
+                    break
+        except:
+            app_log.error(f"获取本地电价单位出错 {traceback.format_exc()}")
+        ele_price_info = {
+            "buy": [None] * 192,
+            "sell": [None] * 192,
+            "date": datetime.strftime(datetime.now(), "%Y-%m-%d"),
+            "ele_unit": ele_unit if ele_unit else "/kWh",
+        }
+        for period in price_info["periodConfiguration"]:
+            start_index = self.trans_str_time_to_index(period["startTime"])
+            end_index = self.trans_str_time_to_index(period["endTime"])
+            slotName = period["slotName"]
+            for price in price_info["priceAllocation"]:
+                if price["slotName"] == slotName:
+                    ele_price_info["buy"][start_index:end_index] = [
+                        price["buyPrice"]
+                    ] * (end_index - start_index)
+                    ele_price_info["sell"][start_index:end_index] = [
+                        price["salePrice"]
+                    ] * (end_index - start_index)
+                    break
+        return ele_price_info
+
+    def get_electrovalence_data(self):
+        try:
+            online_status = self.redis_service.hget(RedisKey.LED_STATUS_KEY, "blue")
+            online_status = (
+                json.loads(online_status).get("status") if online_status else 0
+            )
+            if online_status:
+                ele_price_info = self.redis_service.get_ele_price_info() or {}
+                today = datetime.strftime(datetime.now(), "%Y-%m-%d")
+                date_now = ele_price_info.get("date", "")
+                if today not in date_now:
+                    ele_price_info = {}
+            else:
+                app_log.info("设备离线，获取本地电价")
+                ele_price_info = self.get_electrovalence_data_from_redis()
+            return ele_price_info
+        except Exception:
+            app_log.error(traceback.format_exc())
+            return {}
+
+    def get_highest_or_lowest_price(
+        self, start_time, end_time, hours, price_list, func="expensive_hours"
+    ):
+        """获取一段时间内，电价最高或最低的几个小时"""
+        start_index = self.trans_str_time_to_index(start_time)
+        end_index = self.trans_str_time_to_index(end_time)
+        arr = price_list[start_index:end_index]
+        if None in arr:
+            return False
+        indices = list(range(end_index - start_index))
+        if func == "expensive_hours":
+            reverse = True
+        else:
+            reverse = False
+        sorted_indices = sorted(indices, key=lambda i: arr[i], reverse=reverse)
+        return sorted_indices[: int(hours * 4)], start_index
+
+    def get_rounded_times(self):
+        """
+        返回距离当前时间最近的15min的整点时间以及后一整点5min时间（天气是预测未来15min的，也就是在00:00时，只能拿到00:15的数据）
+        """
+        now = datetime.now()
+        # 确定当前时间所属的15分钟区间
+        index_1 = now.minute // 15
+        index_2 = now.minute % 15
+        left_time = now.replace(minute=15 * index_1, second=0, microsecond=0)
+        right_time = left_time + timedelta(minutes=15)
+        if index_2 < 8:
+            nearest_time = left_time
+        else:
+            nearest_time = right_time
+        return datetime.strftime(nearest_time, "%Y-%m-%d %H:%M:%S"), datetime.strftime(
+            right_time, "%Y-%m-%d %H:%M:%S"
+        )
+
+    def compare_the_magnitudes(self, function, compare_value, base_value):
+        """比较两个值"""
+        if function == ConditionFunc.GT:
+            return compare_value > base_value
+        elif function == ConditionFunc.EQ:
+            return compare_value == base_value
+        elif function == ConditionFunc.LT:
+            return compare_value < base_value
+        return False
+
+    def get_cabinet_type(self):
+        # 获取机柜类型
+        cabinet_type = 1
+        with session_maker(change=False) as session:
+            result = (
+                session.query(Device.deviceModel)
+                .filter(Device.deviceType == DeviceInfo.ESS_TYPE, Device.isDelete == 0)
+                .first()
+            )
+
+            if result:
+                cabinet_type = result[0]
+        if cabinet_type in [3, 4, 7, 8]:
+            key_name = "AELIO"
+        else:
+            key_name = "TRENE"
+        return key_name
+
+    def set_manual_mode(self, work_mode, power, soc, cabinet_type):
+        """设置手动模式"""
+        # 充电
+        if work_mode == 3:
+            strategy_info = {
+                "chargePower": power,
+                "chargeTargetSoc": soc,
+                "runState": 1,
+            }
+            self.redis_service.hset(
+                RedisKey.MANUAL_STRATEGY_INFO,
+                RedisKey.CHARGE_MODE,
+                json.dumps(strategy_info),
+            )
+            self.strategy_control_service.apply_or_stop_strategy(
+                0, RedisKey.MANUAL_STRATEGY_INFO, RedisKey.DISCHARGE_MODE
+            )
+            # 将运行模式修改为手动
+            self.redis_service.set(RedisKey.RUN_STRATEGY_TYPE, 1)
+        elif work_mode == 4:
+            strategy_info = {
+                "dischargePower": power,
+                "dischargeTargetSoc": soc,
+                "runState": 1,
+            }
+            self.redis_service.hset(
+                RedisKey.MANUAL_STRATEGY_INFO,
+                RedisKey.DISCHARGE_MODE,
+                json.dumps(strategy_info),
+            )
+            # 将充电状态修改
+            self.strategy_control_service.apply_or_stop_strategy(
+                0, RedisKey.MANUAL_STRATEGY_INFO, RedisKey.CHARGE_MODE
+            )
+            # 将运行模式修改为手动
+            self.redis_service.set(RedisKey.RUN_STRATEGY_TYPE, 1)
+        # 停止
+        else:
+            self.strategy_control_service.apply_or_stop_strategy(
+                0, RedisKey.MANUAL_STRATEGY_INFO, RedisKey.DISCHARGE_MODE
+            )
+            self.strategy_control_service.apply_or_stop_strategy(
+                0, RedisKey.MANUAL_STRATEGY_INFO, RedisKey.CHARGE_MODE
+            )
+            self.redis_service.set(RedisKey.RUN_STRATEGY_TYPE, 1)
+        if work_mode == 3:
+            manualType = 1
+        elif work_mode == 4:
+            manualType = 2
+        else:
+            manualType = 3
+        data = {
+            "power": power,
+            "soc": soc,
+            "workMode": work_mode,
+            "manualType": manualType,
+            "useMode": 3,
+        }
+        if cabinet_type in ["TRENE"]:
+            t = threading.Thread(
+                target=self.request_local_redis, args=(options.REDIS_POWER_CONTROL, "")
+            )
+        else:
+            func_name = PCSOperateFunctionName.SET_AELIO_USE_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"] = data
+            t = threading.Thread(
+                target=self.request_local_redis,
+                args=(channel, json.dumps(future_data)),
+                daemon=True,
+            )
+        t.start()
+        return True
+
+    def struct_transform(self, value, fmt, order="big"):
+        """将10进制的原始值转换为modbus协议需要的精度与类型的值"""
+        value = int(value)
+        if order == "little":
+            opt = "<"
+        else:
+            opt = ">"
+        try:
+            if fmt == "int16":
+                ret = struct.pack(f"{opt}h", value)
+                ret_list = struct.unpack(f"{opt}H", ret)
+            elif fmt == "uint16":
+                ret = struct.pack(f"{opt}H", value)
+                ret_list = struct.unpack(f"{opt}H", ret)
+            elif fmt == "int32":
+                ret = struct.pack(f"{opt}i", value)
+                ret_list = struct.unpack(f"{opt}HH", ret)
+            elif fmt == "uint32":
+                ret = struct.pack(f"{opt}I", value)
+                ret_list = struct.unpack(f"{opt}HH", ret)
+            elif fmt == "int64":
+                ret = struct.pack(f"{opt}q", value)
+                ret_list = struct.unpack(f"{opt}HHHH", ret)
+            elif fmt == "uint64":
+                ret = struct.pack(f"{opt}Q", value)
+                ret_list = struct.unpack(f"{opt}HHHH", ret)
+            else:
+                ret_list = [0]
+        except Exception:
+            if "16" in fmt:
+                ret_list = [0]
+            elif "32" in fmt:
+                ret_list = [0, 0]
+            else:
+                ret_list = [0, 0, 0, 0]
+        return list(ret_list)
+
+    def ems_do_control(self, data):
+        for do_info in data:
+            do_number = do_info.DoNumber
+            do_value = do_info.DoValue
+            if 1 <= do_number <= 8 and do_value in [0, 1]:
+                path = DeviceInfo.DI_DO_GPIO_MAPPING[f"DO{do_number}"] + "/value"
+                if not os.path.exists(path):
+                    app_log.info(f"DO path not exists {do_info}")
+                else:
+                    cmd = f"echo {do_value} > {path}"
+                    ret = sp.getstatusoutput(cmd)
+                    ret = True if ret[0] == 0 else False
+                    app_log.info(f"DO {do_info} 控制结果: {ret}")

{solax_py_library-1.0.0.2503.dist-info → solax_py_library-1.0.0.2504.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: solax-py-library
-Version: 1.0.0.2503
+Version: 1.0.0.2504
 Summary: some common tool
 Author: shenlvyu
 Author-email: 13296718439@163.com

{solax_py_library-1.0.0.2503.dist-info → solax_py_library-1.0.0.2504.dist-info}/RECORD

@@ -20,12 +20,14 @@ solax_py_library/smart_scene/core/action/base.py,sha256=vSC3rL9qfPy41Nlds_0QcTLM
 solax_py_library/smart_scene/core/action/ems_action.py,sha256=tasL7pUJbnmrEEokAa9Mug5eUFvHuFKGYZKNvNMdrBs,610
 solax_py_library/smart_scene/core/action/system_action.py,sha256=mVLTg9pZ7tDayLbr3I92a33snA2AGT3meUdm_XYDQEc,10839
 solax_py_library/smart_scene/core/condition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solax_py_library/smart_scene/core/condition/base.py,sha256=dQK5gRguOo7GmQkRSnae2kTv4wvZh7zJeyQCdX09OmE,177
-solax_py_library/smart_scene/core/condition/cabinet_condition.py,sha256=vbo5wHf_p1qoTgItcyh-DcxE4GOe-2mUK5tYCg5pRCM,879
-solax_py_library/smart_scene/core/condition/date_condition.py,sha256=NXDN2A7t6h8r_F9GNUD8YPAJLFedFDXlrQhs5vvyNyo,899
-solax_py_library/smart_scene/core/condition/price_condition.py,sha256=4k4oDKSiSFdAM5reRVdfBW25XNw0o1QKYm0PUB_Mnxw,4174
-solax_py_library/smart_scene/core/condition/system_condition.py,sha256=100lBBf_yhdPbzK000U1OSfanKtA2xH4PoM6RRc42x0,1522
-solax_py_library/smart_scene/core/condition/weather_condition.py,sha256=kQ-0pM07G9-mOqOGp6BNbEdP3HuZyOdBqTQD0cAl8Ck,2469
+solax_py_library/smart_scene/core/condition/base.py,sha256=T3R18uYh-XLXOXdtn_WwHS4nBoakJomHWLLAjs-0K1I,425
+solax_py_library/smart_scene/core/condition/cabinet_condition.py,sha256=HbiIrOHzlGowEww8JD8ioScmayhtMNiVS8YzOHwoElw,1505
+solax_py_library/smart_scene/core/condition/date_condition.py,sha256=8dbYhftUzGKQJkDqIkV_hjf4PIhKJrUCo9fv-_93sl8,855
+solax_py_library/smart_scene/core/condition/price_condition.py,sha256=kAIkg5VxTOd5gTRHzqU23ZgFYSkcvF_haqzVKA-uDZc,3768
+solax_py_library/smart_scene/core/condition/system_condition.py,sha256=Pstq_y6fdwh7a39q8JZuabymFeJx5AH5Xjj4MZz4or0,1309
+solax_py_library/smart_scene/core/condition/weather_condition.py,sha256=jn8gbQ2ITvwNIlimib7zv-j5BvslFfJebJoftCGECeE,2173
+solax_py_library/smart_scene/core/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+solax_py_library/smart_scene/core/service/smart_scene_service.py,sha256=wbC4Y0NK7vQRgJXrHCptjlb7r_C5PHLEHyGU1oaFNjw,15704
 solax_py_library/smart_scene/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 solax_py_library/smart_scene/exceptions/price.py,sha256=ztsM8leCsxbzx1TYS5GQAVbfvxlU49QymS1NUykqM_g,142
 solax_py_library/smart_scene/exceptions/smart_scene.py,sha256=VFjRe7fUg5JA13Wg8BFvxzlF-pBSNaGJJBpnphYdSbM,1774
@@ -71,6 +73,6 @@ solax_py_library/utils/cloud_client.py,sha256=5dZrc5fzrNFSXqTPZd7oHt-Y9Jj6RCigB7
 solax_py_library/utils/common.py,sha256=bfnZcX9uM-PjJrYAFv1UMmZgt6bGR7MaOd7jRPNHGxw,1238
 solax_py_library/utils/struct_util.py,sha256=4SKx5IyAke88PGHPHDK3OEDtyGHdapGoQ1BnGR0F2ts,913
 solax_py_library/utils/time_util.py,sha256=bY5kj9dmyOuLEQ6uYGQK7jU7y1RMiHZgevEKnkcQcSU,1461
-solax_py_library-1.0.0.2503.dist-info/METADATA,sha256=vk7Hfoh4mLBm6qpGLhpsqNgPN01FRrex8Cu24KqzNYg,1827
-solax_py_library-1.0.0.2503.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-solax_py_library-1.0.0.2503.dist-info/RECORD,,
+solax_py_library-1.0.0.2504.dist-info/METADATA,sha256=4Z1yv8A7yWqkA0cCMP7UQG88cvcAMx33shtI-Huk5CU,1827
+solax_py_library-1.0.0.2504.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+solax_py_library-1.0.0.2504.dist-info/RECORD,,