ygo 1.0.8__tar.gz → 1.2.12__tar.gz

ygo-1.2.12/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: ygo
+Version: 1.2.12
+Summary: 一个轻量级 Python 工具包，支持 并发执行（带进度条）、延迟调用、链式绑定参数、函数信息获取、模块/函数动态加载。
+Project-URL: homepage, https://github.com/link-yundi/ygo
+Project-URL: repository, https://github.com/link-yundi/ygo
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: joblib>=1.5.0
+Requires-Dist: logair>=1.0.6
+Requires-Dist: psutil>=7.2.1
+Requires-Dist: tqdm>=4.67.1
+Dynamic: license-file
+
+# ygo
+一个轻量级 Python 工具包，底层基于 joblib 和 tqdm 、loguru 实现，支持
+- 并发执行（带进度条）
+- 延迟调用
+- 链式绑定参数
+- 函数信息获取
+- 模块/函数动态加载...
+- 并结合 ylog 提供日志记录能力
+
+### 安装
+```shell
+pip install -U ygo
+```
+
+### 🧰 功能概览
+
+| 模块   | 功能                                                         |
+| :----- | :----------------------------------------------------------- |
+| `ygo`  | 支持并发执行（带进度条）、延迟调用、函数信息获取以及模块/函数动态加载等功能 |
+| `ylog` | 日志模块，提供统一的日志输出接口                             |
+
+### 示例
+
+```
+├── a
+│   ├── __init__.py
+│   └── b
+│       ├── __init__.py
+│       └── c.py
+└── test.py
+
+c.py 中定义了目标函数
+def test_fn(a, b=2):
+    return a+b
+```
+
+#### 场景1: 并发执行
+
+```python
+import ygo
+import ylog
+from a.b.c import test_fn
+
+with ygo.pool(n_jobs=5, show_progress=True) as go:
+    for i in range(10):
+        go.submit(test_fn)(a=i, b=2*i)
+    for res in go.do():
+        ylog.info(res)
+```
+
+#### ✅ `ygo.pool` 支持的参数
+
+| 参数名        | 类型 | 描述                                                         |
+| ------------- | ---- | ------------------------------------------------------------ |
+| n_jobs        | int  | 并行任务数(<=1 表示串行)                                     |
+| show_progress | bool | 是否显示进度条                                               |
+| backend       | str  | 执行后端（默认 'threading'，可选 'multiprocessing' 或 'loky'） |
+
+#### 场景2: 延迟调用
+
+```
+>>> fn = delay(test_fn)(a=1, b=2)
+>>> fn()
+3
+>>> # 逐步传递参数
+>>> fn1 = delay(lambda a, b, c: a+b+c)(a=1)
+>>> fn2 = delay(fn1)(b=2)
+>>> fn2(c=3)
+6
+>>> # 参数更改
+>>> fn1 = delay(lambda a, b, c: a+b+c)(a=1, b=2)
+>>> fn2 = delay(fn1)(c=3, b=5)
+>>> fn2()
+9
+```
+
+#### 场景3: 获取目标函数信息
+
+```
+>>> ygo.fn_info(test_fn)
+=============================================================
+    a.b.c.test_fn(a, b=2)
+=============================================================
+    def test_fn(a, b=2):
+    return a+b
+```
+
+#### 🔍 其他函数信息工具
+
+| 方法名                    | 描述                                     |
+| ------------------------- | ---------------------------------------- |
+| `fn_params(fn)`           | 获取函数实参                             |
+| `fn_signature_params(fn)` | 获取函数定义的所有参数名                 |
+| `fn_code(fn)`             | 获取函数源码字符串                       |
+| `fn_path(fn)`             | 获取函数所属模块路径                     |
+| `fn_from_str(s)`          | 根据字符串导入函数（如 "a.b.c.test_fn"） |
+| `module_from_str(s)`      | 根据字符串导入模块                       |
+
+#### 场景4: 通过字符串解析函数并执行
+
+```
+>>> ygo.fn_from_str("a.b.c.test_fn")(a=1, b=5)
+6
+```

ygo-1.2.12/README.md

@@ -0,0 +1,104 @@
+# ygo
+一个轻量级 Python 工具包，底层基于 joblib 和 tqdm 、loguru 实现，支持
+- 并发执行（带进度条）
+- 延迟调用
+- 链式绑定参数
+- 函数信息获取
+- 模块/函数动态加载...
+- 并结合 ylog 提供日志记录能力
+
+### 安装
+```shell
+pip install -U ygo
+```
+
+### 🧰 功能概览
+
+| 模块   | 功能                                                         |
+| :----- | :----------------------------------------------------------- |
+| `ygo`  | 支持并发执行（带进度条）、延迟调用、函数信息获取以及模块/函数动态加载等功能 |
+| `ylog` | 日志模块，提供统一的日志输出接口                             |
+
+### 示例
+
+```
+├── a
+│   ├── __init__.py
+│   └── b
+│       ├── __init__.py
+│       └── c.py
+└── test.py
+
+c.py 中定义了目标函数
+def test_fn(a, b=2):
+    return a+b
+```
+
+#### 场景1: 并发执行
+
+```python
+import ygo
+import ylog
+from a.b.c import test_fn
+
+with ygo.pool(n_jobs=5, show_progress=True) as go:
+    for i in range(10):
+        go.submit(test_fn)(a=i, b=2*i)
+    for res in go.do():
+        ylog.info(res)
+```
+
+#### ✅ `ygo.pool` 支持的参数
+
+| 参数名        | 类型 | 描述                                                         |
+| ------------- | ---- | ------------------------------------------------------------ |
+| n_jobs        | int  | 并行任务数(<=1 表示串行)                                     |
+| show_progress | bool | 是否显示进度条                                               |
+| backend       | str  | 执行后端（默认 'threading'，可选 'multiprocessing' 或 'loky'） |
+
+#### 场景2: 延迟调用
+
+```
+>>> fn = delay(test_fn)(a=1, b=2)
+>>> fn()
+3
+>>> # 逐步传递参数
+>>> fn1 = delay(lambda a, b, c: a+b+c)(a=1)
+>>> fn2 = delay(fn1)(b=2)
+>>> fn2(c=3)
+6
+>>> # 参数更改
+>>> fn1 = delay(lambda a, b, c: a+b+c)(a=1, b=2)
+>>> fn2 = delay(fn1)(c=3, b=5)
+>>> fn2()
+9
+```
+
+#### 场景3: 获取目标函数信息
+
+```
+>>> ygo.fn_info(test_fn)
+=============================================================
+    a.b.c.test_fn(a, b=2)
+=============================================================
+    def test_fn(a, b=2):
+    return a+b
+```
+
+#### 🔍 其他函数信息工具
+
+| 方法名                    | 描述                                     |
+| ------------------------- | ---------------------------------------- |
+| `fn_params(fn)`           | 获取函数实参                             |
+| `fn_signature_params(fn)` | 获取函数定义的所有参数名                 |
+| `fn_code(fn)`             | 获取函数源码字符串                       |
+| `fn_path(fn)`             | 获取函数所属模块路径                     |
+| `fn_from_str(s)`          | 根据字符串导入函数（如 "a.b.c.test_fn"） |
+| `module_from_str(s)`      | 根据字符串导入模块                       |
+
+#### 场景4: 通过字符串解析函数并执行
+
+```
+>>> ygo.fn_from_str("a.b.c.test_fn")(a=1, b=5)
+6
+```

ygo-1.2.12/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ygo"
+version = "1.2.12"
+description = "一个轻量级 Python 工具包，支持 并发执行（带进度条）、延迟调用、链式绑定参数、函数信息获取、模块/函数动态加载。"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "joblib>=1.5.0",
+    "logair>=1.0.6",
+    "psutil>=7.2.1",
+    "tqdm>=4.67.1",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ygo", "ygo.*",]
+
+[project.urls]
+homepage = "https://github.com/link-yundi/ygo"
+repository = "https://github.com/link-yundi/ygo"

ygo-1.2.12/tests/test_lazy.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Copyright (c) 2025 ZhangYundi
+Licensed under the MIT License. 
+Created on 2025/6/29 10:49
+Email: yundi.xxii@outlook.com
+Description: 
+---------------------------------------------
+"""
+
+import ygo
+
+def test_import_module():
+    import os
+    os_path = ygo.lazy_import("os.path")
+    assert os_path.join("a", "b") == os.path.join("a", "b")
+
+def test_import_function():
+    from os.path import join
+    assert ygo.lazy_import("os.path.join")("a", "b") == join("a", "b")

ygo-1.2.12/tests/test_utils.py

@@ -0,0 +1,19 @@
+# Copyright (c) ZhangYundi.
+# Licensed under the MIT License. 
+# Created on 2025/7/20 16:33
+# Description:
+import queue
+
+# from ygo.utils import locate
+from ygo.pool import run_job
+
+# def test_locate():
+    # fn = locate("functools.partial")
+    # test_fn = lambda a, b: a+b
+    # assert fn(test_fn, 1, 2)() == 3
+
+def foo():
+    run_job(1, 1, queue.Queue())
+
+if __name__ == '__main__':
+    foo()

ygo-1.2.12/tests/test_ygo.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Created on 2025/5/27 09:14
+@author: ZhangYundi
+@email: yundi.xxii@outlook.com
+---------------------------------------------
+"""
+
+import time
+
+import ygo
+
+
+def sample_task_add(a, b):
+    time.sleep(1)
+    return a + b
+
+
+def sample_task_sub(a, b):
+    time.sleep(1)
+    return a - b
+
+
+def warn_task():
+    raise ygo.WarnException("Test warning")
+
+
+def error_task():
+    raise ValueError("Test error")
+
+
+def test_pool_submit_and_do():
+    with ygo.pool() as go:
+        go.submit(sample_task_add, "task add")(a=1, b=2)
+        go.submit(sample_task_add, "task add")(a=2, b=3)
+        go.submit(sample_task_sub, "task sub")(a=5, b=1)
+
+        results = go.do()
+
+    assert len(results) == 3
+    assert results[0] == 3
+    assert results[1] == 5
+    assert results[2] == 4
+
+
+def test_pool_error_handling():
+    with ygo.pool() as go:
+        go.submit(error_task, job_name="task_error")()
+
+        results = go.do()
+
+    assert len(results) == 1
+    assert results[0] is None
+
+
+def test_pool_warn_exception_handled():
+    """测试 WarnException 是否被记录警告但继续执行"""
+    with ygo.pool(n_jobs=1) as go:
+        go.submit(warn_task, job_name="task_warn")()
+
+        results = go.do()
+
+        assert len(results) == 1
+        assert results[0] is None  # WarnException 不中断流程
+
+
+def test_pool_progress_bar_disabled():
+    """测试关闭进度条时的行为"""
+    with ygo.pool(n_jobs=2, show_progress=False) as go:
+        go.submit(sample_task_add, "test add")(a=1, b=2)
+        go.submit(sample_task_add, "test add")(a=3, b=4)
+
+        results = go.do()
+
+        assert len(results) == 2
+        assert 3 == results[0]
+        assert 7 == results[1]
+
+
+def test_pool_with_one_jobs():
+    """测试 n_jobs=1 时是否退化为串行执行"""
+    with ygo.pool(n_jobs=1) as go:
+        go.submit(sample_task_add, "test add")(a=1, b=2)
+        go.submit(sample_task_add, "test add")(a=3, b=4)
+
+        results = go.do()
+
+        assert len(results) == 2
+        assert 3 == results[0]
+        assert 7 == results[1]
+
+
+def test_delay_basic_usage():
+    """场景1：基本使用"""
+    fn = ygo.delay(lambda a, b: a + b)(a=1, b=2)
+    assert fn() == 3
+
+
+def test_delay_partial_kwargs():
+    """场景2：逐步传递参数"""
+    fn1 = ygo.delay(lambda a, b, c: a + b + c)(a=1)
+    fn2 = ygo.delay(fn1)(b=2)
+    assert fn2(c=3) == 6
+
+
+def test_delay_override_kwargs():
+    """场景3：参数更改"""
+    fn1 = ygo.delay(lambda a, b, c: a + b + c)(a=1, b=2)
+    fn2 = ygo.delay(fn1)(c=3, b=5)  # 修改 b 的值
+    assert fn2() == 9
+
+
+def test_delay_with_no_call():
+    """延迟函数在未调用时不会执行"""
+    called = False
+
+    def side_effect(*args, **kwargs):
+        nonlocal called
+        called = True
+        return None
+
+    delayed_fn = ygo.delay(side_effect)(x=1)
+    assert not called  # 还未执行
+    delayed_fn()
+    assert called  # 执行后标记为 True
+
+
+def test_fn_signature_params():
+    assert ygo.fn_signature_params(sample_task_add) == ['a', 'b']
+
+
+def test_fn_params_with_defaults():
+    delayed = ygo.delay(sample_task_add)(a=3)
+    print(ygo.fn_params(delayed))
+    assert dict(ygo.fn_params(delayed)) == {'a': 3, }
+
+
+def test_fn_path_for_function():
+    fn_path = ygo.fn_path(sample_task_add)
+    assert 'tests.test_ygo' in fn_path or '__main__' in fn_path
+
+
+def test_fn_code():
+    code = ygo.fn_code(sample_task_add)
+    assert "def sample_task_add(a, b):" in code
+    assert "return a+b" in code
+
+
+def test_fn_info():
+    info = ygo.fn_info(sample_task_add)
+    assert "sample_task_add(a, b)" in info
+    assert "def sample_task_add(a, b):" in info
+
+
+def test_fn_from_str():
+    func = ygo.fn_from_str("ygo.utils.fn_from_str")
+    assert func.__name__ == "fn_from_str"
+
+
+def test_module_from_str():
+    mod = ygo.module_from_str("ygo.utils")
+    assert mod.__name__ == "ygo.utils"
+
+
+def test_fn_params_with_no_defaults():
+    def no_defaults(x, y):
+        pass
+
+    delayed = ygo.delay(no_defaults)()
+    assert dict(ygo.fn_params(delayed)) == {}

ygo-1.2.12/ygo/__init__.py

@@ -0,0 +1,31 @@
+from .exceptions import FailTaskError, WarnException
+from .pool import pool
+from .delay import delay
+from .utils import (
+    fn_params,
+    fn_signature_params,
+    fn_path,
+    fn_code,
+    fn_info,
+    module_from_str,
+    fn_from_str,
+    locate,
+)
+from .lazy import lazy_import
+
+__version__ = "1.2.12"
+
+__all__ = [
+    "FailTaskError",
+    "delay",
+    "WarnException",
+    "fn_params",
+    "fn_signature_params",
+    "fn_path",
+    "fn_code",
+    "fn_info",
+    "fn_from_str",
+    "module_from_str",
+    "pool",
+    "lazy_import"
+]

ygo-1.2.12/ygo/delay.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Created on 2025/5/26 20:12
+@author: ZhangYundi
+@email: yundi.xxii@outlook.com
+---------------------------------------------
+"""
+
+import functools
+import inspect
+
+
+class DelayedFunction:
+
+    def __init__(self, func):
+        self.func = func
+        self._fn_params_k = inspect.signature(self.func).parameters.keys()
+        self.stored_kwargs = self._get_default_args(func)
+        if hasattr(func, 'stored_kwargs'):
+            self.stored_kwargs.update(func.stored_kwargs)
+
+    def _get_default_args(self, func):
+        signature = inspect.signature(func)
+        return {
+            k: v.default
+            for k, v in signature.parameters.items()
+            if v.default is not inspect.Parameter.empty
+        }
+
+    def __call__(self, *args, **kwargs):
+        def delayed(*args, **_kwargs):
+            new_kwargs = {k: v for k, v in self.stored_kwargs.items()}
+            for k, v in _kwargs.items():
+                if k not in self._fn_params_k:
+                    continue
+                new_kwargs[k] = v
+            return self.func(*args, **new_kwargs)
+
+        self._stored_kwargs(**kwargs)
+        new_fn = functools.wraps(self.func)(delayed)
+        new_fn.stored_kwargs = self.stored_kwargs
+        return new_fn
+
+    def _stored_kwargs(self, **kwargs):
+        for k, v in kwargs.items():
+            if k not in self._fn_params_k:
+                continue
+            self.stored_kwargs[k] = v
+
+
+def delay(func):
+    """
+    延迟执行
+    Parameters
+    ----------
+    func: Callable
+        需要延迟执行的对象, 必须是一个Callable对象
+
+    Returns
+    -------
+    DelayedFunction
+        将预先设置好的参数包装进原始的Callable对象中
+
+    Examples
+    --------
+
+    场景1：基本使用
+
+    >>> fn = delay(lambda a, b: a+b)(a=1, b=2)
+    >>> fn()
+    3
+
+    场景2: 逐步传递参数
+
+    >>> fn1 = delay(lambda a, b, c: a+b+c)(a=1)
+    >>> fn2 = delay(fn1)(b=2)
+    >>> fn2(c=3)
+    6
+
+    场景3: 参数更改
+
+    >>> fn1 = delay(lambda a, b, c: a+b+c)(a=1, b=2)
+    >>> fn2 = delay(fn1)(c=3, b=5)
+    >>> fn2()
+    9
+    """
+    return DelayedFunction(func)
+

{ygo-1.0.8 → ygo-1.2.12}/ygo/exceptions.py

@@ -7,7 +7,23 @@ Created on 2024/12/18 下午7:01
 ---------------------------------------------
 """
 
+from dataclasses import dataclass
+
 class WarnException(Exception):
     """自定义异常类，仅用于警告"""
     def __init__(self, message):
-        super().__init__(message)  # 调用父类的构造函数
+        super().__init__(message)  # 调用父类的构造函数
+
+@dataclass
+class FailTaskError:
+    task_name: str
+    error: Exception
+
+    def __str__(self):
+        return f"""
+[失败任务]: {self.task_name}
+[错误信息]: \n{self.error}
+"""
+
+    def __repr__(self):
+        return self.__str__()

ygo-1.2.12/ygo/lazy.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Copyright (c) 2025 ZhangYundi
+Licensed under the MIT License. 
+Created on 2025/6/29 10:36
+Email: yundi.xxii@outlook.com
+Description:
+---------------------------------------------
+"""
+
+from typing import Any
+from .utils import locate
+
+class LazyImport:
+    def __init__(self, full_name: str):
+        self._full_name = full_name
+        self._obj = None
+
+    def _load(self) -> Any:
+        if self._obj is None:
+            self._obj = locate(self._full_name)
+        return self._obj
+
+    def __getattr__(self, attr: str) -> Any:
+        obj = self._load()
+        return getattr(obj, attr)
+
+    def __dir__(self) -> list[str]:
+        obj = self._load()
+        return dir(obj)
+
+    def __call__(self, *args, **kwargs) -> Any:
+        obj = self._load()
+        if isinstance(obj, type):
+            return obj(*args, **kwargs)
+        elif callable(obj):
+            return obj(*args, **kwargs)
+        else:
+            raise TypeError(f"The target `{self._full_name}` is not callable or instantiable.")
+
+    def __str__(self):
+        return self._full_name
+
+    def __repr__(self):
+        return self._full_name
+
+def lazy_import(full_name: str):
+    """实现模块和方法的懒加载"""
+    return LazyImport(full_name)