l0n0lc 0.8.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

l0n0lc//346/225/260/347/273/204/345/257/271/350/261/241/346/261/240.py

@@ -0,0 +1,248 @@
+"""
+数组对象池模块
+
+提供高效的 ctypes 数组对象池，用于减少运行时参数转换开销。
+"""
+
+import ctypes
+import os
+from collections import OrderedDict
+from typing import Type, Tuple, Optional, Dict, Any
+from threading import Lock
+
+
+def 获取默认池大小() -> int:
+    """获取默认对象池大小"""
+    return int(os.environ.get("L0N0LC_ARRAY_POOL_SIZE", "128"))
+
+
+def 获取是否启用对象池() -> bool:
+    """获取是否启用对象池"""
+    return os.environ.get("L0N0LC_ENABLE_ARRAY_POOL", "1") == "1"
+
+
+class 数组对象池统计:
+    """对象池统计信息"""
+
+    def __init__(self):
+        self.命中次数 = 0
+        self.未命中次数 = 0
+        self.分配次数 = 0
+        self.释放次数 = 0
+        self.缓存数组数 = 0
+
+    def 重置(self):
+        """重置统计信息"""
+        self.命中次数 = 0
+        self.未命中次数 = 0
+        self.分配次数 = 0
+        self.释放次数 = 0
+        self.缓存数组数 = 0
+
+    def 获取命中率(self) -> float:
+        """获取缓存命中率"""
+        总次数 = self.命中次数 + self.未命中次数
+        if 总次数 == 0:
+            return 0.0
+        return self.命中次数 / 总次数
+
+    def __repr__(self) -> str:
+        return (
+            f"数组对象池统计(命中={self.命中次数}, 未命中={self.未命中次数}, "
+            f"命中率={self.获取命中率():.2%}, 分配={self.分配次数}, "
+            f"释放={self.释放次数}, 缓存={self.缓存数组数})"
+        )
+
+
+class 数组对象池:
+    """
+    ctypes 数组对象池
+
+    使用 LRU 缓存策略管理已分配的数组对象，减少重复分配开销。
+    """
+
+    def __init__(self, 最大大小: Optional[int] = None):
+        """
+        初始化对象池
+
+        Args:
+            最大大小: 最大缓存条目数，None 表示使用默认值
+        """
+        self._最大大小 = 最大大小 or 获取默认池大小()
+        self._缓存: OrderedDict[Tuple[Type, int], Any] = OrderedDict()
+        self._锁 = Lock()
+        self._统计 = 数组对象池统计()
+        self._是否启用 = 获取是否启用对象池()
+
+    def 获取(self, 元素类型: Type[Any], 大小: int) -> Optional[Any]:
+        """
+        从对象池获取数组
+
+        Args:
+            元素类型: ctypes 元素类型（如 ctypes.c_int64）
+            大小: 数组大小
+
+        Returns:
+            缓存的数组对象，如果未命中则返回 None
+        """
+        if not self._是否启用:
+            return None
+
+        key = (元素类型, 大小)
+
+        with self._锁:
+            if key in self._缓存:
+                # LRU: 移到末尾
+                self._缓存.move_to_end(key)
+                array = self._缓存[key]
+                self._统计.命中次数 += 1
+                self._统计.缓存数组数 = len(self._缓存)
+                return array
+            else:
+                self._统计.未命中次数 += 1
+                return None
+
+    def 分配(self, 元素类型: Type[Any], 大小: int) -> Any:
+        """
+        分配新数组
+
+        Args:
+            元素类型: ctypes 元素类型
+            大小: 数组大小
+
+        Returns:
+            新分配的数组对象
+        """
+        array_type = 元素类型 * 大小  # type: ignore
+        array = array_type()
+
+        with self._锁:
+            self._统计.分配次数 += 1
+
+        return array
+
+    def 释放(self, 元素类型: Type[Any], 大小: int, 数组: Any) -> None:
+        """
+        释放数组回对象池
+
+        Args:
+            元素类型: ctypes 元素类型
+            大小: 数组大小
+            数组: 要释放的数组对象
+        """
+        if not self._是否启用:
+            return
+
+        key = (元素类型, 大小)
+
+        with self._锁:
+            # 如果缓存已满，移除最旧的条目
+            if len(self._缓存) >= self._最大大小:
+                self._缓存.popitem(last=False)
+
+            self._缓存[key] = 数组
+            self._缓存.move_to_end(key)
+            self._统计.释放次数 += 1
+            self._统计.缓存数组数 = len(self._缓存)
+
+    def 获取或分配(self, 元素类型: Type[Any], 大小: int) -> Tuple[Any, bool]:
+        """
+        获取或分配数组
+
+        Args:
+            元素类型: ctypes 元素类型
+            大小: 数组大小
+
+        Returns:
+            (数组对象, 是否从缓存获取)
+        """
+        cached = self.获取(元素类型, 大小)
+        if cached is not None:
+            return cached, True
+
+        new_array = self.分配(元素类型, 大小)
+        return new_array, False
+
+    def 清空(self) -> None:
+        """清空对象池"""
+        with self._锁:
+            self._缓存.clear()
+
+    def 获取统计(self) -> 数组对象池统计:
+        """获取统计信息副本"""
+        with self._锁:
+            # 返回统计信息的副本
+            统计 = 数组对象池统计()
+            统计.命中次数 = self._统计.命中次数
+            统计.未命中次数 = self._统计.未命中次数
+            统计.分配次数 = self._统计.分配次数
+            统计.释放次数 = self._统计.释放次数
+            统计.缓存数组数 = len(self._缓存)
+            return 统计
+
+    def 设置启用(self, 启用: bool) -> None:
+        """设置是否启用对象池"""
+        self._是否启用 = 启用
+
+    def 是否启用(self) -> bool:
+        """获取是否启用对象池"""
+        return self._是否启用
+
+    def 获取缓存大小(self) -> int:
+        """获取当前缓存条目数"""
+        with self._锁:
+            return len(self._缓存)
+
+    def 获取最大大小(self) -> int:
+        """获取最大缓存大小"""
+        return self._最大大小
+
+
+# 全局对象池实例
+_全局对象池: Optional[数组对象池] = None
+_全局池锁 = Lock()
+
+
+def 获取全局对象池() -> 数组对象池:
+    """获取全局对象池实例（单例）"""
+    global _全局对象池
+
+    if _全局对象池 is None:
+        with _全局池锁:
+            if _全局对象池 is None:
+                _全局对象池 = 数组对象池()
+
+    return _全局对象池
+
+
+def 重置全局对象池(最大大小: Optional[int] = None) -> 数组对象池:
+    """
+    重置全局对象池
+
+    Args:
+        最大大小: 新的最大缓存大小，None 表示保持默认
+
+    Returns:
+        新创建的全局对象池实例
+    """
+    global _全局对象池
+
+    with _全局池锁:
+        _全局对象池 = 数组对象池(最大大小=最大大小)
+
+    return _全局对象池
+
+
+def 获取全局池统计() -> 数组对象池统计:
+    """获取全局对象池统计信息"""
+    return 获取全局对象池().获取统计()
+
+
+def 清空全局对象池() -> None:
+    """清空全局对象池"""
+    获取全局对象池().清空()
+
+
+def 设置全局池启用(启用: bool) -> None:
+    """设置全局对象池是否启用"""
+    获取全局对象池().设置启用(启用)

l0n0lc//346/226/207/344/273/266/347/256/241/347/220/206/345/231/250.py

@@ -0,0 +1,286 @@
+"""
+文件管理器模块
+
+统一管理文件路径构建、文件清理和缓存管理操作。
+消除重复代码，提供一致的文件操作接口。
+"""
+
+import os
+import glob
+import time
+from typing import List, Optional, Set
+
+
+class 文件管理器:
+    """
+    统一管理文件路径和清理操作
+
+    负责处理所有与文件系统相关的操作，包括：
+    - 文件路径构建
+    - 临时文件清理
+    - 缓存管理
+    - 目录操作
+    """
+
+    def __init__(self, 工作目录: str):
+        """
+        初始化文件管理器
+
+        Args:
+            工作目录: 编译输出目录
+        """
+        self.工作目录 = 工作目录
+
+    def 获取完整路径(self, 文件名: str) -> str:
+        """
+        获取文件的完整路径
+
+        Args:
+            文件名: 文件名（不含路径）
+
+        Returns:
+            完整路径: 工作目录/文件名
+        """
+        return f"{self.工作目录}/{文件名}"
+
+    def 确保目录存在(self):
+        """确保工作目录存在，不存在则创建"""
+        if not os.path.exists(self.工作目录):
+            try:
+                os.makedirs(self.工作目录, exist_ok=True)
+            except OSError as e:
+                raise RuntimeError(f"无法创建工作目录 {self.工作目录}: {e}")
+
+    def 清理临时文件(self, 基础名称: str):
+        """
+        清理编译产生的临时文件
+
+        Args:
+            基础名称: 文件的基础名称（不含扩展名）
+        """
+        temp_patterns = [
+            f"{self.工作目录}/{基础名称}*.o",
+            f"{self.工作目录}/{基础名称}*.tmp",
+            f"{self.工作目录}/{基础名称}*.bak"
+        ]
+
+        self._删除文件按模式(temp_patterns)
+
+    def 清理编译文件(self, 文件名列表: List[str]):
+        """
+        清理指定的编译文件
+
+        Args:
+            文件名列表: 需要清理的文件名列表
+        """
+        for 文件名 in 文件名列表:
+            file_path = self.获取完整路径(文件名)
+            if os.path.exists(file_path):
+                try:
+                    os.remove(file_path)
+                except OSError:
+                    pass  # 忽略删除失败
+
+    def 清理所有缓存(self, 过期时间: Optional[float] = None) -> int:
+        """
+        清理所有缓存文件
+
+        Args:
+            过期时间: 可选，只清理超过此时间（秒）的文件
+                     如果为 None，则清理所有缓存
+
+        Returns:
+            清理的文件数量
+        """
+        patterns = [
+            os.path.join(self.工作目录, "*.so"),
+            os.path.join(self.工作目录, "*.o"),
+            os.path.join(self.工作目录, "*.tmp"),
+            os.path.join(self.工作目录, "*.bak"),
+            os.path.join(self.工作目录, "*.cpp"),
+            os.path.join(self.工作目录, "*.h"),
+            os.path.join(self.工作目录, "*.hash"),
+            os.path.join(self.工作目录, "*.dylib"),  # macOS
+            os.path.join(self.工作目录, "*.dll")     # Windows
+        ]
+
+        cleaned_count = 0
+        当前时间 = time.time()
+
+        for pattern in patterns:
+            for file_path in glob.glob(pattern):
+                try:
+                    # 检查文件是否过期
+                    if 过期时间 is not None:
+                        file_mtime = os.path.getmtime(file_path)
+                        if 当前时间 - file_mtime <= 过期时间:
+                            continue
+
+                    os.remove(file_path)
+                    cleaned_count += 1
+                except OSError:
+                    pass
+
+        return cleaned_count
+
+    def 清理旧文件(self, 文件前缀: str):
+        """
+        清理具有指定前缀的所有旧文件
+
+        Args:
+            文件前缀: 文件名前缀
+        """
+        if not os.path.exists(self.工作目录):
+            return
+
+        for fname in os.listdir(self.工作目录):
+            if fname.startswith(文件前缀):
+                file_path = os.path.join(self.工作目录, fname)
+                try:
+                    os.remove(file_path)
+                except OSError:
+                    pass
+
+    def 文件是否存在(self, 文件名: str) -> bool:
+        """
+        检查文件是否存在
+
+        Args:
+            文件名: 文件名
+
+        Returns:
+            文件是否存在
+        """
+        return os.path.exists(self.获取完整路径(文件名))
+
+    def 文件是否可读(self, 文件名: str) -> bool:
+        """
+        检查文件是否可读
+
+        Args:
+            文件名: 文件名
+
+        Returns:
+            文件是否可读
+        """
+        file_path = self.获取完整路径(文件名)
+        return os.path.exists(file_path) and os.access(file_path, os.R_OK)
+
+    def 获取文件大小(self, 文件名: str) -> int:
+        """
+        获取文件大小
+
+        Args:
+            文件名: 文件名
+
+        Returns:
+            文件大小（字节）
+        """
+        file_path = self.获取完整路径(文件名)
+        if os.path.exists(file_path):
+            return os.path.getsize(file_path)
+        return 0
+
+    def 获取文件修改时间(self, 文件名: str) -> float:
+        """
+        获取文件修改时间
+
+        Args:
+            文件名: 文件名
+
+        Returns:
+            文件修改时间（时间戳）
+        """
+        file_path = self.获取完整路径(文件名)
+        if os.path.exists(file_path):
+            return os.path.getmtime(file_path)
+        return 0
+
+    def 写入文件(self, 文件名: str, 内容: str):
+        """
+        写入内容到文件
+
+        Args:
+            文件名: 文件名
+            内容: 文件内容
+        """
+        self.确保目录存在()
+        file_path = self.获取完整路径(文件名)
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(内容)
+
+    def 读取文件(self, 文件名: str) -> Optional[str]:
+        """
+        读取文件内容
+
+        Args:
+            文件名: 文件名
+
+        Returns:
+            文件内容，如果文件不存在返回 None
+        """
+        file_path = self.获取完整路径(文件名)
+        if not os.path.exists(file_path):
+            return None
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    def 列出文件(self, 模式: str = "*") -> List[str]:
+        """
+        列出工作目录中匹配模式的文件
+
+        Args:
+            模式: 文件匹配模式（如 "*.cpp"）
+
+        Returns:
+            文件列表
+        """
+        if not os.path.exists(self.工作目录):
+            return []
+
+        pattern = os.path.join(self.工作目录, 模式)
+        return glob.glob(pattern)
+
+    def _删除文件按模式(self, 模式列表: List[str]):
+        """
+        根据模式列表删除文件
+
+        Args:
+            模式列表: 文件模式列表
+        """
+        for pattern in 模式列表:
+            for file_path in glob.glob(pattern):
+                try:
+                    os.remove(file_path)
+                except OSError:
+                    pass  # 忽略删除失败
+
+    def 获取状态摘要(self) -> dict:
+        """
+        获取文件管理器的状态摘要
+
+        Returns:
+            包含当前状态的字典
+        """
+        状态信息 = {
+            "工作目录": self.工作目录,
+            "目录是否存在": os.path.exists(self.工作目录)
+        }
+
+        if 状态信息["目录是否存在"]:
+            # 统计各类文件数量
+            文件统计 = {
+                "cpp文件": len(glob.glob(os.path.join(self.工作目录, "*.cpp"))),
+                "头文件": len(glob.glob(os.path.join(self.工作目录, "*.h"))),
+                "共享库": len(glob.glob(os.path.join(self.工作目录, "*.so"))) +
+                         len(glob.glob(os.path.join(self.工作目录, "*.dylib"))) +
+                         len(glob.glob(os.path.join(self.工作目录, "*.dll"))),
+                "对象文件": len(glob.glob(os.path.join(self.工作目录, "*.o"))),
+                "临时文件": len(glob.glob(os.path.join(self.工作目录, "*.tmp"))) +
+                          len(glob.glob(os.path.join(self.工作目录, "*.bak")))
+            }
+            状态信息["文件统计"] = 文件统计
+
+        return 状态信息

l0n0lc//346/227/245/345/277/227/345/267/245/345/205/267.py

@@ -0,0 +1,152 @@
+"""
+日志工具模块 - 提供可配置的日志系统
+替代调试代码，提供更专业的日志记录功能
+"""
+
+import logging
+import sys
+from typing import Optional
+from enum import Enum
+
+
+class 日志级别(Enum):
+    """日志级别枚举"""
+    调试 = logging.DEBUG
+    信息 = logging.INFO
+    警告 = logging.WARNING
+    错误 = logging.ERROR
+    严重 = logging.CRITICAL
+
+
+class 日志工具:
+    """统一的日志管理类"""
+    
+    _实例 = None
+    _已初始化 = False
+    
+    def __new__(cls):
+        """单例模式"""
+        if cls._实例 is None:
+            cls._实例 = super().__new__(cls)
+        return cls._实例
+    
+    def __init__(self):
+        if not self._已初始化:
+            self.日志器 = logging.getLogger("l0n0lc")
+            self.日志器.setLevel(logging.INFO)  # 默认级别
+            self.处理器 = None
+            self.调试模式 = False
+            self.已初始化 = True
+    
+    def 设置级别(self, 级别: 日志级别):
+        """设置日志级别"""
+        self.日志器.setLevel(级别.value)
+    
+    def 启用调试模式(self):
+        """启用调试模式"""
+        self.调试模式 = True
+        self.设置级别(日志级别.调试)
+    
+    def 禁用调试模式(self):
+        """禁用调试模式"""
+        self.调试模式 = False
+        self.设置级别(日志级别.信息)
+    
+    def 设置输出格式(self, 格式字符串: Optional[str] = None):
+        """设置日志输出格式"""
+        if 格式字符串 is None:
+            if self.调试模式:
+                格式字符串 = '[%(asctime)s] %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(funcName)s - %(message)s'
+            else:
+                格式字符串 = '[%(levelname)s] %(message)s'
+        
+        formatter = logging.Formatter(格式字符串)
+        
+        if self.处理器:
+            self.处理器.setFormatter(formatter)
+        else:
+            self.处理器 = logging.StreamHandler(sys.stdout)
+            self.处理器.setFormatter(formatter)
+            self.日志器.addHandler(self.处理器)
+    
+    def 调试(self, 消息: str, **kwargs):
+        """记录调试信息"""
+        if self.调试模式:
+            self.日志器.debug(消息, **kwargs)
+    
+    def 信息(self, 消息: str, **kwargs):
+        """记录一般信息"""
+        self.日志器.info(消息, **kwargs)
+    
+    def 警告(self, 消息: str, **kwargs):
+        """记录警告信息"""
+        self.日志器.warning(消息, **kwargs)
+    
+    def 错误(self, 消息: str, **kwargs):
+        """记录错误信息"""
+        self.日志器.error(消息, **kwargs)
+    
+    def 严重(self, 消息: str, **kwargs):
+        """记录严重错误信息"""
+        self.日志器.critical(消息, **kwargs)
+    
+    def 异常(self, 消息: str, 异常对象: Optional[Exception] = None, **kwargs):
+        """记录异常信息"""
+        if 异常对象:
+            self.错误(f"{消息}: {str(异常对象)}", **kwargs)
+            if self.调试模式:
+                self.调试(f"异常详细信息: {type(异常对象).__name__}", **kwargs)
+        else:
+            self.错误(消息, **kwargs)
+    
+    def 编译信息(self, 文件名: str, 操作: str, **kwargs):
+        """记录编译相关信息"""
+        self.信息(f"编译操作 - {操作}: {文件名}", **kwargs)
+    
+    def 类型推断信息(self, 变量名: str, python类型: str, cpp类型: str, **kwargs):
+        """记录类型推断信息"""
+        if self.调试模式:
+            self.调试(f"类型推断 - {变量名}: {python类型} -> {cpp类型}", **kwargs)
+    
+    def 依赖关系信息(self, 主函数: str, 依赖函数: str, **kwargs):
+        """记录依赖关系信息"""
+        if self.调试模式:
+            self.调试(f"依赖关系 - {主函数} 依赖 {依赖函数}", **kwargs)
+    
+    def 性能信息(self, 操作: str, 耗时: float, **kwargs):
+        """记录性能信息"""
+        if self.调试模式:
+            self.信息(f"性能 - {操作}: {耗时:.3f}秒", **kwargs)
+    
+    def 清理信息(self, 文件路径: str, 原因: str = "编译失败", **kwargs):
+        """记录文件清理信息"""
+        if self.调试模式:
+            self.调试(f"文件清理 - {原因}: {文件路径}", **kwargs)
+    
+    def 缓存信息(self, 操作: str, 文件名: str, **kwargs):
+        """记录缓存操作信息"""
+        if self.调试模式:
+            self.调试(f"缓存操作 - {操作}: {文件名}", **kwargs)
+
+
+# 全局日志实例
+日志 = 日志工具()
+
+# 便捷函数
+def 启用调试模式():
+    """全局启用调试模式"""
+    日志.启用调试模式()
+    日志.设置输出格式()
+
+def 禁用调试模式():
+    """全局禁用调试模式"""
+    日志.禁用调试模式()
+    日志.设置输出格式()
+
+def 设置日志级别(级别: 日志级别):
+    """全局设置日志级别"""
+    日志.设置级别(级别)
+    日志.设置输出格式()
+
+# 初始化默认配置
+日志.设置输出格式()