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

l0n0lc//344/276/235/350/265/226/346/263/250/345/205/245.py

@@ -0,0 +1,155 @@
+"""
+依赖注入模块 - 实现依赖注入模式，降低模块间的耦合度
+"""
+
+from typing import Dict, Any, Type, TypeVar, Callable, Optional, Union, cast
+from abc import ABC, abstractmethod
+
+T = TypeVar('T')
+
+
+class 服务容器:
+    """简单的依赖注入容器"""
+    
+    def __init__(self):
+        self._服务: Dict[str, Any] = {}
+        self._工厂: Dict[str, Union[Callable[[], Any], Type[Any], Any]] = {}
+        self._单例: Dict[str, bool] = {}
+    
+    def 注册单例(self, 接口: Type[T], 实现: Type[T]) -> None:
+        """注册单例服务"""
+        接口名 = 接口.__name__
+        self._工厂[接口名] = 实现
+        self._单例[接口名] = True
+    
+    def 注册工厂(self, 接口: Type[T], 工厂: Callable[[], T]) -> None:
+        """注册工厂方法"""
+        接口名 = 接口.__name__
+        self._工厂[接口名] = 工厂
+        self._单例[接口名] = False
+    
+    def 注册实例(self, 接口: Type[T], 实例: T) -> None:
+        """注册实例"""
+        接口名 = 接口.__name__
+        self._服务[接口名] = 实例
+        self._单例[接口名] = True
+    
+    def 解析(self, 接口: Type[T]) -> T:
+        """解析服务"""
+        接口名 = 接口.__name__
+        
+        # 如果已有实例且为单例，直接返回
+        if 接口名 in self._服务 and self._单例.get(接口名, False):
+            return cast(T, self._服务[接口名])
+        
+        # 创建新实例
+        if 接口名 in self._工厂:
+            if callable(self._工厂[接口名]):
+                实例 = self._工厂[接口名]()
+            else:
+                实例 = self._工厂[接口名]
+            
+            if self._单例.get(接口名, False):
+                self._服务[接口名] = 实例
+            
+            return cast(T, 实例)
+        
+        raise ValueError(f"未注册的服务: {接口名}")
+    
+    def 清理(self) -> None:
+        """清理容器"""
+        self._服务.clear()
+        self._工厂.clear()
+        self._单例.clear()
+
+
+# 全局服务容器
+全局容器 = 服务容器()
+
+
+class 转译器组件接口(ABC):
+    """转译器组件的抽象基类"""
+    
+    @abstractmethod
+    def 初始化(self, 转译器) -> None:
+        """初始化组件"""
+        pass
+    
+    @abstractmethod
+    def 清理(self) -> None:
+        """清理组件资源"""
+        pass
+
+
+class 代码生成接口(ABC):
+    """代码生成接口"""
+    
+    @abstractmethod
+    def 生成代码(self) -> str:
+        """生成代码"""
+        pass
+    
+    @abstractmethod
+    def 保存代码(self, 文件路径: str) -> None:
+        """保存代码到文件"""
+        pass
+
+
+class 类型推断接口(ABC):
+    """类型推断接口"""
+    
+    @abstractmethod
+    def 推断类型(self, 节点) -> str:
+        """推断类型"""
+        pass
+    
+    @abstractmethod
+    def 验证类型(self, 类型1: str, 类型2: str) -> bool:
+        """验证类型兼容性"""
+        pass
+
+
+class 编译管理接口(ABC):
+    """编译管理接口"""
+    
+    @abstractmethod
+    def 编译(self, 源文件: str, 输出文件: str) -> bool:
+        """编译文件"""
+        pass
+    
+    @abstractmethod
+    def 清理临时文件(self) -> None:
+        """清理临时文件"""
+        pass
+
+
+class 依赖解析接口(ABC):
+    """依赖解析接口"""
+    
+    @abstractmethod
+    def 解析依赖(self, 函数) -> list:
+        """解析函数依赖"""
+        pass
+    
+    @abstractmethod
+    def 排序依赖(self, 依赖列表: list) -> list:
+        """对依赖进行拓扑排序"""
+        pass
+
+
+def 注册服务(接口: Type[T], 实现: Type[T], 单例: bool = True) -> None:
+    """便捷的服务注册函数"""
+    if 单例:
+        全局容器.注册单例(接口, 实现)
+    else:
+        全局容器.注册工厂(接口, 实现)
+
+
+def 解析服务(接口: Type[T]) -> T:
+    """便捷的服务解析函数"""
+    return 全局容器.解析(接口)
+
+
+def 清理容器() -> None:
+    """清理全局容器"""
+    全局容器.清理()

l0n0lc//345/215/263/346/227/266/347/274/226/350/257/221.py

@@ -0,0 +1,192 @@
+
+import os
+import inspect
+from typing import Callable, Optional
+from .Py转Cpp转译器 import Py转Cpp转译器
+from .cpp编译器 import Cpp编译器
+from .工具 import 全局上下文
+from .日志工具 import 日志
+
+
+def _从环境变量获取LTO设置() -> bool:
+    """
+    从环境变量获取 LTO 设置
+
+    环境变量 L0N0LC_ENABLE_LTO:
+    - "1", "true", "True", "TRUE" -> 启用 LTO
+    - "0", "false", "False", "FALSE" 或未设置 -> 禁用 LTO
+
+    Returns:
+        是否启用 LTO
+    """
+    环境变量值 = os.environ.get('L0N0LC_ENABLE_LTO', '').strip()
+    if 环境变量值:
+        return 环境变量值.lower() in ('1', 'true')
+    return False
+
+
+def _从环境变量获取向量化设置() -> bool:
+    """
+    从环境变量获取向量化设置
+
+    环境变量 L0N0LC_ENABLE_VECTORIZE:
+    - "1", "true", "True", "TRUE" -> 启用向量化
+    - "0", "false", "False", "FALSE" 或未设置 -> 禁用向量化
+
+    Returns:
+        是否启用向量化
+    """
+    环境变量值 = os.environ.get('L0N0LC_ENABLE_VECTORIZE', '').strip()
+    if 环境变量值:
+        return 环境变量值.lower() in ('1', 'true')
+    return False
+
+
+def 即时编译(
+    转译器类=None,
+    编译器类=None,
+    总是重编: bool = False,
+    可执行文件名: Optional[str] = None,
+    优化级别: str = 'O2',
+    启用并行编译: bool = True,
+    最大进程数: Optional[int] = None,
+    启用LTO: Optional[bool] = None,
+    启用向量化: Optional[bool] = None,
+    SIMD指令集: Optional[str] = None,
+    启用代码优化: bool = True
+):
+    """
+    JIT (即时编译) 装饰器。
+
+    能够将受支持的 Python 函数转换为 C++ 代码，编译为动态库并加载执行。
+    大大提高计算密集型任务的性能。
+
+    注意：编译延迟到函数首次调用时才执行（可执行文件除外）。
+
+    Args:
+        转译器类: 自定义转译器类 (可选)
+        编译器类: 自定义编译器类 (可选)
+        总是重编: 是否每次运行都强制重新编译 (默认为 False，利用缓存)
+        可执行文件名: 如果指定，将编译为独立的可执行文件而不是动态库
+        优化级别: 编译优化级别，默认为 'O2'
+            - O0: 无优化，编译最快，运行最慢
+            - O1: 基础优化
+            - O2: 标准优化（默认）
+            - O3: 最大优化，编译较慢，运行最快
+            - Os: 优化代码大小
+            - Ofast: 激进优化（可能破坏标准合规）
+            - Og: 调试优化
+            - Oz: 最小代码大小
+        启用并行编译: 是否启用并行编译依赖函数（默认为 True）
+        最大进程数: 并行编译的最大进程数（None 表示自动检测 CPU 核心数）
+        启用LTO: 是否启用链接时优化（LTO），默认为 None（自动检测环境变量）
+            - None: 检查环境变量 L0N0LC_ENABLE_LTO
+            - True: 强制启用 LTO
+            - False: 强制禁用 LTO
+            LTO 可以提升运行时性能 10-30%，但会增加编译时间
+        启用向量化: 是否启用 SIMD 向量化优化，默认为 None（自动检测环境变量）
+            - None: 检查环境变量 L0N0LC_ENABLE_VECTORIZE
+            - True: 强制启用向量化
+            - False: 强制禁用向量化
+            向量化可以提升数组操作性能 2-8x，适用于计算密集型循环
+        SIMD指令集: 指定 SIMD 指令集，None 表示自动检测
+            可选值: SSE2, SSE4_2, AVX, AVX2, AVX512F, NEON
+        启用代码优化: 是否启用代码优化（默认为 True）
+            - 常量折叠：编译时计算常量表达式
+            - 死代码消除：移除永远不会执行的代码
+            - 循环优化：使用范围循环替代索引循环
+            可以提升运行时性能 20-50%，代码体积减少 10-30%
+
+    Examples:
+        >>> @jit()
+        >>> def func(x: int) -> int:
+        >>>     return x * 2
+
+        >>> @jit(优化级别='O3')
+        >>> def performance_critical(x: int) -> int:
+        >>>     return x ** 2
+
+        >>> @jit(优化级别='O0')
+        >>> def fast_compile(x: int) -> int:
+        >>>     return x + 1
+
+        >>> @jit(启用并行编译=False)  # 禁用并行编译
+        >>> def serial_compile(x: int) -> int:
+        >>>     return x + 1
+
+        >>> @jit(最大进程数=2)  # 限制最多使用 2 个进程
+        >>> def limited_parallel(x: int) -> int:
+        >>>     return x * 2
+
+        >>> @jit(启用LTO=True)  # 启用链接时优化
+        >>> def lto_func(x: int) -> int:
+        >>>     return x * x
+
+        >>> @jit(启用向量化=True)  # 启用 SIMD 向量化
+        >>> def vectorized_func(arr: List[int]) -> int:
+        >>>     total = 0
+        >>>     for x in arr:
+        >>>         total += x
+        >>>     return total
+    """
+    def 装饰器(fn: Callable):
+        # 输入验证
+        if not callable(fn):
+            raise TypeError(
+                f"@jit 装饰器只能用于函数或类，得到: {type(fn).__name__}\n"
+                f"请确保 @jit 装饰器应用在函数定义上，例如：\n"
+                f"  @jit()\n"
+                f"  def my_function():\n"
+                f"      pass"
+            )
+
+        # 检查是否为异步函数
+        if inspect.iscoroutinefunction(fn):
+            raise NotImplementedError("暂不支持异步函数 (async/await)，请使用同步函数")
+
+        _编译器类 = 编译器类 or Cpp编译器
+        _转译器类 = 转译器类 or Py转Cpp转译器
+
+        # 确定 LTO 设置（优先使用参数，其次使用环境变量）
+        实际LTO设置: bool
+        if 启用LTO is None:
+            实际LTO设置 = _从环境变量获取LTO设置()
+        else:
+            实际LTO设置 = 启用LTO
+
+        # 确定向量化设置（优先使用参数，其次使用环境变量）
+        实际向量化设置: bool
+        if 启用向量化 is None:
+            实际向量化设置 = _从环境变量获取向量化设置()
+        else:
+            实际向量化设置 = 启用向量化
+
+        # 创建编译器实例，传入所有优化参数
+        编译器实例 = _编译器类(
+            优化级别=优化级别,
+            启用LTO=实际LTO设置,
+            启用向量化=实际向量化设置,
+            SIMD指令集=SIMD指令集
+        )
+
+        # 创建转译器实例，传递参数（包括并行编译参数和代码优化参数）
+        转译器实例 = _转译器类(fn, 编译器实例, 可执行文件名, 总是重编, 启用并行编译, 最大进程数, 启用代码优化)
+
+        # 可执行文件需要立即编译
+        if 可执行文件名 is not None:
+            库文件名 = 转译器实例.获取库文件名()
+            库路径 = f'{全局上下文.工作目录}/{库文件名}'
+
+            if 总是重编 or not os.path.exists(库路径):
+                日志.缓存信息("编译", fn.__name__ if hasattr(fn, '__name__') else "unknown")
+                转译器实例.编译()
+
+        # 将转译器对象添加到目标函数的全局变量中，以便其他JIT函数可以调用它
+        if hasattr(fn, '__name__'):
+            转译器实例.全局变量[fn.__name__] = 转译器实例
+
+        return 转译器实例
+    return 装饰器
+
+
+jit = 即时编译

l0n0lc//345/217/230/351/207/217/347/256/241/347/220/206/345/231/250.py

@@ -0,0 +1,123 @@
+"""
+变量管理器模块
+
+负责管理变量作用域、变量查找和变量注册。
+从 Py转Cpp转译器 中分离出来，实现单一职责原则。
+"""
+
+from typing import Optional, Any, Dict, List
+from .cpp类型 import C变量
+
+
+class 变量管理器:
+    """
+    变量管理器
+
+    负责：
+    - 管理变量作用域栈
+    - 查找变量
+    - 注册变量
+    """
+
+    def __init__(self):
+        """初始化变量管理器"""
+        # 变量作用域栈，每个元素是一个字典 {变量名: C变量}
+        self.作用域变量: List[Dict[str, C变量]] = [{}]
+        self.当前作用域层级 = 0
+
+    def 进入作用域(self):
+        """
+        进入新的作用域（如 if/for 块内部）
+
+        创建一个新的空字典用于存储当前作用域的变量。
+        """
+        self.作用域变量.append({})
+        self.当前作用域层级 += 1
+
+    def 退出作用域(self):
+        """
+        退出当前作用域
+
+        弹出当前作用域的变量字典，返回到上一层作用域。
+        """
+        if self.当前作用域层级 > 0:
+            self.作用域变量.pop()
+            self.当前作用域层级 -= 1
+
+    def 获取C变量(self, name: str) -> Optional[C变量]:
+        """
+        从当前及上层作用域查找 C 变量
+
+        Args:
+            name: 变量名
+
+        Returns:
+            找到的 C 变量，如果未找到返回 None
+        """
+        # 从当前作用域向上查找
+        for i in range(self.当前作用域层级, -1, -1):
+            v = self.作用域变量[i].get(name)
+            if v is not None:
+                return v
+        return None
+
+    def 添加C变量(self, variable: C变量):
+        """
+        在当前作用域注册 C 变量
+
+        Args:
+            variable: 要注册的 C 变量
+        """
+        self.作用域变量[self.当前作用域层级][variable.名称] = variable
+
+    def 变量是否存在(self, name: str) -> bool:
+        """
+        检查变量是否存在于任何作用域
+
+        Args:
+            name: 变量名
+
+        Returns:
+            变量是否存在
+        """
+        return self.获取C变量(name) is not None
+
+    def 获取当前作用域变量数(self) -> int:
+        """
+        获取当前作用域的变量数量
+
+        Returns:
+            当前作用域的变量数量
+        """
+        return len(self.作用域变量[self.当前作用域层级])
+
+    def 获取所有作用域变量数(self) -> int:
+        """
+        获取所有作用域的变量总数
+
+        Returns:
+            所有作用域的变量总数
+        """
+        total = 0
+        for scope in self.作用域变量:
+            total += len(scope)
+        return total
+
+    def 清空所有作用域(self):
+        """清空所有作用域，重置为初始状态"""
+        self.作用域变量 = [{}]
+        self.当前作用域层级 = 0
+
+    def 获取状态摘要(self) -> Dict[str, Any]:
+        """
+        获取变量管理器的状态摘要
+
+        Returns:
+            包含当前状态的字典
+        """
+        return {
+            "当前作用域层级": self.当前作用域层级,
+            "作用域总数": len(self.作用域变量),
+            "当前作用域变量数": self.获取当前作用域变量数(),
+            "总变量数": self.获取所有作用域变量数(),
+        }

l0n0lc//345/237/272/347/241/200/346/230/240/345/260/204.py

@@ -0,0 +1,103 @@
+from .工具 import 映射类型
+import ctypes
+from typing import SupportsIndex
+from .cpp类型 import *
+
+class _数值类型基类(SupportsIndex):
+    """数值类型基类，提供通用的运算符支持"""
+
+    def __init__(self, value):
+        pass
+        
+    def __index__(self) -> int:
+        return 0
+
+    # 基本运算
+    def __add__(self, other): return self
+    def __sub__(self, other): return self
+    def __mul__(self, other): return self
+    def __truediv__(self, other): return self
+    def __floordiv__(self, other): return self
+    def __mod__(self, other): return self
+    def __pow__(self, other): return self
+    def __neg__(self): return self
+    def __abs__(self): return self
+    
+    # 比较运算
+    def __eq__(self, other): return self
+    def __ne__(self, other): return self
+    def __lt__(self, other): return self
+    def __le__(self, other): return self
+    def __gt__(self, other): return self
+    def __ge__(self, other): return self
+
+    # 反向运算符（支持左操作数为普通数值的情况）
+    def __radd__(self, other): return self
+    def __rsub__(self, other): return self
+    def __rmul__(self, other): return self
+    def __rtruediv__(self, other): return self
+    def __rfloordiv__(self, other): return self
+    def __rmod__(self, other): return self
+    def __rpow__(self, other): return self
+
+    # 类型转换
+    def __int__(self): return int(0)
+    def __float__(self): return float(0)
+
+
+# 设置全局变量
+int映射目标 = Cpp类型.INT64_T
+float映射目标 = Cpp类型.FLOAT64
+
+# 基础类型映射
+映射类型(Cpp类型.StdString, ['<string>'])(str)
+映射类型(Cpp类型.StdString, ['<string>'])(CString常量)
+映射类型(Cpp类型.字符串, ctypes类型=ctypes.c_char_p)(bytes)
+映射类型(Cpp类型.字符串, ctypes类型=ctypes.c_char_p)(CBytes常量)
+映射类型(Cpp类型.INT64_T, ctypes类型=ctypes.c_int64)(int)
+映射类型(Cpp类型.INT64_T, ctypes类型=ctypes.c_int64)(CInt常量)
+映射类型(Cpp类型.FLOAT64, ctypes类型=ctypes.c_double)(float)
+映射类型(Cpp类型.FLOAT64, ctypes类型=ctypes.c_double)(CFloat常量)
+映射类型(Cpp类型.布尔, ctypes类型=ctypes.c_bool)(bool)
+映射类型(Cpp类型.布尔, ctypes类型=ctypes.c_bool)(C布尔)
+
+# 数值类型映射
+@映射类型(Cpp类型.INT8_T, ctypes类型=ctypes.c_int8)
+class int8(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.INT16_T, ctypes类型=ctypes.c_int16)
+class int16(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.INT32_T, ctypes类型=ctypes.c_int32)
+class int32(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.INT64_T, ctypes类型=ctypes.c_int64)
+class int64(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.UINT8_T, ctypes类型=ctypes.c_uint8)
+class uint8(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.UINT16_T, ctypes类型=ctypes.c_uint16)
+class uint16(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.UINT32_T, ctypes类型=ctypes.c_uint32)
+class uint32(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.UINT64_T, ctypes类型=ctypes.c_uint64)
+class uint64(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.FLOAT32, ctypes类型=ctypes.c_float)
+class float32(_数值类型基类):
+    pass
+
+@映射类型(Cpp类型.FLOAT64, ctypes类型=ctypes.c_double)
+class float64(_数值类型基类):
+    pass