ygo 1.0.10__tar.gz → 1.1.0__tar.gz

ygo-1.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: ygo
+Version: 1.1.0
+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: loguru>=0.7.3
+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(job_name="test parallel", 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
+```
+
+### 📝 日志记录（ylog）
+
+```python
+import ylog
+
+ylog.info("这是一个信息日志")
+ylog.warning("这是一个警告日志")
+ylog.error("这是一个错误日志", exc_info=True)
+
+
+
+# 为不同的模块使用不同的logger
+logger_app1 = ylog.get_logger("app1", )
+logger_app2 = ylog.get_logger("app2", )
+```
+
+#### 🔧 配置管理：`update_config`
+
+你可以通过 update_config 方法动态修改日志配置，例如设置日志级别、格式、是否启用颜色等。
+
+```python
+# 开启调试模式
+ylog.update_config(debug_mode=True)
+```
+
+#### 🧩 获取独立的 Logger 实例：`get_logger`
+
+在大型项目中，你可能希望为不同模块或组件创建独立的 logger 实例以区分日志来源。
+
+```python
+logger1 = ylog.get_logger("moduleA")
+logger2 = ylog.get_logger("moduleB")
+
+logger1.info("这是来自 moduleA 的日志")
+logger2.warning("这是来自 moduleB 的警告")
+```
+
+#### 📌 使用建议
+
+- 生产环境建议关闭 `debug_mode`，避免产生过多调试日志。
+- 对于复杂项目，推荐使用 `get_logger` 创建命名 logger，便于日志分类与分析。
+- 使用 `exc_info=True` 参数时，可自动打印异常堆栈信息，适用于错误捕获场景。

ygo-1.1.0/README.md

@@ -0,0 +1,147 @@
+# 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(job_name="test parallel", 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
+```
+
+### 📝 日志记录（ylog）
+
+```python
+import ylog
+
+ylog.info("这是一个信息日志")
+ylog.warning("这是一个警告日志")
+ylog.error("这是一个错误日志", exc_info=True)
+
+
+
+# 为不同的模块使用不同的logger
+logger_app1 = ylog.get_logger("app1", )
+logger_app2 = ylog.get_logger("app2", )
+```
+
+#### 🔧 配置管理：`update_config`
+
+你可以通过 update_config 方法动态修改日志配置，例如设置日志级别、格式、是否启用颜色等。
+
+```python
+# 开启调试模式
+ylog.update_config(debug_mode=True)
+```
+
+#### 🧩 获取独立的 Logger 实例：`get_logger`
+
+在大型项目中，你可能希望为不同模块或组件创建独立的 logger 实例以区分日志来源。
+
+```python
+logger1 = ylog.get_logger("moduleA")
+logger2 = ylog.get_logger("moduleB")
+
+logger1.info("这是来自 moduleA 的日志")
+logger2.warning("这是来自 moduleB 的警告")
+```
+
+#### 📌 使用建议
+
+- 生产环境建议关闭 `debug_mode`，避免产生过多调试日志。
+- 对于复杂项目，推荐使用 `get_logger` 创建命名 logger，便于日志分类与分析。
+- 使用 `exc_info=True` 参数时，可自动打印异常堆栈信息，适用于错误捕获场景。

ygo-1.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ygo"
+version = "v1.1.0"
+description = ""
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "joblib>=1.5.0",
+    "loguru>=0.7.3",
+    "tqdm>=4.67.1",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ygo", "ygo.*", "ylog", "ylog.*", ]
+
+[project.urls]
+homepage = "https://github.com/link-yundi/ygo"
+repository = "https://github.com/link-yundi/ygo"

ygo-1.1.0/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.0.10 → ygo-1.1.0}/ygo/__init__.py

@@ -7,9 +7,10 @@ Created on 2025/4/28 15:25
 ---------------------------------------------
 """
 
-from .exceptions import FailTaskError
-from .ygo import (
-    delay,
+from .exceptions import FailTaskError, WarnException
+from .pool import pool
+from .delay import delay
+from .utils import (
     fn_params,
     fn_signature_params,
     fn_path,
@@ -17,12 +18,14 @@ from .ygo import (
     fn_info,
     module_from_str,
     fn_from_str,
-    pool,
 )
 
+__version__ = "v1.1.0"
+
 __all__ = [
     "FailTaskError",
     "delay",
+    "WarnException",
     "fn_params",
     "fn_signature_params",
     "fn_path",

ygo-1.1.0/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)
+