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

l0n0lc-1.0.0.dist-info/METADATA

@@ -0,0 +1,363 @@
+Metadata-Version: 2.4
+Name: l0n0lc
+Version: 1.0.0
+Summary: 一个将python函数翻译为c++函数并运行的jit编译器
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# l0n0lc
+
+<div align="center">
+
+**将 Python 函数翻译为 C++ 并运行的 JIT 编译器**
+
+[![Python Version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://python.org)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Version](https://img.shields.io/badge/version-1.0.0-orange.svg)](pyproject.toml)
+[![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen.svg)](pyproject.toml)
+
+</div>
+
+---
+
+## 简介
+
+l0n0lc 是一个零外部依赖的 Python JIT 编译器，通过简单的装饰器将 Python 函数转换为原生 C++ 代码并编译执行。它专注于计算密集型任务的性能优化，同时保持 API 的简洁性和易用性。
+
+### 核心特点
+
+- **零依赖** - 仅依赖 Python 3.10+ 标准库
+- **简单易用** - 一个 `@jit` 装饰器即可启用
+- **智能缓存** - 基于源码哈希，自动避免重复编译
+- **跨平台** - 支持 Linux、macOS、Windows
+- **类型推断** - 自动推断变量类型，生成高效 C++ 代码
+
+---
+
+## 安装
+
+```bash
+pip install l0n0lc
+```
+
+### 系统要求
+
+- Python 3.10 或更高版本
+- C++ 编译器（g++、clang++ 或 c++）
+
+```bash
+# Ubuntu/Debian
+sudo apt install g++
+
+# macOS
+xcode-select --install
+
+# Windows (MSYS2)
+pacman -S mingw-w64-x86_64-gcc
+```
+
+---
+
+## 快速开始
+
+### 基础用法
+
+```python
+from l0n0lc import jit
+
+@jit()
+def fibonacci(n: int) -> int:
+    if n <= 1:
+        return n
+    a, b = 0, 1
+    for _ in range(2, n + 1):
+        a, b = b, a + b
+    return b
+
+print(fibonacci(40))  # 输出: 102334155
+```
+
+### 容器类型支持
+
+```python
+from typing import List
+
+@jit()
+def sum_list(nums: List[int]) -> int:
+    total = 0
+    for num in nums:
+        total += num
+    return total
+
+print(sum_list([1, 2, 3, 4, 5]))  # 输出: 15
+```
+
+### 类支持
+
+```python
+# 定义类（类本身不需要 jit 装饰器）
+class Point:
+    x: float
+    y: float
+
+    def __init__(self, x: float, y: float):
+        self.x = x
+        self.y = y
+
+@jit()
+def compute_distance() -> float:
+    # 在 JIT 函数内部创建和使用类实例
+    p1 = Point(0.0, 0.0)
+    p2 = Point(3.0, 4.0)
+    dx = p1.x - p2.x
+    dy = p1.y - p2.y
+    return (dx * dx + dy * dy) ** 0.5
+
+print(compute_distance())  # 输出: 25.0 (平方距离)
+```
+
+---
+
+## API 参考
+
+### @jit 装饰器
+
+```python
+@jit(
+    总是重编=False,        # 强制重新编译
+    可执行文件名=None,     # 编译为独立可执行文件
+    优化级别="-O3",        # C++ 优化级别
+    启用_lto=False,        # 启用链接时优化
+    启用_simd=False,       # 启用 SIMD 优化
+)
+def function_name() -> ReturnType:
+    ...
+```
+
+### 中文别名
+
+```python
+from l0n0lc import jit, 即时编译
+
+# 两者等价
+@jit()
+def func1(): pass
+
+@即时编译()
+def func2(): pass
+```
+
+---
+
+## 高级功能
+
+### AOT 编译
+
+```bash
+# 将 Python 文件编译为独立可执行文件
+l0n0lc-aot-compile input.py -o output_executable
+```
+
+### 自定义 C++ 映射
+
+```python
+import l0n0lc as lc
+
+# 映射到 C++ 标准库函数
+@lc.映射函数到('sqrt({x})', ['<cmath>'])
+def my_sqrt(x: float) -> float:
+    return 0  # 实际使用 C++ 实现
+```
+
+### 性能优化选项
+
+```python
+# 启用 LTO 优化
+@jit(启用_lto=True)
+def optimized_function():
+    pass
+
+# 启用 SIMD
+@jit(启用_simd=True)
+def vectorized_compute(data: List[float]) -> List[float]:
+    pass
+```
+
+---
+
+## 工作原理
+
+```
+Python 函数
+    ↓
+AST 解析与类型推断
+    ↓
+C++ 代码生成
+    ↓
+系统 C++ 编译器
+    ↓
+动态库 (.so/.dll/.dylib)
+    ↓
+ctypes 加载执行
+```
+
+---
+
+## 性能对比
+
+```python
+import time
+from l0n0lc import jit
+
+def fib_py(n: int) -> int:
+    if n <= 1:
+        return n
+    return fib_py(n-1) + fib_py(n-2)
+
+@jit()
+def fib_jit(n: int) -> int:
+    if n <= 1:
+        return n
+    return fib_jit(n-1) + fib_jit(n-2)
+
+# 测试
+n = 35
+
+t = time.time()
+fib_py(n)
+py_time = time.time() - t
+
+t = time.time()
+fib_jit(n)
+jit_time = time.time() - t
+
+print(f"Python: {py_time:.3f}s")
+print(f"JIT:    {jit_time:.3f}s")
+print(f"加速比: {py_time/jit_time:.1f}x")
+```
+
+---
+
+## 支持的语言特性
+
+| 特性 | 支持情况 |
+|------|----------|
+| 基本类型 (int, float, bool, str) | ✅ |
+| 容器类型 (List, Dict, Set) | ✅ |
+| 类定义和实例方法 | ✅ |
+| for/while 循环 | ✅ |
+| if/else 条件 | ✅ |
+| try/except 异常处理 | ✅ |
+| 列表推导式 | ✅ |
+| 可变参数 (*args, **kwargs) | ❌ |
+| 生成器 | ❌ |
+| 异步函数 | ❌ |
+
+---
+
+## 开发
+
+### 从源码构建
+
+```bash
+git clone https://github.com/username/l0n0lc.git
+cd l0n0lc
+pip install -e .
+```
+
+### 运行测试
+
+```bash
+cd tests
+for test in test_*.py; do
+    echo "Running $test"
+    python "$test"
+done
+```
+
+### 构建发布包
+
+```bash
+# 使用 uv 构建
+uv build
+
+# 或使用构建脚本
+./build.sh
+```
+
+---
+
+## 缓存机制
+
+编译产物存储在 `l0n0lcoutput/` 目录：
+
+```
+l0n0lcoutput/
+├── {hash}_{filename}_{funcname}@_{hash}.cpp  # C++ 源码
+├── {hash}_{filename}_{funcname}@_{hash}.h    # 头文件
+└── {hash}_{filename}_{funcname}@_{hash}.so   # 动态库
+```
+
+缓存基于函数源码的 BLAKE2s 哈希，代码修改后自动重新编译。
+
+### 清理缓存
+
+```bash
+# 清理所有缓存
+rm -rf l0n0lcoutput/
+
+# 清理构建产物
+./build.sh  # 自动清理并重新构建
+```
+
+---
+
+## 项目结构
+
+```
+l0n0lc/
+├── 即时编译.py          # @jit 装饰器
+├── Py转Cpp转译器.py     # AST 转 C++ 核心逻辑
+├── cpp编译器.py         # C++ 编译器管理
+├── 运行时加载.py        # ctypes 加载
+├── cpp类型.py           # C++ 类型定义
+├── 类型转换.py          # Python ↔ C++ 类型转换
+├── std_vector.py        # std::vector 支持
+├── std_map.py           # std::map 支持
+├── std_set.py           # std::set 支持
+├── aot编译.py           # AOT 编译
+├── simd优化.py          # SIMD 优化
+├── 并行编译器.py        # 并行编译
+└── ...
+```
+
+---
+
+## 限制与注意事项
+
+1. **类型注解** - 建议提供完整的类型注解以提高代码质量
+2. **首次编译** - 首次调用会有编译延迟，后续调用使用缓存
+3. **适用场景** - 适合计算密集型任务，简单函数可能因编译开销反而变慢
+4. **函数名编码** - 包含非 ASCII 字符的函数名会被编码
+
+---
+
+## 许可证
+
+[MIT License](LICENSE)
+
+---
+
+## 作者
+
+倾城铸剑师
+
+---
+
+## 文档
+
+- [CLAUDE.md](CLAUDE.md) - 开发者文档
+- [tests/](tests/) - 测试用例和示例

l0n0lc-1.0.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+l0n0lc/Py转Cpp转译器.py,sha256=l60o45f-CM3oloTTLawAHh_It0BjmgKVwBcI5C6Qoek,25781
+l0n0lc/__init__.py,sha256=ASRJnSQn5a3oFEksFBzdAh2u7s0LTjz5qDBGGHU7lvQ,1822
+l0n0lc/aot编译.py,sha256=tU801fcisn5F0v_FshjjFV1jcBJK8vsZkMo3NFvr5Hg,22003
+l0n0lc/ast访问者.py,sha256=QamOTOI6morgU6WPDQWSpFQCPbM8B_s4zHIJVuAmvoo,25661
+l0n0lc/cpp类型.py,sha256=zL0imonIuP53Bt0dcWy8H-MaTEJ5B0OLlVu1nnFusO0,9614
+l0n0lc/cpp编译器.py,sha256=BaqEqWNMQ9zjZ9Y7Kccx8HhZMubuTPiDj83vBEKLXsg,11180
+l0n0lc/simd优化.py,sha256=PAu88gHVPYiyFHD9nL4mGT4kBKs7aOMFrnYRWn8MeZM,8576
+l0n0lc/std_map.py,sha256=4KDcIczA03M758t1nrQzHLa-Y0aDYaFaGWNX4odUfVc,5235
+l0n0lc/std_set.py,sha256=12kiT3cYSlTEXNn1M5Cv2QYOPN_XTOO2jkCfkFI-ATM,5594
+l0n0lc/std_vector.py,sha256=MyjmQtWm1I0hUYgSGH5olmOUrlC-jdGIvjNi-rUxG_A,3449
+l0n0lc/代码优化.py,sha256=ij2xKXaKnTraqCxyRg6z4Hp7cMvd1UWMxOEduXSeADA,10311
+l0n0lc/代码生成.py,sha256=6CzOo_qBRPPnCH_865TEfQ-uKemJTAzd-624bUusa3g,23861
+l0n0lc/依赖注入.py,sha256=NzuHJm-H3gEqo2wvj9iflB5NjtyYnsbF9_i-Fexgsuc,4075
+l0n0lc/即时编译.py,sha256=6PBDtQbyC-8-ZKmWdw5UjyKmBvtkDrFRawbbteGp3RY,7420
+l0n0lc/变量管理器.py,sha256=Gj3fCrBussjVIamAEoRwup5pzw73RVD5Cm6vfzHj5Ko,3402
+l0n0lc/基础映射.py,sha256=2xiPNOpZrTg1H9S8n1fMnBBol4gHcVm43xXvlF3VXzo,3347
+l0n0lc/基础混入.py,sha256=O49XZcyIQK7XgA1lrpC7MkRsmFyE8qnhKO9LWTy67VQ,4345
+l0n0lc/容器构建器.py,sha256=3_JeYVCcxns6mv7FErVd-p8GszGDPmjKdgBsNF24S9M,7525
+l0n0lc/工具.py,sha256=O2FKVsiP6f0aP2utyto9n-6omnP_XN4omnY_3__3Hh0,9478
+l0n0lc/并行编译器.py,sha256=8B4jjor7idNdm9HUITAD3BWBWzb-R251VnVfnUfwApM,12982
+l0n0lc/异常.py,sha256=eZZFdeY7nNiawmlF8aQ_FEEHQBB6bedRiE1Ah6nZ0hg,15766
+l0n0lc/数组对象池.py,sha256=rt1SU8G2izXDRJfdmF5IeaDCLsbK_v0O-B_RbIcReGM,7119
+l0n0lc/文件管理器.py,sha256=xBKI71X0ZGQVdDUqN3s_R-JNUqX3yQaiS092nInP8GA,8531
+l0n0lc/日志工具.py,sha256=yEXoyxljokVSzag7A7jYdiHaFDrOpjV0worQHMwktmU,5081
+l0n0lc/类型推断工具.py,sha256=rWpY60dp6dELDDNMlMC6gjrtdxXMQeFqvthuYdeTxrM,12597
+l0n0lc/类型转换.py,sha256=LW8Adh689HpKpC53P_4M-9Ip41ujHGBSVeZY5hC83ro,7892
+l0n0lc/类支持.py,sha256=sranCRrZDogZpMKLp5So-hjy1KGG5CddziBw9A1O9gA,15435
+l0n0lc/编译上下文.py,sha256=aadn7UHesoy9TUHXGrKf5rJAUAEfGG_kUyMRrwfthkc,3585
+l0n0lc/编译管理器.py,sha256=MoV_ABlW2tJ9MLyqbODaIss5jF2ySfWo0axF3hLoHBo,5493
+l0n0lc/表达式处理.py,sha256=y7zqNSyYvTsIUgeOoGILKISLqsV6qz7wkN5rre7LG6A,20163
+l0n0lc/转译器工具.py,sha256=okgsrhMEq3ucYuWVStv1kBVgH9QrwxQsYpwYBHt6XXk,1429
+l0n0lc/运行时加载.py,sha256=t-P9jZj8ShRImOiGE-v64rfw6Mte2m4zqyx2VUzBwkM,8684
+l0n0lc/通用工具.py,sha256=3FDv6aLVqxVmzZNSUACpubM9A7sjigfulqJJ1-YEaaA,4148
+l0n0lc-1.0.0.dist-info/licenses/LICENSE,sha256=1L-MAjulZ3kpbYwsJtlXpDVITRxykna2Ecg_521YfkA,1093
+l0n0lc-1.0.0.dist-info/METADATA,sha256=E50BmlQ71-CUV8HafPfv_MowYUzcKexyhqlAmHoeiWM,6846
+l0n0lc-1.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+l0n0lc-1.0.0.dist-info/entry_points.txt,sha256=u1ynz2q2r-oPTc8k0uthgRqbxuyQ_DN5pkEigeKJvHw,61
+l0n0lc-1.0.0.dist-info/top_level.txt,sha256=Q21D_eEY_-xgRUPwATGp9YDKSBO4w_7MI2MYxQI1aT4,7
+l0n0lc-1.0.0.dist-info/RECORD,,

{l0n0lc-0.8.4.dist-info → l0n0lc-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

l0n0lc-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+l0n0lc-aot-compile = l0n0lc.aot编译:main

l0n0lc/StdList.py

@@ -1,24 +0,0 @@
-from .c基础处理 import c变量, cpp类型, list初始化列表
-
-
-class StdList(c变量):
-    def __init__(
-            self,
-            初始化列表: list初始化列表,
-            名字: str, 是参数: bool) -> None:
-        self.初始化列表 = 初始化列表
-        if 初始化列表.类型 == cpp类型.ANY:
-            super().__init__(f'std::vector<{初始化列表.类型}>', 名字, 是参数)
-        else:
-            super().__init__(f'{初始化列表.类型}', 名字, 是参数)
-
-    def __getitem__(self, key):
-        return f'{self}[{key}]'
-
-    def __setitem__(self, key, value):
-        return f'{self}[{key}] = {value};'
-
-    def 初始化(self, 初始值):
-        if self.初始化列表.类型 == cpp类型.ANY:
-            return super().初始化(初始值)
-        return f'{self.类型} {self.名字}[] = {初始值};'

l0n0lc/StdMap.py

@@ -1,21 +0,0 @@
-from .c基础处理 import py类型转c类型, dict初始化列表, c变量, cpp类型
-from typing import Tuple, Union, List
-from .通用 import toCString
-
-
-class StdUnorderedMap(c变量):
-    def __init__(
-            self,
-            初始化列表: dict初始化列表,
-            名字: str, 是参数: bool) -> None:
-        self.初始化列表 = 初始化列表
-        super().__init__(
-            f'std::unordered_map<{初始化列表.key类型}, {初始化列表.value类型}>', 名字, 是参数)
-
-    def __getitem__(self, key):
-        return f'{self}[{toCString(key)}]'
-
-    def __setitem__(self, key, value):
-        左 = f'{self}[{toCString(key)}]'
-        右 = toCString(value)
-        return f'{左} = {右};'

l0n0lc/c/345/237/272/347/241/200/345/244/204/347/220/206.py

@@ -1,207 +0,0 @@
-from typing import Union, List, get_origin, get_args
-from .通用 import 生成变量Id, toCString
-import ctypes
-
-
-def cpp获取变量类型(v):
-    return f'decltype({v})'
-
-
-class cpp类型:
-    INT8_T = 'int8_t'
-    INT16_T = 'int16_t'
-    INT32_T = 'int32_t'
-    INT64_T = 'int64_t'
-    UINT8_T = 'uint8_t'
-    UINT16_T = 'uint16_t'
-    UINT32_T = 'uint32_t'
-    UINT64_T = 'uint64_t'
-    HALF = 'half'
-    FLOAT = 'float'
-    STRING = 'std::string'
-    BOOL = 'bool'
-    ANY = 'std::any'
-    AUTO = 'auto'
-    VOID_P = 'void*'
-
-
-class 指针:
-    def __init__(self, 类型) -> None:
-        self.基础类型 = 类型
-
-    def __str__(self) -> str:
-        return f'{self.基础类型}*'
-
-
-def 执行额外函数(函数列表: List, *args):
-    for fn in 函数列表:
-        ret = fn(*args)
-        if ret is not None:
-            return ret
-
-
-额外py转ctypes函数 = []
-
-
-def py类型转ctypes类型(类型):
-    ret = 执行额外函数(额外py转ctypes函数, 类型)
-    if ret is not None:
-        return ret
-
-    # 基础类型
-    if 类型 is int:
-        return ctypes.c_int64
-    if 类型 is float:
-        return ctypes.c_float
-    if 类型 is str:
-        return ctypes.c_char_p
-    if 类型 is bool:
-        return ctypes.c_bool
-    if 类型 is 指针:
-        return ctypes.c_void_p
-
-额外py转c函数 = []
-
-
-def py类型转c类型(类型):
-    ret = 执行额外函数(额外py转c函数, 类型)
-    if ret is not None:
-        return ret
-
-    # 基础类型
-    if 类型 is int:
-        return cpp类型.INT64_T
-    if 类型 is float:
-        return cpp类型.FLOAT
-    if 类型 is str:
-        return cpp类型.STRING
-    if 类型 is bool:
-        return cpp类型.BOOL
-    if 类型 is 指针:
-        return cpp类型.VOID_P
-
-    origin = get_origin(类型)
-    args = get_args(类型)
-
-    if origin is Union:
-        return cpp类型.ANY
-
-    # List[...] → 指针(...)
-    if origin is list:
-        if args:
-            elem_type = args[0]
-            return 指针(py类型转c类型(elem_type))
-
-    # Dict[K, V] → std::unordered_map<K, V>
-    if origin is dict:
-        if len(args) == 2:
-            key_type = py类型转c类型(args[0])
-            val_type = py类型转c类型(args[1])
-            return f"std::unordered_map<{key_type}, {val_type}>&"
-
-    # 直接传字符串类型名
-    if isinstance(类型, str):
-        return 类型
-
-    return cpp类型.ANY
-
-def cpp类型检查(类型, 支持提示: str):
-    if 类型 not in [int, float, str, bool]:
-        raise Exception(f'{支持提示} 仅支持 [int, float, str, bool]')
-
-
-class list初始化列表:
-    def __init__(
-            self,
-            代码: str,
-            类型列表: Union[List[Union[int, float, bool, str]],
-                        int, float, bool, str],
-            长度: int) -> None:
-        self.代码 = 代码
-        self.类型列表 = 类型列表
-        self.类型 = py类型转c类型(类型列表)
-        self.长度 = 长度
-
-    def __str__(self) -> str:
-        return self.代码
-
-
-def 从list构建初始化列表(value: List):
-    数据类型列表 = []
-    初始化列表 = []
-    for v in value:
-        dtype = type(v)
-        cpp类型检查(dtype, 'List')
-        数据类型列表.append(dtype)
-        初始化列表.append(toCString(v))
-    # 构建初始化列表
-    初始化列表 = '{' + ','.join(初始化列表) + '}'
-
-    # 构建类型列表
-    if all(类型 == 数据类型列表[0] for 类型 in 数据类型列表):
-        数据类型列表 = 数据类型列表[0]
-
-    return list初始化列表(初始化列表, 数据类型列表, len(value))
-
-
-class dict初始化列表:
-    def __init__(
-            self,
-            代码: str,
-            key类型列表: Union[List[Union[int, float, bool, str]],
-                           int, float, bool, str],
-            value类型列表: Union[List[Union[int, float, bool, str]],
-                             int, float, bool, str]) -> None:
-        self.代码 = 代码
-        self.key类型列表 = key类型列表
-        self.value类型列表 = value类型列表
-        self.key类型 = py类型转c类型(key类型列表)
-        self.value类型 = py类型转c类型(value类型列表)
-
-    def __str__(self) -> str:
-        return self.代码
-
-
-def 从dict构建初始化列表(value: dict):
-    code = []
-    key类型列表 = []
-    value类型列表 = []
-    for k, v in value.items():
-        key类型 = type(k)
-        cpp类型检查(key类型, 'Map')
-        value类型 = type(v)
-        cpp类型检查(value类型, 'Map')
-        key类型列表.append(key类型)
-        value类型列表.append(value类型)
-        code.append(f'{{ {toCString(k)}, {v} }}')
-
-    # 构建类型列表
-    if all(类型 == key类型列表[0] for 类型 in key类型列表):
-        key类型列表 = key类型列表[0]
-
-    if all(类型 == value类型列表[0] for 类型 in value类型列表):
-        value类型列表 = value类型列表[0]
-
-    # 构建初始化列表
-    初始化列表 = '{' + ','.join(code) + '}'
-
-    return dict初始化列表(初始化列表, key类型列表, value类型列表)
-
-
-class c变量:
-    def __init__(self, 类型: str, 名字: str, 是参数: bool, 默认值=None) -> None:
-        self.类型 = 类型
-        self.名字 = 名字
-        self.c名字 = 生成变量Id(名字)
-        self.是参数 = 是参数
-        self.默认值 = 默认值
-
-    def __str__(self):
-        return self.c名字
-
-    @property
-    def c类型(self):
-        return cpp获取变量类型(self)
-
-    def 初始化(self, 初始值):
-        return f'{self.类型} {self.c名字} = {初始值};'