solax-py-library 1.0.0.2507__py3-none-any.whl → 1.0.0.2509__py3-none-any.whl

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

@@ -1,4 +1,6 @@
 class BaseCondition(object):
+    condition_type = None
+
     def __init__(self, update_value_function, **kwargs):
         self.value = {}
         if not callable(update_value_function):

solax_py_library/smart_scene/core/condition/cabinet_condition.py

@@ -4,11 +4,14 @@ 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(

solax_py_library/smart_scene/core/condition/date_condition.py

@@ -4,10 +4,13 @@ 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)
 

solax_py_library/smart_scene/core/condition/price_condition.py

@@ -6,6 +6,7 @@ from solax_py_library.smart_scene.types.condition import (
     PriceConditionType,
     SmartSceneUnit,
     ConditionFunc,
+    ConditionType,
 )
 from solax_py_library.utils.time_util import (
     trans_str_time_to_index,
@@ -88,12 +89,16 @@ class ElePriceCondition(BaseCondition):
 
 
 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

@@ -2,10 +2,13 @@ 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)
         self.grid_active_power = None

solax_py_library/smart_scene/core/condition/weather_condition.py

@@ -2,11 +2,14 @@ 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)
 

solax_py_library/smart_scene/core/service/__init__.py

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

solax_py_library/smart_scene/core/service/run.py

@@ -0,0 +1,145 @@
+import json
+import traceback
+from datetime import datetime
+from typing import List, Set
+
+from solax_py_library.smart_scene.types.action import (
+    SmartSceneAction,
+)
+from solax_py_library.smart_scene.types.condition import (
+    ConditionType,
+    RepeatFunc,
+    LogicFunc,
+    SmartSceneCondition,
+    DateConditionType,
+    ConditionItem,
+)
+from solax_py_library.smart_scene.types.smart_scene_content import (
+    SmartSceneContent,
+    SmartSceneOtherInfo,
+)
+from tornado.log import app_log
+
+
+class SmartSceneRunner:
+    def __init__(self, condition_class_map, action_class_map):
+        self.condition_class_map = condition_class_map
+        self.action_class_map = action_class_map
+
+    @staticmethod
+    def _handle_repeat_info(scene_content: SmartSceneContent, once_flag):
+        # once_flag: 是否执行过
+        if scene_content.repeatFunction == RepeatFunc.ONCE:
+            return False if once_flag else True
+        week_list = scene_content.get_weekday_index()
+        if datetime.now().weekday() + 1 in week_list:
+            return True
+        return False
+
+    def smart_scene_handle(self, scene_instance):
+        other_info = SmartSceneOtherInfo.parse_raw(scene_instance.other)
+        try:
+            scene_data = SmartSceneContent.parse_raw(scene_instance.content)
+
+            # repeat，是否执行
+            if not self._handle_repeat_info(scene_data, other_info.once_flag):
+                app_log.info(
+                    f"场景名称: {scene_data.name}, 场景ID: {scene_instance.scene_id} 不符合重复条件，不执行"
+                )
+                return
+            scene_id = scene_instance.scene_id
+            app_log.info(
+                f"场景名称: {scene_data.name}, 场景ID: {scene_id}, 判断类型: {scene_data.conditions.operation}:"
+            )
+
+            # 条件判断
+            result = self._handle_conditions(
+                scene_data.conditions.operation,
+                scene_data.conditions,
+                other_info,
+            )
+
+            # 动作执行
+            new_exec_number = scene_instance.exec_number
+            if result:
+                self._handle_action(scene_id, scene_data.thenActions, log_prefix="THEN")
+                new_exec_number = 1
+                other_info.once_flag = True
+            elif scene_instance.exec_number == 1 and scene_data.elseThenActions:
+                self._handle_action(
+                    scene_id, scene_data.elseThenActions, log_prefix="ELSE THEN"
+                )
+                new_exec_number = 0
+                other_info.duration_times = 0
+
+            app_log.info(f"{scene_id} 执行完毕\n")
+            scene_instance.exec_number = new_exec_number
+            scene_instance.other = json.dumps(other_info.dict())
+            return scene_instance
+        except Exception:
+            app_log.error(
+                f"{scene_instance.scene_id} 执行智能场景异常 {traceback.format_exc()}"
+            )
+
+    def _handle_action(
+        self, scene_id, actions: List[SmartSceneAction], log_prefix="THEN"
+    ):
+        if not actions:
+            return
+        for action_info in actions:
+            action_class = self.action_class_map[action_info.type]
+            for child_info in action_info.data:
+                ret = action_class.do_func(scene_id=scene_id, data=child_info)
+                app_log.info(f"{log_prefix}条件 {child_info} 执行结果: {ret}")
+
+    def _handle_conditions(
+        self,
+        operation: LogicFunc,
+        conditions: SmartSceneCondition,
+        other_info: SmartSceneOtherInfo,
+    ):
+        need_duration_times = conditions.get_duration_info()
+        if not self._check_conditions(operation, conditions):
+            other_info.duration_times = 0
+            return False
+        if other_info.duration_times < need_duration_times:
+            other_info.duration_times += 1
+        app_log.info(
+            f"need times: {need_duration_times}, current times: {other_info.duration_times}"
+        )
+        return other_info.duration_times >= need_duration_times
+
+    def _check_conditions(self, operation, conditions):
+        ret_list = []
+        for cond in conditions.value:
+            parent_type = cond.type  # 父条件类型 (日期、天气、电价)
+            condition_class = self.condition_class_map[parent_type]
+            ctx = self._build_condition_ctx(cond)
+            for child_info in cond.data:
+                if child_info.childType == DateConditionType.duration:
+                    continue
+                ret = condition_class.meet_func(data=child_info, ctx=ctx)
+                app_log.info(f"IF条件 {child_info} 判断结果: {ret}")
+                ret_list.append(ret)
+                # 如果该条件判断不满足，并且客户设置为and,则无需继续判断，返回失败
+                if not ret and operation == LogicFunc.AND:
+                    return False
+                # 如果条件判断满足，并且客户设置为or,则无需继续判断，返回成功
+                if ret and operation == LogicFunc.OR:
+                    return True
+        if (operation == LogicFunc.AND and all(ret_list)) or (
+            operation == LogicFunc.OR and any(ret_list)
+        ):
+            return True
+        return False
+
+    @staticmethod
+    def _build_condition_ctx(condition_info: ConditionItem):
+        ctx = {}
+        if condition_info.type == ConditionType.cabinet:
+            ctx["cabinet"] = condition_info.cabinet
+        return ctx
+
+    def update_all_condition_data(self, condition_types: Set[ConditionType]):
+        for cond_type in condition_types:
+            self.condition_class_map[cond_type].update_value()

solax_py_library/smart_scene/exceptions/__init__.py

@@ -0,0 +1,7 @@
+from price import ElectricityPriceFailure
+from weather import WeatherFailure
+
+__all__ = [
+    "ElectricityPriceFailure",
+    "WeatherFailure",
+]

{solax_py_library-1.0.0.2507.dist-info → solax_py_library-1.0.0.2509.dist-info}/METADATA

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

{solax_py_library-1.0.0.2507.dist-info → solax_py_library-1.0.0.2509.dist-info}/RECORD

@@ -19,16 +19,16 @@ solax_py_library/smart_scene/core/action/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 solax_py_library/smart_scene/core/action/base.py,sha256=vSC3rL9qfPy41Nlds_0QcTLMbf4n-P18XUBJ3oYiNGk,237
 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=SIxUieoHkiuRQvmUCkI22knFzOlHkmAcbsuOWJeQGHk,429
-solax_py_library/smart_scene/core/condition/cabinet_condition.py,sha256=YhjmwgFBlugkMeRz6zfu1bV_Q-2LAbq5vjHfZgewSXE,1518
-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/core/condition/__init__.py,sha256=1nN-N52Oq7LKdn6ApKGtSZq5fB1qJzJq8BOKOumfQvY,475
+solax_py_library/smart_scene/core/condition/base.py,sha256=CMVHRuPrVpCjrc5WLHFU9nc-jrE9RLCbXfzBiNkURWE,456
+solax_py_library/smart_scene/core/condition/cabinet_condition.py,sha256=HEVifO3rHk2ElfSCEB0MzVdfrFWlkwqjt6tFhtJ8CLY,1581
+solax_py_library/smart_scene/core/condition/date_condition.py,sha256=-mzTgahn1IphYBBhT5dc_VeVrmgoIUCjhzVqrDJUqLc,915
+solax_py_library/smart_scene/core/condition/price_condition.py,sha256=mzUnrMuG0DHCxaQQe7-rmE_vra9U6vd-1AYDKkbPPUw,3884
+solax_py_library/smart_scene/core/condition/system_condition.py,sha256=g-5LSUAnu7JESUlTRbJ3MKm9cEMzofDZzNNm7_RSy10,1380
+solax_py_library/smart_scene/core/condition/weather_condition.py,sha256=OiKye007PZnocnmcrNQD6ObOEF7VyaYkdqz6D_2lNok,2236
+solax_py_library/smart_scene/core/service/__init__.py,sha256=4qoUm6NPOApn9hamW20oh5bL5cDo1AVjQ9qZtQVf6zM,65
+solax_py_library/smart_scene/core/service/run.py,sha256=9hevnzI0wtp4Szxo_EQFeMm0_-iuq5gdmvjbgmyKOz0,5707
+solax_py_library/smart_scene/exceptions/__init__.py,sha256=lPMBWT7DDAsnvz_g2PX8jgEqr9bOrPa2x3UZ0SKvO0w,145
 solax_py_library/smart_scene/exceptions/price.py,sha256=3bnY6JzeEskUoXVzEs8bpg6hQzgbinBKY4GP4hBITWU,152
 solax_py_library/smart_scene/exceptions/smart_scene.py,sha256=lIwzjdpvtrAub4lyTQRD3h2sM95vF6gpUy3Nmq1w1k0,1778
 solax_py_library/smart_scene/exceptions/weather.py,sha256=bJl1VwiIXEpLQ9VjlVrDoTAIMFqVZdRCas7dtR7eAJc,133
@@ -73,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.2507.dist-info/METADATA,sha256=QFXm7_nZgxPq1nYNqz-sRWxbuSCBSCMgwFdZkRqtQEc,1827
-solax_py_library-1.0.0.2507.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-solax_py_library-1.0.0.2507.dist-info/RECORD,,
+solax_py_library-1.0.0.2509.dist-info/METADATA,sha256=Z1mbr2wt6filJOXO4rpQUuBH2uEEJjJdULIWrv8ycHU,1827
+solax_py_library-1.0.0.2509.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+solax_py_library-1.0.0.2509.dist-info/RECORD,,

solax_py_library/smart_scene/core/service/smart_scene_service.py

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