vools 0.2.0__tar.gz → 0.2.2__tar.gz

{vools-0.2.0/vools.egg-info → vools-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vools
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python 函数式编程工具集
 Author-email: Victor <victortop921129@gmail.com>
 License: Apache License
@@ -264,6 +264,7 @@ Dynamic: license-file
 - **任务调度**: TaskQueue、WorkerPool、DAG 调度器
 - **序列化**: 支持 JSON、MsgPack、Pickle 等多种格式
 - **编码/加密**: Base64、URL 编码、哈希函数
+- **多语言桥接**: 支持 27 种编程语言（Lua、Rust、Go、Java、Kotlin、Swift、Dart、MoonBit 等），统一装饰器接口
 
 ## 安装
 
@@ -281,12 +282,12 @@ pip install .
 
 ### 环境要求
 
-- Python 3.9+
+- Python 3.6+
 
 ### 依赖
 
-- `wrapt >= 1.14`
-- `attrs >= 22.1`
+- `attrs >= 22.1` (Python < 3.7 时需要，用于 dataclass 兼容)
+- `contextvars` (Python < 3.7 时需要)
 
 ## 快速开始
 
@@ -387,6 +388,20 @@ print(result)  # [4, 8]
 
 ```
 vools/
+├── api/             # CLI 命令行接口
+├── bridge/          # 多语言桥接（27种语言）
+│   ├── core/        # 桥接核心（类型、签名缓存、装饰器）
+│   ├── lua/         # Lua 桥接
+│   ├── rust/        # Rust 桥接
+│   ├── go/          # Go 桥接
+│   ├── java/        # Java 桥接
+│   ├── kotlin/      # Kotlin 桥接
+│   ├── swift/       # Swift 桥接
+│   ├── dart/        # Dart 桥接
+│   ├── moonbit/     # MoonBit 桥接
+│   ├── c/           # C 桥接
+│   ├── cpp/         # C++ 桥接
+│   └── ...          # 更多语言
 ├── cache/           # 缓存装饰器
 │   ├── memorize     # 时间缓存
 │   ├── once         # 单次执行
@@ -421,6 +436,8 @@ vools/
 ├── recorder/        # 录制回放
 ├── security/        # 安全模块
 ├── serialize/       # 序列化
+├── sql/             # SQL 工具
+├── sys/             # 系统工具
 ├── task/           # 任务调度
 └── utils/          # 通用工具
 ```

{vools-0.2.0 → vools-0.2.2}/README.md

@@ -15,6 +15,7 @@
 - **任务调度**: TaskQueue、WorkerPool、DAG 调度器
 - **序列化**: 支持 JSON、MsgPack、Pickle 等多种格式
 - **编码/加密**: Base64、URL 编码、哈希函数
+- **多语言桥接**: 支持 27 种编程语言（Lua、Rust、Go、Java、Kotlin、Swift、Dart、MoonBit 等），统一装饰器接口
 
 ## 安装
 
@@ -32,12 +33,12 @@ pip install .
 
 ### 环境要求
 
-- Python 3.9+
+- Python 3.6+
 
 ### 依赖
 
-- `wrapt >= 1.14`
-- `attrs >= 22.1`
+- `attrs >= 22.1` (Python < 3.7 时需要，用于 dataclass 兼容)
+- `contextvars` (Python < 3.7 时需要)
 
 ## 快速开始
 
@@ -138,6 +139,20 @@ print(result)  # [4, 8]
 
 ```
 vools/
+├── api/             # CLI 命令行接口
+├── bridge/          # 多语言桥接（27种语言）
+│   ├── core/        # 桥接核心（类型、签名缓存、装饰器）
+│   ├── lua/         # Lua 桥接
+│   ├── rust/        # Rust 桥接
+│   ├── go/          # Go 桥接
+│   ├── java/        # Java 桥接
+│   ├── kotlin/      # Kotlin 桥接
+│   ├── swift/       # Swift 桥接
+│   ├── dart/        # Dart 桥接
+│   ├── moonbit/     # MoonBit 桥接
+│   ├── c/           # C 桥接
+│   ├── cpp/         # C++ 桥接
+│   └── ...          # 更多语言
 ├── cache/           # 缓存装饰器
 │   ├── memorize     # 时间缓存
 │   ├── once         # 单次执行
@@ -172,6 +187,8 @@ vools/
 ├── recorder/        # 录制回放
 ├── security/        # 安全模块
 ├── serialize/       # 序列化
+├── sql/             # SQL 工具
+├── sys/             # 系统工具
 ├── task/           # 任务调度
 └── utils/          # 通用工具
 ```

{vools-0.2.0 → vools-0.2.2}/pyproject.toml

@@ -76,9 +76,10 @@ vools = "vools.__main__:main"
 "Repository" = "https://github.com/vicTop-cw/vools"
 "Issues" = "https://github.com/vicTop-cw/vools/issues"
 
-# ============ setuptools: 明确指定要打包的目录，避免污染 ============
-[tool.setuptools]
-packages = ["vools", "vools.sys"]
+# ============ setuptools: 自动发现所有包 ============
+[tool.setuptools.packages.find]
+include = ["vools*"]
+exclude = ["vools.__pycache__", "vools.*.__pycache__"]
 
 [tool.setuptools.dynamic]
 version = { attr = "vools.__version__" }

{vools-0.2.0 → vools-0.2.2}/vools/__init__.py

@@ -7,7 +7,7 @@ vools - Python 函数式编程工具集
 import importlib
 from typing import Any
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 __author__ = "Victor"
 __license__ = "Apache 2.0"
 
@@ -514,6 +514,44 @@ __all__ = [
     'VDate',
 ]
 
+# Python 3.6 兼容：模块级 __getattr__ 和 __dir__ 是 3.7+ 才有的
+# 在 3.6 中需要主动导入所有延迟加载的名称
+import sys as _sys
+if _sys.version_info < (3, 7):
+    for _name in _lazy_modules:
+        if _name not in globals():
+            try:
+                _module_path = _lazy_modules[_name]
+                _module = importlib.import_module(_module_path, package='vools')
+                if hasattr(_module, _name):
+                    globals()[_name] = getattr(_module, _name)
+                else:
+                    globals()[_name] = _module
+            except Exception:
+                pass
+    # VList, VText, VDate
+    for _vname in ('VList', 'VText', 'VDate'):
+        if _vname not in globals():
+            try:
+                if _vname == 'VList':
+                    from .data.vlist import VList as _v
+                    globals()['VList'] = _v
+                elif _vname == 'VText':
+                    from .data.vtext import VText as _v
+                    globals()['VText'] = _v
+                elif _vname == 'VDate':
+                    from .datetime.vdate_class import VDate as _v
+                    globals()['VDate'] = _v
+            except Exception:
+                pass
+    # vicTools, vicDate, vicText, vicList
+    try:
+        _load_vic()
+        for _vk, _vv in _vic_classes.items():
+            globals()[_vk] = _vv
+    except Exception:
+        pass
+
 if __name__ == '__main__':
     print(f"vools version: {__version__}")
     print(f"Available exports: {len(__all__)} items")

vools-0.2.2/vools/api/__init__.py

@@ -0,0 +1,21 @@
+"""
+vools.api - Typer CLI 应用包
+
+导出 Typer 应用实例，提供命令行接口。
+
+子命令:
+- seq: Seq 序列操作
+- ops: Ops 管道操作  
+- curry: 函数柯里化
+- memoize: 函数记忆化
+
+示例:
+    from vools.api import typer_app
+    typer_app()
+"""
+
+from .typer_app import typer_app, main, info
+
+__all__ = ["typer_app", "main", "info"]
+
+__version__ = "0.1.0"

vools-0.2.2/vools/api/curry_cmd.py

@@ -0,0 +1,98 @@
+"""
+curry 子命令 - 函数柯里化 CLI
+
+用法示例:
+    vools curry --func "lambda x, y: x + y" --args 5 10
+    vools curry --func "lambda a, b, c: a * b * c" --args 2 3 4
+"""
+
+from typing import Optional, List, Callable
+import typer
+from typing_extensions import Annotated
+
+from vools.decorators import curry
+
+curry_app = typer.Typer(help="Curry 柯里化命令")
+
+
+def parse_lambda_or_func(expr: str):
+    """解析 lambda 表达式或函数名"""
+    try:
+        return eval(expr, {"__builtins__": {}})
+    except Exception:
+        # 如果是函数名，尝试从全局查找
+        import builtins
+        if hasattr(builtins, expr):
+            return getattr(builtins, expr)
+        raise ValueError(f"无法解析表达式: {expr}")
+
+
+@curry_app.command()
+def call(
+    func_expr: str = typer.Argument(..., help="函数表达式，如: lambda x, y: x + y"),
+    args: List[str] = typer.Argument(..., help="函数参数"),
+    kwargs: Annotated[
+        Optional[List[str]],
+        typer.Option("--kwargs", "-k", help="关键字参数，格式: key=value")
+    ] = None,
+):
+    """调用柯里化函数"""
+    func = parse_lambda_or_func(func_expr)
+    
+    # 解析参数
+    parsed_args = []
+    for arg in args:
+        try:
+            parsed_args.append(eval(arg, {"__builtins__": {}}))
+        except Exception:
+            parsed_args.append(arg)
+    
+    # 解析关键字参数
+    parsed_kwargs = {}
+    if kwargs:
+        for kw in kwargs:
+            if "=" in kw:
+                key, value = kw.split("=", 1)
+                try:
+                    parsed_kwargs[key] = eval(value, {"__builtins__": {}})
+                except Exception:
+                    parsed_kwargs[key] = value
+    
+    # 应用 curry 装饰器
+    curried_func = curry(func)
+    
+    # 调用
+    if parsed_kwargs:
+        result = curried_func(*parsed_args, **parsed_kwargs)
+    else:
+        result = curried_func(*parsed_args)
+    
+    typer.echo(f"结果: {result}")
+    return result
+
+
+@curry_app.command()
+def curry_func(
+    func_expr: str = typer.Argument(..., help="函数表达式"),
+):
+    """将函数柯里化并显示"""
+    func = parse_lambda_or_func(func_expr)
+    curried = curry(func)
+    typer.echo(f"原始函数: {func}")
+    typer.echo(f"柯里化函数: {curried}")
+    
+    # 尝试调用示例
+    try:
+        if hasattr(func, "__code__") and func.__code__.co_argcount >= 2:
+            # 如果是多参数函数，展示分步调用
+            args_example = ["arg1", "arg2"]
+            typer.echo(f"\n示例调用:")
+            typer.echo(f"  curried({args_example[0]}) = {curried(args_example[0])}")
+    except Exception as e:
+        typer.echo(f"无法展示示例: {e}")
+    
+    return curried
+
+
+if __name__ == "__main__":
+    typer.run(call)

vools-0.2.2/vools/api/memoize_cmd.py

@@ -0,0 +1,125 @@
+"""
+memoize 子命令 - 函数记忆化 CLI
+
+用法示例:
+    vools memoize --func "lambda x: x * 2" --args 5 --repeat 3
+    vools memoize --func "my_func" --args 10 --repeat 5
+"""
+
+from typing import Optional, List, Callable
+import time
+import typer
+from typing_extensions import Annotated
+
+from vools import memorize
+
+memoize_app = typer.Typer(help="Memoize 记忆化命令")
+
+
+def parse_lambda_or_func(expr: str) -> Callable:
+    """解析 lambda 表达式或函数名"""
+    try:
+        return eval(expr, {"__builtins__": {}})
+    except Exception:
+        import builtins
+        if hasattr(builtins, expr):
+            return getattr(builtins, expr)
+        raise ValueError(f"无法解析表达式: {expr}")
+
+
+def timing_decorator(func: Callable) -> Callable:
+    """计时装饰器"""
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        elapsed = time.time() - start
+        return result, elapsed
+    return wrapper
+
+
+@memoize_app.command()
+def call(
+    func_expr: str = typer.Argument(..., help="函数表达式，如: lambda x: x * 2"),
+    args: List[str] = typer.Argument(..., help="函数参数"),
+    repeat: int = typer.Option(1, "--repeat", "-r", help="重复调用次数"),
+    show_cache: bool = typer.Option(False, "--show-cache/--no-show-cache", help="显示缓存状态"),
+):
+    """调用记忆化函数并测量性能"""
+    func = parse_lambda_or_func(func_expr)
+    
+    # 解析参数
+    parsed_args = []
+    for arg in args:
+        try:
+            parsed_args.append(eval(arg, {"__builtins__": {}}))
+        except Exception:
+            parsed_args.append(arg)
+    
+    # 应用 memorize 装饰器
+    memorized_func = memorize(func)
+    
+    typer.echo(f"函数: {func_expr}")
+    typer.echo(f"参数: {parsed_args}")
+    typer.echo(f"重复次数: {repeat}")
+    typer.echo("-" * 40)
+    
+    total_time = 0
+    results = []
+    
+    for i in range(repeat):
+        result, elapsed = timing_decorator(memorized_func)(*parsed_args)
+        results.append(result)
+        total_time += elapsed
+        
+        cache_status = "缓存命中" if i > 0 else "首次计算"
+        typer.echo(f"第 {i+1} 次: 结果={result}, 耗时={elapsed:.6f}s, {cache_status}")
+    
+    typer.echo("-" * 40)
+    typer.echo(f"平均耗时: {total_time/repeat:.6f}s")
+    typer.echo(f"结果一致: {len(set(results)) == 1}")
+    
+    return results[0]
+
+
+@memoize_app.command()
+def benchmark(
+    func_expr: str = typer.Argument(..., help="函数表达式"),
+    args: List[str] = typer.Argument(..., help="函数参数"),
+    iterations: int = typer.Option(100, "--iterations", "-n", help="基准测试迭代次数"),
+):
+    """基准测试记忆化函数"""
+    func = parse_lambda_or_func(func_expr)
+    
+    # 解析参数
+    parsed_args = []
+    for arg in args:
+        try:
+            parsed_args.append(eval(arg, {"__builtins__": {}}))
+        except Exception:
+            parsed_args.append(arg)
+    
+    # 应用 memorize 装饰器
+    memorized_func = memorize(func)
+    
+    # 预热
+    for _ in range(10):
+        memorized_func(*parsed_args)
+    
+    # 基准测试
+    start = time.time()
+    for _ in range(iterations):
+        memorized_func(*parsed_args)
+    elapsed = time.time() - start
+    
+    typer.echo(f"函数: {func_expr}")
+    typer.echo(f"参数: {parsed_args}")
+    typer.echo(f"迭代次数: {iterations}")
+    typer.echo(f"总耗时: {elapsed:.4f}s")
+    typer.echo(f"平均每次: {elapsed/iterations*1000:.4f}ms")
+    typer.echo(f"每秒操作数: {iterations/elapsed:.2f}")
+    
+    return elapsed
+
+
+if __name__ == "__main__":
+    typer.run(call)

vools-0.2.2/vools/api/ops_cmd.py

@@ -0,0 +1,112 @@
+"""
+ops 子命令 - Ops 管道操作 CLI
+
+用法示例:
+    vools ops --pipe 1 2 3 4 5 --filter "lambda x: x % 2 == 0"
+    vools ops --pipe 1 2 3 4 5 --map "lambda x: x * 2" --sum
+    vools ops --pipe 1 2 3 4 5 6 7 8 9 10 --filter "lambda x: x % 2 == 0" --map "lambda x: x ** 2" --sum
+"""
+
+from typing import Optional, List, Callable
+import typer
+from typing_extensions import Annotated
+
+from vools.functional import Ops, O
+
+ops_app = typer.Typer(help="Ops 管道操作命令")
+
+
+def parse_lambda(expr: str) -> Callable:
+    """解析 lambda 表达式字符串"""
+    return eval(expr, {"__builtins__": {}})
+
+
+@ops_app.command()
+def pipe(
+    items: List[int] = typer.Argument(..., help="输入数据列表"),
+    filter_expr: Annotated[
+        Optional[str],
+        typer.Option("--filter", "-f", help="过滤表达式")
+    ] = None,
+    map_expr: Annotated[
+        Optional[str],
+        typer.Option("--map", "-m", help="映射表达式")
+    ] = None,
+    sum_flag: bool = typer.Option(False, "--sum/--no-sum", help="求和"),
+    min_flag: bool = typer.Option(False, "--min/--no-min", help="最小值"),
+    max_flag: bool = typer.Option(False, "--max/--no-max", help="最大值"),
+    count_flag: bool = typer.Option(False, "--count/--no-count", help="计数"),
+    collect_flag: bool = typer.Option(True, "--collect/--no-collect", help="收集为列表"),
+):
+    """管道操作"""
+    result = items
+    
+    if filter_expr:
+        result = result | Ops.filter(parse_lambda(filter_expr))
+    
+    if map_expr:
+        result = result | Ops.map(parse_lambda(map_expr))
+    
+    if sum_flag:
+        result = result | Ops.sum
+        typer.echo(f"求和结果: {result}")
+        return result
+    
+    if min_flag:
+        result = result | Ops.min
+        typer.echo(f"最小值: {result}")
+        return result
+    
+    if max_flag:
+        result = result | Ops.max
+        typer.echo(f"最大值: {result}")
+        return result
+    
+    if count_flag:
+        result = result | Ops.count
+        typer.echo(f"计数: {result}")
+        return result
+    
+    if collect_flag:
+        result = result | Ops.as_list
+        typer.echo(f"结果: {result}")
+        return result
+    
+    typer.echo(f"结果: {result}")
+    return result
+
+
+@ops_app.command()
+def filter_op(
+    items: List[int] = typer.Argument(..., help="输入数据列表"),
+    expr: str = typer.Argument(..., help="过滤表达式"),
+):
+    """管道过滤操作"""
+    result = items | Ops.filter(parse_lambda(expr)) | Ops.as_list
+    typer.echo(f"过滤结果: {result}")
+    return result
+
+
+@ops_app.command()
+def map_op(
+    items: List[int] = typer.Argument(..., help="输入数据列表"),
+    expr: str = typer.Argument(..., help="映射表达式"),
+):
+    """管道映射操作"""
+    result = items | Ops.map(parse_lambda(expr)) | Ops.as_list
+    typer.echo(f"映射结果: {result}")
+    return result
+
+
+@ops_app.command()
+def sum_op(
+    items: List[int] = typer.Argument(..., help="输入数据列表"),
+):
+    """管道求和操作"""
+    result = items | Ops.sum
+    typer.echo(f"求和结果: {result}")
+    return result
+
+
+if __name__ == "__main__":
+    typer.run(pipe)

vools-0.2.2/vools/api/seq_cmd.py

@@ -0,0 +1,129 @@
+"""
+seq 子命令 - Seq 序列操作 CLI
+
+用法示例:
+    vools seq --from-range 10 --filter "lambda x: x % 2 == 0"
+    vools seq --from-list 1 2 3 4 5 --map "lambda x: x * 2"
+    vools seq --from-range 20 --filter "lambda x: x % 2 == 0" --map "lambda x: x ** 2" --collect
+"""
+
+from typing import Optional, List, Callable
+import typer
+from typing_extensions import Annotated
+
+from vools.data import Seq
+
+seq_app = typer.Typer(help="Seq 序列操作命令")
+
+
+def parse_lambda(expr: str) -> Callable:
+    """解析 lambda 表达式字符串"""
+    return eval(expr, {"__builtins__": {}})
+
+
+@seq_app.command()
+def from_range(
+    count: int = typer.Argument(..., help="范围大小（生成 0 到 count-1 的序列）"),
+    filter_expr: Annotated[
+        Optional[str],
+        typer.Option("--filter", "-f", help="过滤表达式，如: lambda x: x % 2 == 0")
+    ] = None,
+    map_expr: Annotated[
+        Optional[str],
+        typer.Option("--map", "-m", help="映射表达式，如: lambda x: x * 2")
+    ] = None,
+    collect: bool = typer.Option(False, "--collect/--no-collect", help="立即收集结果"),
+    limit: Annotated[
+        Optional[int],
+        typer.Option("--limit", "-l", help="限制结果数量")
+    ] = None,
+):
+    """从范围创建序列"""
+    seq = Seq.range(count)
+    
+    if filter_expr:
+        seq = seq.filter(parse_lambda(filter_expr))
+    
+    if map_expr:
+        seq = seq.map(parse_lambda(map_expr))
+    
+    if limit:
+        seq = seq.take(limit)
+    
+    if collect:
+        result = seq.collect()
+        typer.echo(f"结果: {result}")
+        return result
+    else:
+        typer.echo(f"Seq (lazy): {seq}")
+        return seq
+
+
+@seq_app.command()
+def from_list(
+    items: List[int] = typer.Argument(..., help="列表元素"),
+    filter_expr: Annotated[
+        Optional[str],
+        typer.Option("--filter", "-f", help="过滤表达式")
+    ] = None,
+    map_expr: Annotated[
+        Optional[str],
+        typer.Option("--map", "-m", help="映射表达式")
+    ] = None,
+    collect: bool = typer.Option(False, "--collect/--no-collect", help="立即收集结果"),
+):
+    """从列表创建序列"""
+    seq = Seq(items)
+    
+    if filter_expr:
+        seq = seq.filter(parse_lambda(filter_expr))
+    
+    if map_expr:
+        seq = seq.map(parse_lambda(map_expr))
+    
+    if collect:
+        result = seq.collect()
+        typer.echo(f"结果: {result}")
+        return result
+    else:
+        typer.echo(f"Seq (lazy): {seq}")
+        return seq
+
+
+@seq_app.command()
+def filter_cmd(
+    data: List[int] = typer.Argument(..., help="输入数据"),
+    expr: str = typer.Argument(..., help="过滤表达式"),
+):
+    """过滤序列元素"""
+    seq = Seq(data)
+    result = seq.filter(parse_lambda(expr)).collect()
+    typer.echo(f"过滤结果: {result}")
+    return result
+
+
+@seq_app.command()
+def map_cmd(
+    data: List[int] = typer.Argument(..., help="输入数据"),
+    expr: str = typer.Argument(..., help="映射表达式"),
+):
+    """映射序列元素"""
+    seq = Seq(data)
+    result = seq.map(parse_lambda(expr)).collect()
+    typer.echo(f"映射结果: {result}")
+    return result
+
+
+@seq_app.command()
+def collect_cmd(
+    data: List[int] = typer.Argument(..., help="输入数据"),
+):
+    """收集序列为列表"""
+    seq = Seq(data)
+    result = seq.collect()
+    typer.echo(f"收集结果: {result}")
+    return result
+
+
+if __name__ == "__main__":
+    typer.run(from_range)