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

solax_py_library/upload/test/test_ftp.py

@@ -1,113 +1,113 @@
-import asyncio
-import unittest
-
-from solax_py_library.upload.api.service import upload
-from solax_py_library.upload.core.upload_service import FTPUploadService
-from solax_py_library.upload.exceptions import ConnectError, LoginError
-from solax_py_library.upload.types.client import UploadType, UploadData
-from solax_py_library.upload.types.ftp import FTPFileType
-
-
-class FTPTest(unittest.TestCase):
-    def test_connect(self):
-        ftp_config = {
-            "host": "10.1.31.181",  # 测试host
-            "port": 21,
-            "user": "solax",
-            "password": "123456",
-            "remote_path": "/xixi",
-        }
-        ftp = FTPUploadService(**ftp_config)
-        ftp.connect()
-
-    def test_connect_error_1(self):
-        ftp_config = {
-            "host": "10.1.31.182",  # 测试host
-            "port": 21,
-            "user": "solax",
-            "password": "123456",
-            "remote_path": "/xixi",
-        }
-        ftp = FTPUploadService(**ftp_config)
-        try:
-            ftp.connect()
-        except ConnectError:
-            ...
-
-    def test_connect_error_2(self):
-        ftp_config = {
-            "host": "10.1.31.181",  # 测试host
-            "port": 21,
-            "user": "solax123",
-            "password": "123456",
-            "remote_path": "/xixi",
-        }
-        ftp = FTPUploadService(**ftp_config)
-        try:
-            ftp.connect()
-        except LoginError:
-            ...
-
-    def test_ftp_upload_to_windows(self):
-        ftp_config = {
-            "host": "10.1.31.181",  # 测试host
-            "port": 21,
-            "user": "solax",
-            "password": "123456",
-            "remote_path": "嘻嘻",
-        }
-        asyncio.run(
-            upload(
-                upload_type=UploadType.FTP,
-                configuration=ftp_config,
-                upload_data=UploadData(
-                    upload_type=UploadType.FTP,
-                    data=dict(
-                        file_type=FTPFileType.CSV,
-                        file_name="中文",
-                        data=[
-                            {
-                                "EMS1000序列号": "XMG11A011L",
-                                "EMS1000本地时间": "2025-02-11 15:39:10",
-                                "EMS1000版本号": "V007.11.1",
-                                "电站所在国家和地区": None,
-                                "电站所在当前时区": None,
-                                "电站系统类型": None,
-                            }
-                        ],
-                    ),
-                ),
-            )
-        )
-
-    def test_ftp_upload_to_linux(self):
-        ftp_config = {
-            "host": "920729yofx76.vicp.fun",  # 测试host
-            "port": 59477,
-            "user": "test",
-            "password": "test123456",
-            "remote_path": "test",
-        }
-        asyncio.run(
-            upload(
-                upload_type=UploadType.FTP,
-                configuration=ftp_config,
-                upload_data=UploadData(
-                    upload_type=UploadType.FTP,
-                    data=dict(
-                        file_type=FTPFileType.CSV,
-                        file_name="中文",
-                        data=[
-                            {
-                                "EMS1000序列号": "XMG11A011L",
-                                "EMS1000本地时间": "2025-02-11 15:39:10",
-                                "EMS1000版本号": "V007.11.1",
-                                "电站所在国家和地区": None,
-                                "电站所在当前时区": None,
-                                "电站系统类型": None,
-                            }
-                        ],
-                    ),
-                ),
-            )
-        )
+import asyncio
+import unittest
+
+from solax_py_library.upload.api.service import upload
+from solax_py_library.upload.core.upload_service import FTPUploadService
+from solax_py_library.upload.exceptions import ConnectError, LoginError
+from solax_py_library.upload.types.client import UploadType, UploadData
+from solax_py_library.upload.types.ftp import FTPFileType
+
+
+class FTPTest(unittest.TestCase):
+    def test_connect(self):
+        ftp_config = {
+            "host": "10.1.31.181",  # 测试host
+            "port": 21,
+            "user": "solax",
+            "password": "123456",
+            "remote_path": "/xixi",
+        }
+        ftp = FTPUploadService(**ftp_config)
+        ftp.connect()
+
+    def test_connect_error_1(self):
+        ftp_config = {
+            "host": "10.1.31.182",  # 测试host
+            "port": 21,
+            "user": "solax",
+            "password": "123456",
+            "remote_path": "/xixi",
+        }
+        ftp = FTPUploadService(**ftp_config)
+        try:
+            ftp.connect()
+        except ConnectError:
+            ...
+
+    def test_connect_error_2(self):
+        ftp_config = {
+            "host": "10.1.31.181",  # 测试host
+            "port": 21,
+            "user": "solax123",
+            "password": "123456",
+            "remote_path": "/xixi",
+        }
+        ftp = FTPUploadService(**ftp_config)
+        try:
+            ftp.connect()
+        except LoginError:
+            ...
+
+    def test_ftp_upload_to_windows(self):
+        ftp_config = {
+            "host": "10.1.31.181",  # 测试host
+            "port": 21,
+            "user": "solax",
+            "password": "123456",
+            "remote_path": "嘻嘻",
+        }
+        asyncio.run(
+            upload(
+                upload_type=UploadType.FTP,
+                configuration=ftp_config,
+                upload_data=UploadData(
+                    upload_type=UploadType.FTP,
+                    data=dict(
+                        file_type=FTPFileType.CSV,
+                        file_name="中文",
+                        data=[
+                            {
+                                "EMS1000序列号": "XMG11A011L",
+                                "EMS1000本地时间": "2025-02-11 15:39:10",
+                                "EMS1000版本号": "V007.11.1",
+                                "电站所在国家和地区": None,
+                                "电站所在当前时区": None,
+                                "电站系统类型": None,
+                            }
+                        ],
+                    ),
+                ),
+            )
+        )
+
+    def test_ftp_upload_to_linux(self):
+        ftp_config = {
+            "host": "920729yofx76.vicp.fun",  # 测试host
+            "port": 59477,
+            "user": "test",
+            "password": "test123456",
+            "remote_path": "test",
+        }
+        asyncio.run(
+            upload(
+                upload_type=UploadType.FTP,
+                configuration=ftp_config,
+                upload_data=UploadData(
+                    upload_type=UploadType.FTP,
+                    data=dict(
+                        file_type=FTPFileType.CSV,
+                        file_name="中文",
+                        data=[
+                            {
+                                "EMS1000序列号": "XMG11A011L",
+                                "EMS1000本地时间": "2025-02-11 15:39:10",
+                                "EMS1000版本号": "V007.11.1",
+                                "电站所在国家和地区": None,
+                                "电站所在当前时区": None,
+                                "电站系统类型": None,
+                            }
+                        ],
+                    ),
+                ),
+            )
+        )

solax_py_library/upload/types/__init__.py

@@ -1,11 +1,11 @@
-from .client import UploadType, UploadData
-from .ftp import FTPData, FTPParsedData, FTPFileType, FTPServiceConfig
-
-__all__ = [
-    "FTPData",
-    "FTPParsedData",
-    "FTPServiceConfig",
-    "UploadType",
-    "UploadData",
-    "FTPFileType",
-]
+from .client import UploadType, UploadData
+from .ftp import FTPData, FTPParsedData, FTPFileType, FTPServiceConfig
+
+__all__ = [
+    "FTPData",
+    "FTPParsedData",
+    "FTPServiceConfig",
+    "UploadType",
+    "UploadData",
+    "FTPFileType",
+]

solax_py_library/upload/types/client.py

@@ -1,19 +1,19 @@
-from enum import IntEnum
-from pydantic import BaseModel
-from typing import Optional, Union
-
-from solax_py_library.upload.types.ftp import FTPData
-
-
-class UploadType(IntEnum):
-    FTP = 1
-
-
-class UploadData(BaseModel):
-    data: Optional[Union[dict, FTPData]]
-    upload_type: UploadType
-
-    def build_data(self):
-        dict_obj_data = self.data if isinstance(self.data, dict) else self.data.dict()
-        if self.upload_type == UploadType.FTP:
-            return FTPData(**dict_obj_data)
+from enum import IntEnum
+from pydantic import BaseModel
+from typing import Optional, Union
+
+from solax_py_library.upload.types.ftp import FTPData
+
+
+class UploadType(IntEnum):
+    FTP = 1
+
+
+class UploadData(BaseModel):
+    data: Optional[Union[dict, FTPData]]
+    upload_type: UploadType
+
+    def build_data(self):
+        dict_obj_data = self.data if isinstance(self.data, dict) else self.data.dict()
+        if self.upload_type == UploadType.FTP:
+            return FTPData(**dict_obj_data)

solax_py_library/upload/types/ftp.py

@@ -1,37 +1,37 @@
-import os
-from enum import IntEnum
-from typing import Any, Optional
-
-from pydantic import BaseModel
-
-
-class FTPFileType(IntEnum):
-    CSV = 1
-
-    @classmethod
-    def get_file_suffix(cls, value):
-        return {
-            FTPFileType.CSV: ".csv",
-        }.get(value)
-
-
-class FTPData(BaseModel):
-    file_type: FTPFileType
-    file_name: str
-    data: Any
-
-    def build_full_path(self, remote_path) -> str:
-        return os.path.join(remote_path, self.file_name)
-
-
-class FTPServiceConfig(BaseModel):
-    host: str
-    port: int
-    user: Optional[str]
-    password: Optional[str]
-    remote_path: str
-
-
-class FTPParsedData(BaseModel):
-    file_name: str
-    file_path: str
+import os
+from enum import IntEnum
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+
+class FTPFileType(IntEnum):
+    CSV = 1
+
+    @classmethod
+    def get_file_suffix(cls, value):
+        return {
+            FTPFileType.CSV: ".csv",
+        }.get(value)
+
+
+class FTPData(BaseModel):
+    file_type: FTPFileType
+    file_name: str
+    data: Any
+
+    def build_full_path(self, remote_path) -> str:
+        return os.path.join(remote_path, self.file_name)
+
+
+class FTPServiceConfig(BaseModel):
+    host: str
+    port: int
+    user: Optional[str]
+    password: Optional[str]
+    remote_path: str
+
+
+class FTPParsedData(BaseModel):
+    file_name: str
+    file_path: str

solax_py_library/utils/cloud_client.py

@@ -0,0 +1,210 @@
+import json
+import traceback
+from datetime import datetime
+
+import requests
+
+from solax_py_library.utils.time_util import trans_str_time_to_index
+
+
+class CloudClient:
+    def __init__(self, base_url):
+        self.base_url = base_url
+
+    def get_token(self, ems_sn, sn_secret):
+        token_url = self.base_url + "/device/token/getByRegistrationSn"
+        try:
+            response = requests.post(
+                token_url,
+                json={
+                    "registrationSn": ems_sn,
+                    "snSecret": sn_secret,
+                },
+                timeout=5
+            )
+            if response.content:
+                response_data = json.loads(response.content)
+                print(f"获取token结果 {response_data}")
+                if response_data.get("code") == 0 and response_data.get("result"):
+                    token = response_data["result"]
+                    return token
+        except Exception as e:
+            print(f"访问token接口失败: {str(e)}")
+
+    def get_weather_data_from_cloud(self, ems_sn, token):
+        """获取未来24小时天气数据"""
+        try:
+            weather_url = self.base_url + "/ess/web/v1/powerStation/station/solcast/get"
+            headers = {"token": token, "Content-Type": "application/json"}
+            post_dict = {"registerNo": ems_sn, "day": 1}
+            response = requests.post(
+                url=weather_url, data=json.dumps(post_dict), headers=headers, timeout=5
+            )
+            # 访问失败或获取数据失败，则重复插入最后一条数据
+            if response.status_code != 200:
+                print(f"获取天气数据失败 状态码 {response.status_code}")
+                return False
+            response_data = response.json()
+            if response_data.get("result") is None:
+                print(f"获取天气数据失败 返回数据 {response_data}")
+                return False
+            weather_info = {
+                "timeList": [],
+                "irradiance": {"valueList": []},
+                "temperature": {"valueList": []},
+                "humidity": {"valueList": []},
+                "wind": {"valueList": []},
+                "barometricPressure": {"valueList": []},
+                "rain": {"valueList": []},
+            }
+            for info in response_data["result"]:
+                weather_info["timeList"].append(info["localTime"])
+                weather_info["irradiance"]["valueList"].append(float(info["ghi"]))
+                weather_info["temperature"]["valueList"].append(float(info["air_temp"]))
+                weather_info["humidity"]["valueList"].append(
+                    float(info["relative_humidity"])
+                )
+                weather_info["wind"]["valueList"].append(float(info["wind_speed_10m"]))
+                weather_info["barometricPressure"]["valueList"].append(
+                    float(info.get("surface_pressure", 0))
+                )
+                rain = 1 if float(info["precipitation_rate"]) > 2.5 else 0
+                weather_info["rain"]["valueList"].append(rain)
+            data_length = len(weather_info["irradiance"]["valueList"])
+            if weather_info["timeList"] == []:
+                weather_info = {}
+            else:
+                weather_info["irradiance"]["maxValue"] = max(
+                    weather_info["irradiance"]["valueList"]
+                )
+                weather_info["irradiance"]["avgValue"] = round(
+                    sum(weather_info["irradiance"]["valueList"]) / data_length, 3
+                )
+                weather_info["irradiance"]["minValue"] = min(
+                    weather_info["irradiance"]["valueList"]
+                )
+
+                weather_info["temperature"]["maxValue"] = max(
+                    weather_info["temperature"]["valueList"]
+                )
+                weather_info["temperature"]["avgValue"] = round(
+                    sum(weather_info["temperature"]["valueList"]) / data_length, 3
+                )
+                weather_info["temperature"]["minValue"] = min(
+                    weather_info["temperature"]["valueList"]
+                )
+
+                weather_info["humidity"]["maxValue"] = max(
+                    weather_info["humidity"]["valueList"]
+                )
+                weather_info["humidity"]["avgValue"] = round(
+                    sum(weather_info["humidity"]["valueList"]) / data_length, 3
+                )
+                weather_info["humidity"]["minValue"] = min(
+                    weather_info["humidity"]["valueList"]
+                )
+
+                weather_info["wind"]["maxValue"] = max(
+                    weather_info["wind"]["valueList"]
+                )
+                weather_info["wind"]["avgValue"] = round(
+                    sum(weather_info["wind"]["valueList"]) / data_length, 3
+                )
+                weather_info["wind"]["minValue"] = min(
+                    weather_info["wind"]["valueList"]
+                )
+
+                weather_info["barometricPressure"]["maxValue"] = max(
+                    weather_info["barometricPressure"]["valueList"]
+                )
+                weather_info["barometricPressure"]["avgValue"] = round(
+                    sum(weather_info["barometricPressure"]["valueList"]) / data_length,
+                    3,
+                )
+                weather_info["barometricPressure"]["minValue"] = min(
+                    weather_info["barometricPressure"]["valueList"]
+                )
+
+                weather_info["rain"]["maxValue"] = max(
+                    weather_info["rain"]["valueList"]
+                )
+                weather_info["rain"]["minValue"] = min(
+                    weather_info["rain"]["valueList"]
+                )
+            return weather_info
+            print("获取天气数据成功")
+        except Exception:
+            print(f"获取天气数据失败 异常 {traceback.format_exc()}")
+            return False
+
+    def get_electrovalence_data_from_cloud(self, ems_sn, token):
+        try:
+            price_url = self.base_url + "/powerStation/station/getCurrentElectrovalence"
+            response = requests.post(
+                url=price_url,
+                headers={"token": token, "Content-Type": "application/json"},
+                json={"registerNo": ems_sn},
+                timeout=5
+            )
+            # 访问失败或获取数据失败，则重复插入最后一条数据
+            if response.status_code != 200:
+                print(f"获取电价数据失败 状态码 {response.status_code}")
+                return False
+            response_data = response.json()
+            if response_data.get("result") is None:
+                print(f"获取电价数据失败 返回数据 {response_data}")
+                return False
+            today = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
+            ele_price_info = {
+                "buy": [None] * 192,
+                "sell": [None] * 192,
+                "date": today,
+            }
+            ele_price_info["ele_unit"] = response_data["result"]["unit"]
+            if ele_price_info["ele_unit"] == "¥":
+                rate = 1
+                ele_price_info["ele_unit"] = "¥/kWh"
+            else:
+                rate = 100
+                ele_price_info["ele_unit"] = "Cents €/kWh"
+            for detail_info in response_data["result"]["list"]:
+                start_index = trans_str_time_to_index(detail_info["startTime"])
+                end_index = trans_str_time_to_index(detail_info["endTime"])
+                # 处理欧分的情况
+                if detail_info["buyPrice"] is not None:
+                    buy_price = round(detail_info["buyPrice"] * rate, 5)
+                else:
+                    buy_price = detail_info["buyPrice"]
+                if detail_info["salePrice"] is not None:
+                    sale_price = round(detail_info["salePrice"] * rate, 5)
+                else:
+                    sale_price = detail_info["salePrice"]
+                ele_price_info["buy"][start_index:end_index] = [buy_price] * (
+                    end_index - start_index
+                )
+                ele_price_info["sell"][start_index:end_index] = [sale_price] * (
+                    end_index - start_index
+                )
+            if response_data["result"].get("tomorrow") is not None:
+                for detail_info in response_data["result"]["tomorrow"]:
+                    start_index = trans_str_time_to_index(detail_info["startTime"]) + 96
+                    end_index = trans_str_time_to_index(detail_info["endTime"]) + 96
+                    if detail_info["buyPrice"] is not None:
+                        buy_price = round(detail_info["buyPrice"] * rate, 5)
+                    else:
+                        buy_price = detail_info["buyPrice"]
+                    if detail_info["salePrice"] is not None:
+                        sale_price = round(detail_info["salePrice"] * rate, 5)
+                    else:
+                        sale_price = detail_info["salePrice"]
+                    ele_price_info["buy"][start_index:end_index] = [buy_price] * (
+                        end_index - start_index
+                    )
+                    ele_price_info["sell"][start_index:end_index] = [sale_price] * (
+                        end_index - start_index
+                    )
+            print("获取电价数据成功")
+            return ele_price_info
+        except Exception:
+            print(f"获取电价数据失败 异常 {traceback.format_exc()}")
+            return False

solax_py_library/utils/common.py

@@ -1,38 +1,38 @@
-import asyncio
-from decimal import Decimal, ROUND_HALF_UP
-
-
-def retry(max_attempts=3, delay=0.5, assign_exception=Exception):
-    def decorator(func):
-        async def wrapper(*args, **kwargs):
-            attempts = 0
-            while attempts < max_attempts:
-                try:
-                    return await func(*args, **kwargs)
-                except Exception as e:
-                    print(f"尝试 {attempts+1} 失败: {e}")
-                    await asyncio.sleep(delay)
-                    attempts += 1
-            raise assign_exception(f"操作失败 {max_attempts} 次")
-
-        return wrapper
-
-    return decorator
-
-
-def round_value(value, decimal_places=0):
-    """
-    实现四舍五入 代替round函数 遇到5向上取整
-    @param value: 传入数值
-    @param decimal_places: 保留几位小数
-    @return:
-    """
-    if isinstance(value, int):
-        return value
-    else:
-        # 优化小数位 Decimal函数太耗时 曲线数据直接使用round函数
-        # rounded_value = ("{:.%df}" % decimal_places).format(value)
-        rounded_value = Decimal(str(value)).quantize(
-            Decimal("1e-" + str(decimal_places)), rounding=ROUND_HALF_UP
-        )
-        return float(rounded_value)
+import asyncio
+from decimal import Decimal, ROUND_HALF_UP
+
+
+def retry(max_attempts=3, delay=0.5, assign_exception=Exception):
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            attempts = 0
+            while attempts < max_attempts:
+                try:
+                    return await func(*args, **kwargs)
+                except Exception as e:
+                    print(f"尝试 {attempts+1} 失败: {e}")
+                    await asyncio.sleep(delay)
+                    attempts += 1
+            raise assign_exception(f"操作失败 {max_attempts} 次")
+
+        return wrapper
+
+    return decorator
+
+
+def round_value(value, decimal_places=0):
+    """
+    实现四舍五入 代替round函数 遇到5向上取整
+    @param value: 传入数值
+    @param decimal_places: 保留几位小数
+    @return:
+    """
+    if isinstance(value, int):
+        return value
+    else:
+        # 优化小数位 Decimal函数太耗时 曲线数据直接使用round函数
+        # rounded_value = ("{:.%df}" % decimal_places).format(value)
+        rounded_value = Decimal(str(value)).quantize(
+            Decimal("1e-" + str(decimal_places)), rounding=ROUND_HALF_UP
+        )
+        return float(rounded_value)