p115client 0.0.5.10.8__py3-none-any.whl → 0.0.5.11__py3-none-any.whl

p115client/tool/iterdir.py

@@ -13,6 +13,7 @@ __all__ = [
     "iter_selected_nodes_using_edit", "iter_selected_nodes_using_star_event", 
     "iter_selected_dirs_using_star", "iter_files_with_dirname", "iter_files_with_path", 
     "iter_files_with_path_by_export_dir", "iter_parents_3_level", "iter_dir_nodes", 
+    "search_for_any_file", 
 ]
 __doc__ = "这个模块提供了一些和目录信息罗列有关的函数"
 
@@ -237,7 +238,7 @@ def get_path_to_cid(
             return "/" + path
         else:
             return path
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -369,7 +370,7 @@ def get_file_count(
                     node = DirNode(info["file_name"], pid)
                     id_to_dirnode[(pid := int(info["file_id"]))] = node
             return int(resp["count"]) - int(resp.get("folder_count") or 0)
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -589,7 +590,7 @@ def get_ancestors(
                 if not resp.get("sha1") and id_to_dirnode is not ...:
                     id_to_dirnode[ans["id"]] = DirNode(ans["name"], ans["parent_id"])
         return ancestors
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -691,7 +692,7 @@ def get_ancestors_to_cid(
             parts.append({"id": 0, "name": "", "parent_id": 0})
             parts.reverse()
         return parts
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 # TODO: 使用 search 接口以在特定目录之下搜索某个名字，以便减少风控
@@ -886,7 +887,7 @@ def get_id_to_path(
                     if ensure_file is None or ensure_file ^ attr["is_dir"]:
                         return P115ID(attr["id"], attr, about="path")
         raise error
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -940,7 +941,7 @@ def get_id_to_pickcode(
         check_response(resp)
         data = resp["data"]
         return P115ID(data["file_id"], data, about="pickcode")
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -1000,7 +1001,7 @@ def get_id_to_sha1(
             else:
                 raise FileNotFoundError(ENOENT, file_sha1)
         return P115ID(data["file_id"], data, about="sha1", file_sha1=file_sha1)
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -1052,8 +1053,8 @@ def iter_nodes_skim(
             check_response(resp)
             for a in resp["data"]:
                 a["file_name"] = unescape_115_charref(a["file_name"])
-            yield YieldFrom(resp["data"], identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+            yield YieldFrom(resp["data"], may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -1190,7 +1191,7 @@ def _iter_fs_files(
                             attr = _overview_attr(info)
                             if attr.is_dir:
                                 id_to_dirnode[attr.id] = DirNode(attr.name, attr.parent_id)
-                    yield YieldFrom(resp["data"], identity=True)
+                    yield YieldFrom(resp["data"], may_await=False)
                 else:
                     for info in resp["data"]:
                         attr = _overview_attr(info)
@@ -1199,10 +1200,10 @@ def _iter_fs_files(
                                 id_to_dirnode[attr.id] = DirNode(attr.name, attr.parent_id)
                         elif ensure_file is False:
                             return
-                        yield Yield(info, identity=True)
+                        yield Yield(info, may_await=False)
         except (StopAsyncIteration, StopIteration):
             pass
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -1591,8 +1592,8 @@ def ensure_attr_path[D: dict](
                         warn(f"{type(e).__module__}.{type(e).__qualname__}: {e} of {attr}", category=P115Warning)
                 attr.setdefault("ancestors", None)
                 attr.setdefault("path", "")
-            yield Yield(attr, identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+            yield Yield(attr, may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -2074,10 +2075,10 @@ def iterdir(
                         name = escape(name)
                     attr["path"] = dirname + name
                 return attr
-            yield YieldFrom(do_map(process, it), identity=True) # type: ignore
+            yield YieldFrom(do_map(process, it), may_await=False) # type: ignore
         else:
-            yield YieldFrom(do_map(normalize_attr, it), identity=True) # type: ignore
-    return run_gen_step_iter(gen_step, async_=async_)
+            yield YieldFrom(do_map(normalize_attr, it), may_await=False) # type: ignore
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 def iterdir_limited(
@@ -2186,8 +2187,8 @@ def iterdir_limited(
                 attr["path"] = dirname + name
             yield attr
     def gen_step():
-        resp: dict = yield run_gen_step(request, async_=async_)
-        yield YieldFrom(iter_attrs(resp), identity=True)
+        resp: dict = yield run_gen_step(request, simple=True, async_=async_)
+        yield YieldFrom(iter_attrs(resp), may_await=False)
         count = int(resp["count"])
         count_fetched = len(resp["data"])
         if count > count_fetched:
@@ -2215,30 +2216,30 @@ def iterdir_limited(
             count_top = count_top_dirs + count_top_files
             if count <= count_fetched * 2 - count_top:
                 resp = request({"asc": 0, "offset": count_top, "limit": count - count_fetched})
-                yield YieldFrom(iter_attrs(resp), identity=True)
+                yield YieldFrom(iter_attrs(resp), may_await=False)
                 return
             if diff := count_dirs - len(seen_dirs):
                 if diff > count_fetched - count_top_dirs:
                     resp = request({"nf": 1, "offset": len(seen_dirs)})
-                    yield YieldFrom(iter_attrs(resp), identity=True)
+                    yield YieldFrom(iter_attrs(resp), may_await=False)
                     diff = count_dirs - len(seen_dirs)
                 if diff > 0:
                     resp = request({"asc": 0, "nf": 1, "offset": count_top_dirs, "limit": diff})
-                    yield YieldFrom(iter_attrs(resp), identity=True)
+                    yield YieldFrom(iter_attrs(resp), may_await=False)
                     
                     if diff := count_dirs - len(seen_dirs):
                         warn(f"lost {diff} directories: cid={cid}", category=P115Warning)
             if diff := count_files - len(seen_files):
                 if diff > count_fetched - count_top_files:
                     resp = request({"show_dir": 0, "offset": len(seen_files)})
-                    yield YieldFrom(iter_attrs(resp), identity=True)
+                    yield YieldFrom(iter_attrs(resp), may_await=False)
                     diff = count_files - len(seen_files)
                 if diff > 0:
                     resp = request({"asc": 0, "show_dir": 0, "offset": count_top_files, "limit": diff})
-                    yield YieldFrom(iter_attrs(resp), identity=True)
+                    yield YieldFrom(iter_attrs(resp), may_await=False)
                     if diff := count_files - len(seen_files):
                         warn(f"lost {diff} files: cid={cid}", category=P115Warning)
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -2591,9 +2592,9 @@ def iter_files(
                     add_to_cache(attr)
                 else:
                     return attr
-            yield YieldFrom(do_filter(bool, do_map(process, it)), identity=True) # type: ignore
+            yield YieldFrom(do_filter(bool, do_map(process, it)), may_await=False) # type: ignore
         else:
-            yield YieldFrom(do_map(normalize_attr, it), identity=True) # type: ignore
+            yield YieldFrom(do_map(normalize_attr, it), may_await=False) # type: ignore
         if (with_ancestors or with_path) and cache:
             yield YieldFrom(ensure_attr_path(
                 client, 
@@ -2607,8 +2608,8 @@ def iter_files(
                 app=app, 
                 async_=async_, # type: ignore
                 **request_kwargs, 
-            ), identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+            ), may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -2735,8 +2736,7 @@ def traverse_files(
     def gen_step():
         nonlocal cid
         if auto_splitting_tasks:
-            get_count = partial(
-                get_file_count, 
+            get_count = get_file_count(
                 client, 
                 id_to_dirnode=id_to_dirnode, 
                 **{**request_kwargs, "timeout": auto_splitting_statistics_timeout}
@@ -2772,7 +2772,7 @@ def traverse_files(
                         max_workers=max_workers, 
                         async_=async_, # type: ignore
                         **request_kwargs, 
-                    ), identity=True)
+                    ), may_await=False)
                 else:
                     yield YieldFrom(iter_files(
                         client, 
@@ -2788,7 +2788,7 @@ def traverse_files(
                         max_workers=max_workers, 
                         async_=async_, # type: ignore
                         **request_kwargs, 
-                    ), identity=True)
+                    ), may_await=False)
             else:
                 with with_iter_next(iterdir(
                     client, 
@@ -2813,8 +2813,8 @@ def traverse_files(
                         type > 7 or 
                         type_of_attr(attr) == type
                     ):
-                        yield Yield(attr, identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+                        yield Yield(attr, may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -2907,8 +2907,8 @@ def iter_dirs(
             )) as get_next:
                 while True:
                     batch = yield get_next
-                    yield YieldFrom(batch, identity=True)
-        it = run_gen_step_iter(gen_step(it), async_=async_)
+                    yield YieldFrom(batch, may_await=False)
+        it = run_gen_step_iter(gen_step(it), simple=True, async_=async_)
     return it
 
 
@@ -3155,12 +3155,12 @@ def iter_image_files(
                 count = int(resp.get("count") or 0)
             if offset != resp["offset"]:
                 break
-            yield YieldFrom(map(normalize, resp["data"]), identity=True)
+            yield YieldFrom(map(normalize, resp["data"]), may_await=False)
             offset += len(resp["data"])
             if offset >= count:
                 break
             payload["offset"] = offset
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -3269,11 +3269,11 @@ def share_iterdir(
                         id_to_dirnode[oattr.id] = DirNode(oattr.name, oattr.parent_id)
                 if normalize_attr is not None:
                     attr = normalize_attr(attr)
-                yield Yield(attr, identity=True)
+                yield Yield(attr, may_await=False)
             payload["offset"] += page_size # type: ignore
             if payload["offset"] >= count: # type: ignore
                 break
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -3371,12 +3371,12 @@ def share_iter_files(
                             "name": info["fn"], 
                             "size": int(info["si"]), 
                             "path": f"/{info['pt']}/{info['fn']}", 
-                        }, identity=True)
+                        }, may_await=False)
                 else:
-                    yield Yield({k: attr[k] for k in ("id", "sha1", "name", "size", "path")}, identity=True)
+                    yield Yield({k: attr[k] for k in ("id", "sha1", "name", "size", "path")}, may_await=False)
         except (StopIteration, StopAsyncIteration):
             pass
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -3546,7 +3546,7 @@ def share_get_id_to_path(
                     if ensure_file is None or ensure_file ^ attr["is_dir"]:
                         return P115ID(attr["id"], attr, about="path")
         raise error
-    return run_gen_step(gen_step, async_=async_)
+    return run_gen_step(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -4058,7 +4058,7 @@ def iter_selected_nodes_using_star_event(
                     id_to_dirnode[fid] = DirNode(name, pid)
                 if fid in ids:
                     if not normalize_attr:
-                        yield Yield(event, identity=True)
+                        yield Yield(event, may_await=False)
                     elif normalize_attr is True:
                         attr = {
                             "id": fid, 
@@ -4080,15 +4080,15 @@ def iter_selected_nodes_using_star_event(
                             attr["type"] = 3
                         else:
                             attr["type"] = type_of_attr(attr)
-                        yield Yield(attr, identity=True)
+                        yield Yield(attr, may_await=False)
                     else:
-                        yield Yield(normalize_attr(event), identity=True)
+                        yield Yield(normalize_attr(event), may_await=False)
                     discard(fid)
                     if not ids:
                         break
         except (StopIteration, StopAsyncIteration):
             pass
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -4182,13 +4182,13 @@ def iter_selected_dirs_using_star(
                     break
                 cid = attr["id"]
                 if cid in ids:
-                    yield Yield(info, identity=True)
+                    yield Yield(info, may_await=False)
                     discard(cid)
                     if not ids:
                         break
         except (StopIteration, StopAsyncIteration):
             pass
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -4349,7 +4349,7 @@ def iter_files_with_dirname(
                 resp = yield get_next
                 for attr in resp["data"]:
                     attr.update(pid_to_info[attr["parent_id"]])
-                    yield Yield(attr, identity=True)
+                    yield Yield(attr, may_await=False)
         except (StopIteration, StopAsyncIteration):
             pass
     if with_parents_4_level:
@@ -4362,7 +4362,7 @@ def iter_files_with_dirname(
             it = iter_parents_3_level(
                 client, 
                 iter_unique((async_map if async_ else map)( 
-                    get_pid, run_gen_step_iter(gen_step, async_=async_))), # type: ignore
+                    get_pid, run_gen_step_iter(gen_step, simple=True, async_=async_))), # type: ignore
                 async_=async_, # type: ignore
                 **request_kwargs, 
             )
@@ -4375,9 +4375,9 @@ def iter_files_with_dirname(
             id_to_parents[0] = ("", "", "")
             for attr in files:
                 attr["parents"] = (attr["dir_name"], *id_to_parents[attr["parent_id"]])
-                yield Yield(attr, identity=True)
-        return run_gen_step_iter(gen_step2, async_=async_)
-    return run_gen_step_iter(gen_step, async_=async_)
+                yield Yield(attr, may_await=False)
+        return run_gen_step_iter(gen_step2, simple=True, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -4517,7 +4517,7 @@ def iter_files_with_path(
     _path_already: None | bool = None if path_already else False
     if not path_already:
         from .download import iter_download_nodes
-        def set_path_already(*a):
+        def set_path_already(*_):
             nonlocal _path_already
             _path_already = True
         def fetch_dirs(id: int | str, /):
@@ -4550,7 +4550,7 @@ def iter_files_with_path(
                 )) as get_next:
                     while True:
                         attr = yield get_next
-                        yield run_gen_step(fetch_dirs(attr["pickcode"]), async_=async_)
+                        yield run_gen_step(fetch_dirs(attr["pickcode"]), simple=True, async_=async_)
     if with_ancestors:
         id_to_ancestors: dict[int, list[dict]] = {}
         def get_ancestors(id: int, attr: dict | tuple[str, int] | DirNode, /) -> list[dict]:
@@ -4597,7 +4597,7 @@ def iter_files_with_path(
         add_to_cache = cache.append
         if not path_already:
             if async_:
-                task: Any = create_task(run_gen_step(fetch_dirs(cid), async_=True))
+                task: Any = create_task(run_gen_step(fetch_dirs(cid), simple=True, async_=True))
             else:
                 task = run_as_thread(run_gen_step, fetch_dirs(cid))
             task.add_done_callback(set_path_already)
@@ -4622,16 +4622,16 @@ def iter_files_with_path(
             while True:
                 attr = yield get_next
                 if _path_already is None:
-                    yield Yield(update_path(attr), identity=True)
+                    yield Yield(update_path(attr), may_await=False)
                 elif _path_already:
                     if async_:
                         yield task
                     else:
                         task.result()
                     if cache:
-                        yield YieldFrom(map(update_path, cache), identity=True)
+                        yield YieldFrom(map(update_path, cache), may_await=False)
                         cache.clear()
-                    yield Yield(update_path(attr), identity=True)
+                    yield Yield(update_path(attr), may_await=False)
                     _path_already = None
                 else:
                     add_to_cache(attr)
@@ -4640,8 +4640,8 @@ def iter_files_with_path(
                 yield task
             else:
                 task.result()
-            yield YieldFrom(map(update_path, cache), identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+            yield YieldFrom(map(update_path, cache), may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -4897,8 +4897,8 @@ def iter_files_with_path_by_export_dir(
                 if escape is not None:
                     name = escape(name)
                 attr["path"] = dir_path + name
-                yield Yield(attr, identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+                yield Yield(attr, may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -4989,7 +4989,7 @@ def iter_parents_3_level(
     ids = (async_filter if async_ else filter)(None, ids) # type: ignore
     return flatten(
         batch_map(
-            lambda ids, /: run_gen_step(get_parents(ids), async_=async_), 
+            lambda ids, /: run_gen_step(get_parents(ids), simple=True, async_=async_), 
             chunked(ids, 1150), 
             max_workers=max_workers, 
         ), 
@@ -5069,7 +5069,7 @@ def iter_dir_nodes(
                         id_to_dirnode[id] = DirNode(name, parent_id)
                     yield Yield(
                         {"id": id, "parent_id": parent_id, "name": name}, 
-                        identity=True, 
+                        may_await=False, 
                     )
         else:
             with with_iter_next(iterdir(
@@ -5088,11 +5088,90 @@ def iter_dir_nodes(
                             "parent_id": attr["parent_id"], 
                             "name": attr["name"], 
                         }, 
-                        identity=True, 
+                        may_await=False, 
                     )
                     yield YieldFrom(
-                        run_gen_step_iter(gen_step(attr["pickcode"]), async_=async_), 
-                        identity=True, 
+                        run_gen_step_iter(gen_step(attr["pickcode"]), simple=True, async_=async_), 
+                        may_await=False, 
                     )
-    return run_gen_step_iter(gen_step(cid or 0), async_=async_)
+    return run_gen_step_iter(gen_step(cid or 0), simple=True, async_=async_)
+
+
+@overload
+def search_for_any_file(
+    client: str | P115Client, 
+    cid: int = 0, 
+    search_value: str = ".", 
+    suffix: str = "", 
+    type: int = 99, 
+    app: str = "web", 
+    *, 
+    async_: Literal[False] = False, 
+    **request_kwargs, 
+) -> bool:
+    ...
+@overload
+def search_for_any_file(
+    client: str | P115Client, 
+    cid: int = 0, 
+    search_value: str = ".", 
+    suffix: str = "", 
+    type: int = 99, 
+    app: str = "web", 
+    *, 
+    async_: Literal[True], 
+    **request_kwargs, 
+) -> Coroutine[Any, Any, bool]:
+    ...
+def search_for_any_file(
+    client: str | P115Client, 
+    cid: int = 0, 
+    search_value: str = ".", 
+    suffix: str = "", 
+    type: int = 99, 
+    app: str = "web", 
+    *, 
+    async_: Literal[False, True] = False, 
+    **request_kwargs, 
+) -> bool | Coroutine[Any, Any, bool]:
+    """搜索以判断是否存在某种文件
+
+    :param client: 115 客户端或 cookies
+    :param cid: 目录 id
+    :param search_value: 搜索关键词，搜索到的文件名必须包含这个字符串
+    :param suffix: 后缀名（优先级高于 type）
+    :param type: 文件类型
+
+        - 1: 文档
+        - 2: 图片
+        - 3: 音频
+        - 4: 视频
+        - 5: 压缩包
+        - 6: 应用
+        - 7: 书籍
+        - 99: 仅文件
+
+    :param app: 使用某个 app （设备）的接口
+    :param async_: 是否异步
+    :param request_kwargs: 其它请求参数
+
+    :return: 是否存在某种文件
+    """
+    if isinstance(client, str):
+        client = P115Client(client, check_for_relogin=True)
+    if not isinstance(client, P115Client) or app == "open":
+        fs_search: Callable = client.fs_search_open
+    elif app in ("", "web", "desktop", "harmony"):
+        fs_search = partial(client.fs_search, app=app)
+    else:
+        fs_search = client.fs_search_app
+    def gen_step():
+        resp = yield fs_search(
+            {"cid": cid, "limit": 1, "search_value": search_value, "suffix": suffix, "type": type}, 
+            async_=async_, 
+            **request_kwargs, 
+        )
+        check_response(resp)
+        return bool(resp["data"])
+    return run_gen_step(gen_step, simple=True, async_=async_)
 

p115client/tool/life.py

@@ -137,14 +137,14 @@ def iter_life_list(
                 for items in data["list"]:
                     if "items" not in items:
                         if start_time < items["update_time"] < end_time:
-                            yield Yield(items, identity=True)
+                            yield Yield(items, may_await=False)
                         continue
                     behavior_type = items["behavior_type"]
                     date = items["date"]
                     for item in items["items"]:
                         item["behavior_type"] = behavior_type
                         item["date"] = date
-                        yield Yield(item, identity=True)
+                        yield Yield(item, may_await=False)
                     if behavior_type.startswith("upload_") or items["total"] > len(items["items"]):
                         seen_items: set[str] = {item["id"] for item in items["items"]}
                         payload = {"offset": 0, "limit": 32, "type": behavior_type, "date": date}
@@ -158,7 +158,7 @@ def iter_life_list(
                                 seen_items.add(item["id"])
                                 item["behavior_type"] = behavior_type
                                 item["date"] = date
-                                yield Yield(item, identity=True)
+                                yield Yield(item, may_await=False)
                             else:
                                 if not resp["data"]["next_page"]:
                                     break
@@ -172,7 +172,7 @@ def iter_life_list(
                 else:
                     sleep(1 - diff)
             end_time = int(time())
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -262,7 +262,7 @@ def iter_life_behavior_once(
                     return
                 fid = event["file_id"]
                 if fid not in seen:
-                    yield Yield(event, identity=True)
+                    yield Yield(event, may_await=False)
                     seen_add(fid)
             offset += len(events)
             if offset >= int(resp["data"]["count"]):
@@ -276,7 +276,7 @@ def iter_life_behavior_once(
             ts_last_call = time()
             resp = yield life_behavior_detail(payload, async_=async_)
             events = check_response(resp)["data"]["list"]
-    return run_gen_step_iter(gen_step, async_=async_)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -376,8 +376,8 @@ def iter_life_behavior(
                         sub_first_loop = False
                     if not type and ignore_types and event["type"] in ignore_types:
                         continue
-                    yield Yield(event, identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+                    yield Yield(event, may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 
 
 @overload
@@ -468,6 +468,6 @@ def iter_life_behavior_list(
                     if not type and ignore_types and event["type"] in ignore_types:
                         continue
                     push(event)
-            yield Yield(ls, identity=True)
-    return run_gen_step_iter(gen_step, async_=async_)
+            yield Yield(ls, may_await=False)
+    return run_gen_step_iter(gen_step, simple=True, async_=async_)
 

p115client/tool/pool.py

@@ -88,7 +88,7 @@ def generate_auth_factory(
                     "authorization": "Bearer " + resp["data"]["access_token"], 
                     "app_id": str(app_id), 
                 }
-        return run_gen_step(gen_step, async_=async_)
+        return run_gen_step(gen_step, simple=True, async_=async_)
     return make_cookies
 
 
@@ -142,7 +142,7 @@ def generate_cookies_factory(
                     "cookie": "; ".join(f"{k}={v}" for k, v in resp["data"]["cookie"].items()), 
                     "app": app, 
                 }
-        return run_gen_step(gen_step, async_=async_)
+        return run_gen_step(gen_step, simple=True, async_=async_)
     return make_cookies
 
 
@@ -165,7 +165,7 @@ def generate_client_factory(
         def gen_step():
             headers = yield call(async_=async_)
             return cls(headers["cookie"])
-        return run_gen_step(gen_step, async_=async_)
+        return run_gen_step(gen_step, simple=True, async_=async_)
     return make_client
 
 
@@ -215,7 +215,7 @@ def make_pool[T](
                     value = generate()
                 val = ComparedWithID(value)
             return value, partial(heappush, heap_, (time(), val))
-        return run_gen_step(call, async_=async_)
+        return run_gen_step(call, simple=True, async_=async_)
     if not lock:
         setattr(get_value, "heap", heap_)
         return get_value
@@ -377,7 +377,7 @@ def call_wrap_with_pool(get_cert_headers: Callable, /, func: Callable) -> Callab
                     if not isinstance(e, (AuthenticationError, LoginError)) and get_status_code(e) != 405:
                         revert()
                         raise
-        return run_gen_step(gen_step, async_=async_)
+        return run_gen_step(gen_step, simple=True, async_=async_)
     return update_wrapper(wrapper, func)