egasp 0.0.1__py3-none-any.whl

egasp/__init__.py

@@ -0,0 +1,13 @@
+'''
+一款用于获取乙二醇水溶液物性参数的工具
+可用函数 get_egasp()
+'''
+
+import sys
+from .__main__ import get_egasp
+
+if sys.version_info[0] == 3:
+    from .__main__ import main  # 显式导出 main() 供 CLI 入口使用
+else:
+    # Don't import anything.
+    pass 

egasp/__main__.py

@@ -0,0 +1,145 @@
+'''
+ =======================================================================
+ ····Y88b···d88P················888b·····d888·d8b·······················
+ ·····Y88b·d88P·················8888b···d8888·Y8P·······················
+ ······Y88o88P··················88888b·d88888···························
+ ·······Y888P··8888b···88888b···888Y88888P888·888·88888b·····d88b·······
+ ········888······"88b·888·"88b·888·Y888P·888·888·888·"88b·d88P"88b·····
+ ········888···d888888·888··888·888··Y8P··888·888·888··888·888··888·····
+ ········888··888··888·888··888·888···"···888·888·888··888·Y88b·888·····
+ ········888··"Y888888·888··888·888·······888·888·888··888··"Y88888·····
+ ·······························································888·····
+ ··························································Y8b·d88P·····
+ ···························································"Y88P"······
+ =======================================================================
+
+ -----------------------------------------------------------------------
+Author       : 焱铭
+Date         : 2025-04-22 10:43:55 +0800
+LastEditTime : 2025-04-22 20:17:41 +0800
+Github       : https://github.com/YanMing-lxb/
+FilePath     : /EG-ASP/src/egasp/__main__.py
+Description  : 
+ -----------------------------------------------------------------------
+'''
+
+import argparse
+from rich import box
+from rich import print
+from rich.table import Table
+from rich.console import Console
+from rich_argparse import RichHelpFormatter
+
+from egasp.validate import Validate
+from egasp.core import EG_ASP_Core
+from egasp.logger_config import setup_logger
+from egasp.check_version import UpdateChecker
+# 版本信息
+from egasp.version import script_name, __version__
+logger = setup_logger(True)
+
+def get_egasp(query_temp: float, query_type: str = 'volume', query_value: float = 50) -> tuple:
+    """
+    根据输入的查询类型、浓度和温度, 计算乙二醇水溶液的相关属性。
+
+    Parameters
+    ----------
+    query_type : str
+        查询浓度的类型, 可选值为 "volume" 或 "mass", 分别表示体积浓度和质量浓度, 默认值为 "volume"。
+    query_value : float
+        查询的浓度值, 范围为 10% 到 90%, 单位为百分比 (%), 默认值为 50。
+    query_temp : float
+        查询的温度值, 范围为 -35°C 到 125°C。
+
+    Returns
+    -------
+    tuple
+        返回一个包含以下属性的元组：
+        - mass: 质量浓度 (%)
+        - volume: 体积浓度 (%)
+        - freezing: 冰点 (°C)
+        - boiling: 沸点 (°C)
+        - rho: 密度 (kg/m³)
+        - cp: 比热容 (J/kg·K)
+        - k: 导热率 (W/m·K)
+        - mu: 动力粘度 (Pa·s)
+    """
+
+    eg = EG_ASP_Core()  # 初始化核心计算类实例
+    va = Validate()     # 初始化校验类实例
+
+    # 校验查询类型, 确保其为合法值 ("volume" 或 "mass")
+    query_type = va.type_value(query_type)
+
+    # 校验查询浓度, 确保其在 10% 到 90% 的范围内
+    query_value = va.input_value(query_value, min_val=10, max_val=90)
+
+    # 校验查询温度, 确保其在 -35°C 到 125°C 的范围内
+    query_temp = va.input_value(query_temp, min_val=-35, max_val=125)
+
+    # 打印校验后的查询参数
+    print(f"查询类型: {query_type}")
+    print(f"查询浓度: {query_value} %")
+    print(f"查询温度: {query_temp} °C")
+
+    # 根据查询类型调用相应的函数, 获取冰点和沸点属性
+    mass, volume, freezing, boiling = eg.get_fb_props(query_value, query_type=query_type)
+
+    # 获取密度 (rho), 单位为 kg/m³
+    rho = eg.get_props(temp=query_temp, conc=volume, egp_key='rho')
+
+    # 获取比热容 (cp), 单位为 J/kg·K
+    cp = eg.get_props(temp=query_temp, conc=volume, egp_key='cp')
+
+    # 获取导热率 (k), 单位为 W/m·K
+    k = eg.get_props(temp=query_temp, conc=volume, egp_key='k')
+
+    # 获取动力粘度 (mu), 单位为 Pa·s, 并将结果从 mPa·s 转换为 Pa·s
+    mu = eg.get_props(temp=query_temp, conc=volume, egp_key='mu') / 1000000
+
+    return mass, volume, freezing, boiling, rho, cp, k, mu
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='egasp', 
+        description="[i]乙二醇水溶液属性查询程序  ---- 焱铭[/]",
+        formatter_class = RichHelpFormatter,
+        )
+    parser.add_argument("--query_type", type=str, default="volume", help="浓度类型 (volume/mass or v/m), 默认值为 volume (体积浓度)")
+    parser.add_argument("--query_value", type=float, default=50, help="查询浓度 %% (范围: 10 ~ 90), 默认值为 50")  # 修改此处
+    parser.add_argument("query_temp", type=float, help="查询温度 °C (范围: -35 ~ 125)")  # 如果温度单位有%也需要转义
+
+    args = parser.parse_args()
+
+    console = Console(width=34)
+    console.print(f"\n[bold green]{script_name} v{__version__}[/bold green]", justify="center")
+    print('----------------------------------')
+    mass, volume, freezing, boiling, rho, cp, k, mu = get_egasp(args.query_temp, args.query_type, args.query_value)
+    print('----------------------------------\n')
+
+    # 创建表格
+    table = Table(show_header=True, header_style="bold dark_orange", box=box.ASCII_DOUBLE_HEAD, title="乙二醇水溶液查询结果")
+
+    # 添加列
+    table.add_column("属性", justify="left", style="cyan"   , no_wrap=True)
+    table.add_column("单位", justify="left", style="magenta", no_wrap=True)
+    table.add_column("数值", justify="left", style="green"  , no_wrap=True)
+
+    # 添加行
+    table.add_row("质量浓度" , "%"      , f"{mass:.2f}")
+    table.add_row("体积浓度" , "%"      , f"{volume:.2f}")
+    table.add_row("冰点"    , "°C"      , f"{freezing:.2f}")
+    table.add_row("沸点"    , "°C"      , f"{boiling:.2f}")
+    table.add_row("密度"    , "kg/m³"  , f"{rho:.2f}")
+    table.add_row("比热容"  , "J/kg·K" , f"{cp:.2f}")
+    table.add_row("导热率"  , "W/m·K"  , f"{k:.4f}")
+    table.add_row("粘度"    , "Pa·s"   , f"{mu:.8f}")
+
+    # 打印表格
+    console.print(table)
+
+    # 检查更新
+    uc = UpdateChecker(1, 6)  # 访问超时, 单位: 秒;缓存时长, 单位: 小时
+    uc.check_for_updates()
+if __name__ == "__main__":
+    main()

egasp/check_version.py

@@ -0,0 +1,197 @@
+
+import re
+import time
+import toml
+import logging
+import urllib.request
+from rich import print
+from pathlib import Path
+import importlib.metadata
+import importlib.resources
+from packaging import version
+from datetime import timedelta
+
+from egasp.language import set_language
+
+_ = set_language('check_version')
+
+
+class UpdateChecker():
+
+    def __init__(self, time_out, cache_time):
+        """
+        初始化 CheckVersion 类的实例。
+
+        参数:
+        time_out (int): 超时时间，单位为秒。
+        cache_time (int): 缓存时间，单位为小时。
+
+        行为逻辑:
+        1. 创建日志对象。
+        2. 初始化版本列表。
+        3. 将缓存时间转换为秒并存储。
+        4. 存储超时时间。
+        5. 获取 egasp 安装路径并拼接 data 子路径，创建 data 目录（如果已存在则不报错）。
+        6. 创建缓存文件路径。
+        """
+        self.logger = logging.getLogger(__name__)  # 创建日志对象
+
+        self.versions = []  # 初始化版本列表
+
+        self.cache_time = cache_time * 3600  # 将缓存时间转换为秒并存储
+        self.time_out = time_out  # 存储超时时间
+
+        data_path = Path(importlib.resources.files('egasp')) / 'data'  # 获取 egasp 安装路径并拼接 data 子路径
+        self.cache_file = data_path / "egasp_version_cache.toml"  # 创建缓存文件路径
+
+    # --------------------------------------------------------------------------------
+    # 定义 缓存文件读取函数
+    # --------------------------------------------------------------------------------
+    def _load_cached_version(self):
+        """
+        从缓存文件中加载最新版本号.
+
+        行为逻辑说明:
+        - 尝试读取缓存文件路径.
+        - 检查缓存文件是否存在且未过期(根据缓存时间判断).
+        - 如果缓存文件有效,读取文件内容并返回最新版本号.
+        - 如果发生任何异常,记录错误信息并返回 None.
+
+        返回说明:
+        - 返回缓存文件中的最新版本号,如果加载失败或缓存文件无效,则返回 None.
+        """
+        try:
+            cache_path = Path(self.cache_file)  # 获取缓存文件路径
+            if not cache_path.exists():
+                return None  # 如果缓存文件不存在,返回 None
+
+            # 使用timedelta来转换秒数
+            cache_time_remaining = round(self.cache_time - (time.time() - cache_path.stat().st_mtime), 4)  # 计算缓存剩余时间
+            delta = timedelta(seconds=cache_time_remaining)
+            # 计算小时、分钟和秒
+            total_seconds = delta.total_seconds()  # 将timedelta转换为总秒数
+            hours, remainder = divmod(int(total_seconds), 3600)  # 计算小时数
+            minutes, seconds = divmod(remainder, 60)  # 计算分钟数和秒数
+
+            if cache_path.exists() and (cache_time_remaining > 0):  # 检查缓存文件是否存在且未过期
+                with cache_path.open('r') as f:  # 打开缓存文件
+                    data = toml.load(f)  # 加载缓存文件内容
+                    self.logger.info(_("读取 egasp 版本缓存文件中的版本号，缓存有效期: ") + f'{int(hours):02} h {int(minutes):02} min {int(seconds):02} s')  # 记录日志信息
+                    self.logger.info(_("egasp 版本缓存文件路径: ") + str(self.cache_file))  # 记录日志信息
+                    return data.get("latest_version")  # 返回最新版本号
+        except Exception as e:
+            self.logger.error(_("加载缓存版本时出错: ") + str(e))  # 记录错误信息
+        return None  # 如果加载失败或缓存文件无效,返回 None
+
+    # --------------------------------------------------------------------------------
+    # 定义 缓存文件写入函数
+    # --------------------------------------------------------------------------------
+    def _update_egasp_version_cache(self, latest_version):
+        """
+        更新egasp版本缓存文件.
+
+        参数:
+        latest_version (str): 最新的egasp版本号.
+
+        行为逻辑:
+        尝试打开缓存文件并以写模式写入最新的版本号.如果操作失败,记录错误日志.
+        """
+        try:
+            # 尝试以写模式打开缓存文件
+            with open(self.cache_file, 'w') as f:
+                # 使用toml库将最新的版本号写入文件
+                toml.dump({"latest_version": latest_version}, f)
+        except Exception as e:
+            # 如果更新缓存时出错,记录错误日志
+            self.logger.error(_("更新版本缓存时出错: ") + str(e))
+
+    # --------------------------------------------------------------------------------
+    # 定义 网络获取版本信息函数
+    # --------------------------------------------------------------------------------
+    def _get_latest_version(self, package_name):  # TODO 将该函数放到线程中执行,获取线程信息,保存,并且在下次运行时检查这个显示是否已经执行结束,如果结束则不再执行,否则执行
+        """
+        获取指定包的最新版本号.
+
+        参数:
+        package_name (str): 包的名称.
+
+        返回:
+        str: 最新版本号,如果获取失败则返回 None.
+
+        行为逻辑:
+        1. 记录开始时间.
+        2. 构建包的镜像URL.
+        3. 尝试打开URL并读取HTML内容.
+        4. 使用正则表达式匹配HTML内容中的版本号.
+        5. 将匹配到的版本号添加到版本列表中.
+        6. 如果版本列表不为空,返回最大版本号;否则记录错误并返回 None.
+        7. 捕获所有异常并记录错误信息,返回 None.
+        8. 记录获取版本号的耗时.
+        """
+        start_time = time.time()  # 记录开始时间
+        mirror_url = "https://mirrors.aliyun.com/pypi/simple/"  # 设置镜像URL #TODO 添加多个镜像源,进行循环尝试
+        url = f"{mirror_url}{package_name}"  # 构建包的URL
+
+        try:
+            response = urllib.request.urlopen(url)  # 尝试打开URL
+            html_content = response.read().decode('utf-8')  # 读取并解码HTML内容
+            pattern = re.compile(r'<a\s+href="[^"]+/egasp-([\d\.]+)-py3-none-any\.whl[^"]*"\s+data-requires-python="[^"]+">.*?</a>', re.DOTALL)  # 定义正则表达式模式
+            matches = pattern.findall(html_content)  # 使用正则表达式匹配版本号
+
+            for ver in matches:  # 遍历匹配到的版本号
+                self.versions.append(ver)  # 将版本号添加到版本列表中
+
+            if self.versions:  # 如果版本列表不为空
+                # 使用列表推导式和parse函数将字符串转换为版本对象
+                version_objects = [version.parse(ver) for ver in self.versions]
+
+                # 使用max函数和key参数找到最新版本
+                latest_version = max(version_objects)
+
+                self.logger.info(_("获取 %(args)s 最新版本号成功: ") % {"args": package_name} + f"[bold green]{latest_version}[/bold green]")  # 记录成功信息
+                return latest_version  # 返回最新版本号
+            else:
+                self.logger.error(_("获取 %(args)s 最新版本号失败: 未找到版本号") % {"args": package_name})  # 记录错误信息
+                return None  # 返回 None
+
+        except Exception as e:  # 捕获所有异常
+            self.logger.error(_("获取 %(args)s 最新版本号出错: ") % {"args": package_name} + str(e))  # 记录错误信息
+            return None  # 返回 None
+        finally:
+            end_time = time.time()  # 记录结束时间
+            elapsed_time = round(end_time - start_time, 4)  # 计算耗时
+            self.logger.info(_("获取最新版本号耗时: ") + f"{elapsed_time} s")  # 记录耗时信息
+
+    # --------------------------------------------------------------------------------
+    # 定义 更新检查主函数
+    # --------------------------------------------------------------------------------
+    def check_for_updates(self):
+        """
+        检查是否有新版本可用,并提示用户更新.
+
+        行为逻辑说明:
+        1. 从缓存中加载最新版本信息.
+        2. 如果缓存中没有最新版本信息,则从远程获取最新版本信息并更新缓存.
+        3. 获取当前安装的版本信息.
+        4. 比较当前版本和最新版本,如果当前版本较旧,则提示用户更新.
+        5. 如果当前版本是最新的,则提示当前版本信息.
+        """
+        latest_version = self._load_cached_version()  # 从缓存中加载最新版本信息
+
+        if latest_version:
+            latest_version = version.parse(latest_version)  # 将字符串转换为版本对象
+        else:
+            latest_version = self._get_latest_version("egasp")
+            if latest_version:
+                self._update_egasp_version_cache(str(latest_version))
+            else:
+                return
+
+        # 获取当前安装的版本信息
+        current_version = version.parse(importlib.metadata.version("egasp"))
+
+        if current_version < latest_version:
+            print(_("有新版本可用: ") + f"[bold green]{latest_version}[/bold green] " + _("当前版本: ") + f"[bold red]{current_version}[/bold red]")
+            print(_("请运行 [bold green]'pip install --upgrade egasp'[/bold green] 进行更新"))
+        else:
+            print(_("当前版本: ") + f"[bold green]{current_version}[/bold green]")

egasp/core.py

@@ -0,0 +1,177 @@
+import logging
+
+from egasp.data import EGP
+
+
+
+class EG_ASP_Core:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+    def _interpolate_linear(self, x1: float, y1: float, x2: float, y2: float, x: float) -> float:
+        """线性插值函数
+        
+        根据两点 (x1,y1) 和 (x2,y2) 计算x处的插值y
+        
+        Parameters
+        ----------
+        x1 : float
+            第一个点的x坐标
+        y1 : float
+            第一个点的y坐标
+        x2 : float
+            第二个点的x坐标
+        y2 : float
+            第二个点的y坐标
+        x : float
+            插值点的x坐标
+
+        Returns
+        -------
+        float
+            插值结果y
+        """
+        return y1 + (y2 - y1) * (x - x1) / (x2 - x1)
+
+
+    def get_props(self, temp: float, conc: float, egp_key: str, 
+                    temp_range: tuple = (-35, 125), conc_range: tuple = (10, 90),
+                    temp_step: int = 5, conc_step: float = 10) -> float | None:
+        """根据温度和浓度获取乙二醇水溶液的物性参数
+
+        Parameters
+        ----------
+        temp : float
+            温度, 单位摄氏度
+        conc : float
+            浓度, 质量分数 (10%~90%)
+        egp_key : str
+            物性关键词: rho cp k mu 分别对应密度、比热容、导热率和动力粘度
+        temp_range : tuple, optional
+            温度范围, 默认(-35, 125)
+        conc_range : tuple, optional
+            浓度范围, 默认(10, 90)
+        temp_step : int, optional
+            温度步长, 默认5
+        conc_step : float, optional
+            浓度步长, 默认10
+
+        Returns
+        -------
+        float | None
+            对应的物性参数值, 如果输入超出范围或数据中存在None, 返回None
+        """
+        # data_matrix: 二维列表, 行对应温度, 列对应浓度, 存储物性参数值
+        data_matrix = EGP.get(egp_key)
+        # 生成温度节点列表
+        temp_nodes = list(range(temp_range[0], temp_range[1] + 1, temp_step))
+        # 生成浓度节点列表, 避免浮点精度问题
+        conc_nodes = [round(conc_range[0] + i * conc_step, 1) 
+                    for i in range(int((conc_range[1] - conc_range[0]) / conc_step) + 1)]
+        
+        # 检查输入参数是否在有效范围内
+        if (temp < temp_nodes[0] or temp > temp_nodes[-1] or
+            conc < conc_nodes[0] or conc > conc_nodes[-1]):
+            self.logger.error(f"查询温度 {temp} °C 浓度 {conc} % 在数据库范围之外")
+        
+        # 找到相邻温度节点
+        t_lower = max(t for t in temp_nodes if t <= temp)
+        t_upper = min(t for t in temp_nodes if t >= temp)
+        
+        # 找到相邻浓度节点
+        c_lower = max(c for c in conc_nodes if c <= conc)
+        c_upper = min(c for c in conc_nodes if c >= conc)
+        
+        # 获取索引位置
+        t_lower_idx = temp_nodes.index(t_lower)
+        t_upper_idx = temp_nodes.index(t_upper)
+        c_lower_idx = conc_nodes.index(c_lower)
+        c_upper_idx = conc_nodes.index(c_upper)
+        
+        # 提取四个角点的值
+        v11 = data_matrix[t_lower_idx][c_lower_idx]
+        v12 = data_matrix[t_lower_idx][c_upper_idx]
+        v21 = data_matrix[t_upper_idx][c_lower_idx]
+        v22 = data_matrix[t_upper_idx][c_upper_idx]
+        
+        # 检查数据有效性
+        if any(v is None for v in [v11, v12, v21, v22]):
+            self.logger.error(f"查询温度 {temp} °C 浓度 {conc} % 在数据库缺失数据范围之内, 请调整输入值。")
+            exit()
+        
+        # 执行双线性插值
+        if t_lower == t_upper and c_lower == c_upper:
+            return v11
+        elif t_lower == t_upper:
+            return self._interpolate_linear(c_lower, v11, c_upper, v12, conc)
+        elif c_lower == c_upper:
+            return self._interpolate_linear(t_lower, v11, t_upper, v21, temp)
+        else:
+            v1 = self._interpolate_linear(c_lower, v11, c_upper, v12, conc)
+            v2 = self._interpolate_linear(c_lower, v21, c_upper, v22, conc)
+            return self._interpolate_linear(t_lower, v1, t_upper, v2, temp)
+
+
+    def get_fb_props(self, query: float, query_type: str = 'volume') -> tuple[float, float, float, float] | None:
+        """根据质量浓度或体积浓度查询乙二醇溶液的属性
+
+        Parameters
+        ----------
+        query : float
+            查询的浓度值
+        query_type : str, optional
+            查询类型, 'mass' 或 'volume', 默认为 'volume'
+
+        Returns
+        -------
+        tuple[float, float, float, float] | None
+            返回对应的质量浓度、体积浓度、冰点、沸点, 如果查询值超出范围返回None
+
+        Raises
+        ------
+        ValueError
+            当query_type不是'mass'或'volume'时抛出
+        """
+
+        # 每个元素为 (mass_conc, volume_conc, freezing, boiling)
+        data = EGP.get('fb')
+
+        # 根据查询类型排序数据
+        sort_key = 1 if query_type == 'volume' else 0
+        sorted_data = sorted(data, key=lambda x: x[sort_key])
+        
+        # 遍历寻找相邻数据点
+        for i in range(len(sorted_data) - 1):
+            current = sorted_data[i]
+            next_item = sorted_data[i + 1]
+            
+            current_val = current[sort_key]
+            next_val = next_item[sort_key]
+            
+            if current_val <= query <= next_val:
+                # 解包数据点
+                m1, v1, f1, b1 = current
+                m2, v2, f2, b2 = next_item
+                
+                # 检查数据有效性
+                if any(v is None for v in [m1, v1, f1, b1, m2, v2, f2, b2]):
+                    self.logger.error(f"查询浓度 {query} % 在数据库缺失数据范围之内, 请调整输入值。")
+                    exit()
+                
+                # 执行插值计算
+                if query_type == 'volume':
+                    mass = self._interpolate_linear(v1, m1, v2, m2, query)
+                    volume = query
+                    freezing = self._interpolate_linear(v1, f1, v2, f2, query)
+                    boiling = self._interpolate_linear(v1, b1, v2, b2, query)
+                else:
+                    volume = self._interpolate_linear(m1, v1, m2, v2, query)
+                    mass = query
+                    freezing = self._interpolate_linear(m1, f1, m2, f2, query)
+                    boiling = self._interpolate_linear(m1, b1, m2, b2, query)
+                
+                return (mass, volume, freezing, boiling)
+        
+        # 查询值超出数据范围
+        self.logger.error(f"查询浓度 {query} % 超出数据")
+        exit()