p115client 0.0.5.12.3__py3-none-any.whl → 0.0.5.13__py3-none-any.whl

p115client/tool/download.py

@@ -10,12 +10,13 @@ __all__ = [
 __doc__ = "这个模块提供了一些和下载有关的函数"
 
 from asyncio import create_task, to_thread, Queue as AsyncQueue, TaskGroup
-from collections.abc import AsyncIterator, Callable, Coroutine, Iterable, Iterator, MutableMapping
+from collections.abc import (
+    AsyncIterator, Callable, Coroutine, Iterable, Iterator, MutableMapping, 
+)
 from concurrent.futures import ThreadPoolExecutor
-from errno import ENOTDIR
 from functools import partial
 from glob import iglob
-from itertools import chain, count, cycle, islice
+from itertools import batched, chain, count, cycle
 from os import fsdecode, makedirs, remove, PathLike
 from os.path import abspath, dirname, join as joinpath, normpath, splitext
 from queue import SimpleQueue
@@ -28,15 +29,22 @@ from urllib.request import urlopen, Request
 from uuid import uuid4
 from warnings import warn
 
-from asynctools import async_chain_from_iterable
+from asynctools import async_chain
 from concurrenttools import run_as_thread, thread_batch, async_batch
 from encode_uri import encode_uri_component_loose
-from iterutils import chunked, run_gen_step, run_gen_step_iter, with_iter_next, Yield, YieldFrom
-from p115client import check_response, normalize_attr, normalize_attr_simple, P115Client, P115URL
+from iterutils import (
+    as_gen_step, chunked, run_gen_step, run_gen_step_iter, through, 
+    with_iter_next, Yield, YieldFrom, 
+)
+from p115client import (
+    check_response, normalize_attr, normalize_attr_simple, P115Client, 
+    P115OpenClient, P115URL, 
+)
 from p115client.exception import P115Warning
+from p115pickcode import to_id, to_pickcode
 
 from .iterdir import (
-    get_path_to_cid, iterdir, iter_files, iter_files_raw, iter_files_with_path, 
+    get_path_to_cid, iterdir, iter_files, iter_files_with_path, 
     unescape_115_charref, posix_escape_name, DirNode, ID_TO_DIRNODE_CACHE, 
 )
 from .util import reduce_image_url_layers
@@ -44,9 +52,10 @@ from .util import reduce_image_url_layers
 
 @overload
 def batch_get_url(
-    client: str | P115Client, 
-    id_or_pickcode: int | str | Iterable[int | str], 
+    client: str | P115Client | P115OpenClient, 
+    pickcode: int | str | Iterable[int | str], 
     user_agent: str = "", 
+    app: str = "android", 
     *, 
     async_: Literal[False] = False, 
     **request_kwargs, 
@@ -54,32 +63,30 @@ def batch_get_url(
     ...
 @overload
 def batch_get_url(
-    client: str | P115Client, 
-    id_or_pickcode: int | str | Iterable[int | str], 
+    client: str | P115Client | P115OpenClient, 
+    pickcode: int | str | Iterable[int | str], 
     user_agent: str = "", 
+    app: str = "android", 
     *, 
     async_: Literal[True], 
     **request_kwargs, 
 ) -> Coroutine[Any, Any, dict[int, P115URL]]:
     ...
 def batch_get_url(
-    client: str | P115Client, 
-    id_or_pickcode: int | str | Iterable[int | str], 
+    client: str | P115Client | P115OpenClient, 
+    pickcode: int | str | Iterable[int | str], 
     user_agent: str = "", 
+    app: str = "android", 
     *, 
     async_: Literal[False, True] = False, 
     **request_kwargs, 
 ) -> dict[int, P115URL] | Coroutine[Any, Any, dict[int, P115URL]]:
     """批量获取下载链接
 
-    .. attention::
-        请确保所有的 pickcode 都是有效的，要么是现在存在的，要么是以前存在过被删除的。
-
-        如果有目录的 pickcode 混在其中，则会自动排除。
-
     :param client: 115 客户端或 cookies
-    :param id_or_pickcode: 如果是 int，视为 id，如果是 str，视为 pickcode
+    :param pickcode: pickcode 或 id
     :param user_agent: "user-agent" 请求头的值
+    :param app: 使用指定 app（设备）的接口
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -91,41 +98,16 @@ def batch_get_url(
         request_kwargs["headers"] = dict(headers, **{"user-agent": user_agent})
     else:
         request_kwargs["headers"] = {"user-agent": user_agent}
+    if isinstance(pickcode, (int, str)):
+        pickcode = to_pickcode(pickcode)
+    elif not isinstance(pickcode, str):
+        pickcode = ",".join(map(to_pickcode, pickcode))
+    if not isinstance(client, P115Client) or app == "open":
+        get_download_url: Callable = client.download_url_info_open
+    else:
+        get_download_url = partial(client.download_url_app, app=app)
     def gen_step():
-        if isinstance(id_or_pickcode, int):
-            resp = yield client.fs_file_skim(
-                id_or_pickcode, 
-                async_=async_, 
-                **request_kwargs, 
-            )
-            if not resp or not resp["state"]:
-                return {}
-            pickcode = resp["data"][0]["pick_code"]
-        elif isinstance(id_or_pickcode, str):
-            pickcode = id_or_pickcode
-            if not (len(pickcode) == 17 and pickcode.isalnum()):
-                return {}
-        else:
-            ids: list[int] = []
-            pickcodes: list[str] = []
-            for val in id_or_pickcode:
-                if isinstance(val, int):
-                    ids.append(val)
-                elif len(val) == 17 and val.isalnum():
-                    pickcodes.append(val)
-            if ids:
-                resp = yield client.fs_file_skim(
-                    ids, 
-                    method="POST", 
-                    async_=async_, 
-                    **request_kwargs, 
-                )
-                if resp and resp["state"]:
-                    pickcodes.extend(info["pick_code"] for info in resp["data"])
-            if not pickcodes:
-                return {}
-            pickcode = ",".join(pickcodes)
-        resp = yield client.download_url_app(pickcode, async_=async_, **request_kwargs)
+        resp = yield get_download_url(pickcode, async_=async_, **request_kwargs)
         if not resp["state"]:
             if resp.get("errno") != 50003:
                 check_response(resp)
@@ -139,7 +121,7 @@ def batch_get_url(
                 name=info["file_name"], 
                 size=int(info["file_size"]), 
                 sha1=info["sha1"], 
-                is_directory=False,
+                is_dir=False,
                 headers=headers, 
             )
             for id, info in resp["data"].items()
@@ -150,10 +132,11 @@ def batch_get_url(
 
 @overload
 def iter_url_batches(
-    client: str | P115Client, 
-    pickcodes: Iterator[str], 
+    client: str | P115Client | P115OpenClient, 
+    pickcodes: Iterator[int | str], 
     user_agent: str = "", 
     batch_size: int = 10, 
+    app: str = "android", 
     *, 
     async_: Literal[False] = False, 
     **request_kwargs, 
@@ -161,20 +144,22 @@ def iter_url_batches(
     ...
 @overload
 def iter_url_batches(
-    client: str | P115Client, 
-    pickcodes: Iterator[str], 
+    client: str | P115Client | P115OpenClient, 
+    pickcodes: Iterator[int | str], 
     user_agent: str = "", 
     batch_size: int = 10, 
+    app: str = "android", 
     *, 
     async_: Literal[True], 
     **request_kwargs, 
 ) -> AsyncIterator[P115URL]:
     ...
 def iter_url_batches(
-    client: str | P115Client, 
-    pickcodes: Iterator[str], 
+    client: str | P115Client | P115OpenClient, 
+    pickcodes: Iterator[int | str], 
     user_agent: str = "", 
     batch_size: int = 10, 
+    app: str = "android", 
     *, 
     async_: Literal[False, True] = False, 
     **request_kwargs, 
@@ -187,9 +172,10 @@ def iter_url_batches(
         如果有目录的 pickcode 混在其中，则会自动排除。
 
     :param client: 115 客户端或 cookies
-    :param pickcodes: 一个迭代器，产生提取码 pickcode
+    :param pickcodes: 一个迭代器，产生 pickcode 或 id
     :param user_agent: "user-agent" 请求头的值
     :param batch_size: 每一个批次处理的个量
+    :param app: 使用指定 app（设备）的接口
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -201,13 +187,16 @@ def iter_url_batches(
         request_kwargs["headers"] = dict(headers, **{"user-agent": user_agent})
     else:
         request_kwargs["headers"] = {"user-agent": user_agent}
+    if not isinstance(client, P115Client) or app == "open":
+        get_download_url: Callable = client.download_url_info_open
+    else:
+        get_download_url = partial(client.download_url_app, app=app)
     if batch_size <= 0:
         batch_size = 1
     def gen_step():
-        it = iter(pickcodes)
-        while pcs := ",".join(islice(it, batch_size)):
-            resp = yield client.download_url_app(
-                pcs, 
+        for pcs in batched(map(to_pickcode, pickcodes), batch_size):
+            resp = yield get_download_url(
+                ",".join(pcs), 
                 async_=async_, 
                 **request_kwargs, 
             )
@@ -225,7 +214,7 @@ def iter_url_batches(
                         name=info["file_name"], 
                         size=int(info["file_size"]), 
                         sha1=info["sha1"], 
-                        is_directory=False,
+                        is_dir=False,
                         headers=headers, 
                     ))
     return run_gen_step_iter(gen_step, async_)
@@ -233,8 +222,8 @@ def iter_url_batches(
 
 @overload
 def iter_files_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: None | str | Iterable[str] = None, 
     type: Literal[1, 2, 3, 4, 5, 6, 7, 99] = 99, 
     cur: Literal[0, 1] = 0, 
@@ -254,8 +243,8 @@ def iter_files_with_url(
     ...
 @overload
 def iter_files_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: None | str | Iterable[str] = None, 
     type: Literal[1, 2, 3, 4, 5, 6, 7, 99] = 99, 
     cur: Literal[0, 1] = 0, 
@@ -274,8 +263,8 @@ def iter_files_with_url(
 ) -> AsyncIterator[dict]:
     ...
 def iter_files_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: None | str | Iterable[str] = None, 
     type: Literal[1, 2, 3, 4, 5, 6, 7, 99] = 99, 
     cur: Literal[0, 1] = 0, 
@@ -295,7 +284,7 @@ def iter_files_with_url(
     """获取文件信息和下载链接
 
     :param client: 115 客户端或 cookies
-    :param cid: 目录 id
+    :param cid: 目录 id 或 pickcode
     :param suffixes: 扩展名，可以有多个，最前面的 "." 可以省略
     :param type: 文件类型
 
@@ -321,7 +310,7 @@ def iter_files_with_url(
 
     :param normalize_attr: 把数据进行转换处理，使之便于阅读
     :param id_to_dirnode: 字典，保存 id 到对应文件的 `DirNode(name, parent_id)` 命名元组的字典
-    :param app: 使用某个 app （设备）的接口
+    :param app: 使用指定 app（设备）的接口
     :param raise_for_changed_count: 分批拉取时，发现总数发生变化后，是否报错
     :param user_agent: "user-agent" 请求头的值
     :param async_: 是否异步
@@ -349,6 +338,7 @@ def iter_files_with_url(
         get_url = client.download_url
     else:
         get_url = partial(client.download_url, app=app)
+    cid = to_id(cid)
     def gen_step():
         if suffixes is None:
             it = iter_files(
@@ -386,7 +376,7 @@ def iter_files_with_url(
         with with_iter_next(it) as get_next:
             while True:
                 attr = yield get_next()
-                if attr.get("violated", False):
+                if attr.get("is_collect", False):
                     if attr["size"] < 1024 * 1024 * 115:
                         attr["url"] = yield get_url(
                             attr["pickcode"], 
@@ -408,8 +398,8 @@ def iter_files_with_url(
 
 @overload
 def iter_images_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: None | str | Iterable[str] = None, 
     cur: Literal[0, 1] = 0, 
     with_ancestors: bool = False, 
@@ -427,8 +417,8 @@ def iter_images_with_url(
     ...
 @overload
 def iter_images_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: None | str | Iterable[str] = None, 
     cur: Literal[0, 1] = 0, 
     with_ancestors: bool = False, 
@@ -445,8 +435,8 @@ def iter_images_with_url(
 ) -> AsyncIterator[dict]:
     ...
 def iter_images_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: None | str | Iterable[str] = None, 
     cur: Literal[0, 1] = 0, 
     with_ancestors: bool = False, 
@@ -467,7 +457,7 @@ def iter_images_with_url(
         请不要把不能被 115 识别为图片的文件扩展名放在 `suffixes` 参数中传入，这只是浪费时间，最后也只能获得普通的下载链接
 
     :param client: 115 客户端或 cookies
-    :param cid: 目录 id
+    :param cid: 目录 id 或 pickcode
     :param suffixes: 扩展名，可以有多个，最前面的 "." 可以省略（请确保扩展名确实能被 115 认为是图片，否则会因为不能批量获取到链接而浪费一些时间再去单独生成下载链接）；如果不传（默认），则会获取所有图片
     :param cur: 仅当前目录。0: 否（将遍历子目录树上所有叶子节点），1: 是
     :param with_ancestors: 文件信息中是否要包含 "ancestors"
@@ -482,7 +472,7 @@ def iter_images_with_url(
 
     :param normalize_attr: 把数据进行转换处理，使之便于阅读
     :param id_to_dirnode: 字典，保存 id 到对应文件的 `DirNode(name, parent_id)` 命名元组的字典
-    :param app: 使用某个 app （设备）的接口
+    :param app: 使用指定 app（设备）的接口
     :param raise_for_changed_count: 分批拉取时，发现总数发生变化后，是否报错
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
@@ -509,6 +499,7 @@ def iter_images_with_url(
         get_url = client.download_url
     else:
         get_url = partial(client.download_url, app=app)
+    cid = to_id(cid)
     def gen_step():
         if suffixes is None:
             it = iter_files(
@@ -544,7 +535,7 @@ def iter_images_with_url(
                 try:
                     attr["url"] = reduce_image_url_layers(attr["thumb"])
                 except KeyError:
-                    if attr.get("violated", False):
+                    if attr.get("is_collect", False):
                         if attr["size"] < 1024 * 1024 * 115:
                             attr["url"] = yield get_url(
                                 attr["pickcode"], 
@@ -566,8 +557,8 @@ def iter_images_with_url(
 
 @overload
 def iter_subtitles_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: str | Iterable[str] = (".srt", ".ass", ".ssa"), 
     cur: Literal[0, 1] = 0, 
     with_ancestors: bool = False, 
@@ -585,8 +576,8 @@ def iter_subtitles_with_url(
     ...
 @overload
 def iter_subtitles_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: str | Iterable[str] = (".srt", ".ass", ".ssa"), 
     cur: Literal[0, 1] = 0, 
     with_ancestors: bool = False, 
@@ -603,8 +594,8 @@ def iter_subtitles_with_url(
 ) -> AsyncIterator[dict]:
     ...
 def iter_subtitles_with_url(
-    client: str | P115Client, 
-    cid: int = 0, 
+    client: str | P115Client | P115OpenClient, 
+    cid: int | str = 0, 
     suffixes: str | Iterable[str] = (".srt", ".ass", ".ssa"), 
     cur: Literal[0, 1] = 0, 
     with_ancestors: bool = False, 
@@ -630,7 +621,7 @@ def iter_subtitles_with_url(
         请不要把不能被 115 识别为字幕的文件扩展名放在 `suffixes` 参数中传入，这只是浪费时间，最后也只能获得普通的下载链接
 
     :param client: 115 客户端或 cookies
-    :param cid: 目录 id
+    :param cid: 目录 id 或 pickcode
     :param suffixes: 扩展名，可以有多个，最前面的 "." 可以省略（请确保扩展名确实能被 115 认为是字幕，否则会因为不能批量获取到链接而浪费一些时间再去单独生成下载链接）
     :param cur: 仅当前目录。0: 否（将遍历子目录树上所有叶子节点），1: 是
     :param with_ancestors: 文件信息中是否要包含 "ancestors"
@@ -645,7 +636,7 @@ def iter_subtitles_with_url(
 
     :param normalize_attr: 把数据进行转换处理，使之便于阅读
     :param id_to_dirnode: 字典，保存 id 到对应文件的 `DirNode(name, parent_id)` 命名元组的字典
-    :param app: 使用某个 app （设备）的接口
+    :param app: 使用指定 app（设备）的接口
     :param raise_for_changed_count: 分批拉取时，发现总数发生变化后，是否报错
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
@@ -656,16 +647,30 @@ def iter_subtitles_with_url(
         client = P115Client(client, check_for_relogin=True)
     if not isinstance(client, P115Client) or app == "open":
         get_url: Callable[..., P115URL] = client.download_url_open
+        fs_mkdir: Callable = client.fs_mkdir_open
+        fs_copy: Callable = client.fs_copy_open
+        fs_delete: Callable = client.fs_delete_open
+        fs_video_subtitle: Callable = client.fs_video_subtitle_open
     elif app in ("", "web", "desktop", "harmony"):
         get_url = client.download_url
+        fs_mkdir = client.fs_mkdir
+        fs_copy = client.fs_copy
+        fs_delete = client.fs_delete
+        fs_video_subtitle = client.fs_video_subtitle
     else:
         get_url = partial(client.download_url, app=app)
+        fs_mkdir = partial(client.fs_mkdir_app, app=app)
+        fs_copy = partial(client.fs_copy_app, app=app)
+        fs_delete = partial(client.fs_delete_app, app=app)
+        fs_video_subtitle = partial(client.fs_video_subtitle_app, app=app)
+    cid = to_id(cid)
     def gen_step():
         nonlocal suffixes
         if isinstance(suffixes, str):
             suffixes = suffixes,
-        do_chain: Callable = async_chain_from_iterable if async_ else chain.from_iterable
-        it = chunked(do_chain(
+        do_chain: Callable = async_chain.from_iterable if async_ else chain.from_iterable
+        do_next = anext if async_ else next
+        with with_iter_next(chunked(do_chain(
             iter_files(
                 client, 
                 cid, 
@@ -683,35 +688,42 @@ def iter_subtitles_with_url(
                 **request_kwargs, 
             )
             for suffix in suffixes
-        ), 1000)
-        do_next = anext if async_ else next
-        with with_iter_next(it) as get_next:
+        ), 1000)) as get_next:
             while True:
                 items: tuple[dict] = yield get_next()
-                resp = yield client.fs_mkdir(
+                resp = yield fs_mkdir(
                     f"subtitle-{uuid4()}", 
                     async_=async_, 
                     **request_kwargs, 
                 )
                 check_response(resp)
                 try:
-                    scid = resp["cid"]
-                    resp = yield client.fs_copy(
+                    if "cid" in resp:
+                        scid = resp["cid"]
+                    else:
+                        data = resp["data"]
+                        if "category_id" in data:
+                            scid = data["category_id"]
+                        else:
+                            scid = data["file_id"]
+                    resp = yield fs_copy(
                         (attr["id"] for attr in items), 
                         pid=scid, 
                         async_=async_, 
                         **request_kwargs, 
                     )
                     check_response(resp)
-                    attr = yield do_next(iter_files_raw(
+                    attr = yield do_next(iter_files(
                         client, 
                         scid, 
                         first_page_size=1, 
+                        normalize_attr=None, 
                         base_url=True, 
+                        app=app, 
                         async_=async_, # type: ignore
                         **request_kwargs, 
                     ))
-                    resp = yield client.fs_video_subtitle(
+                    resp = yield fs_video_subtitle(
                         attr["pc"], 
                         async_=async_, 
                         **request_kwargs, 
@@ -722,14 +734,14 @@ def iter_subtitles_with_url(
                         if info.get("file_id")
                     }
                 finally:
-                    yield client.fs_delete(scid, async_=async_, **request_kwargs)
+                    yield fs_delete(scid, async_=async_, **request_kwargs)
                 if subtitles:
                     for attr in items:
                         attr["url"] = subtitles[attr["sha1"]]
                         yield Yield(attr)
                 else:
                     for attr in items:
-                        if attr.get("violated", False):
+                        if attr.get("is_collect", False):
                             if attr["size"] < 1024 * 1024 * 115:
                                 attr["url"] = yield get_url(
                                     attr["pickcode"], 
@@ -751,9 +763,10 @@ def iter_subtitles_with_url(
 
 @overload
 def iter_subtitle_batches(
-    client: str | P115Client, 
-    file_ids: Iterable[int], 
+    client: str | P115Client | P115OpenClient, 
+    file_ids: Iterable[int | str], 
     batch_size: int = 1_000, 
+    app: str = "web", 
     *, 
     async_: Literal[False] = False, 
     **request_kwargs, 
@@ -761,18 +774,20 @@ def iter_subtitle_batches(
     ...
 @overload
 def iter_subtitle_batches(
-    client: str | P115Client, 
-    file_ids: Iterable[int], 
+    client: str | P115Client | P115OpenClient, 
+    file_ids: Iterable[int | str], 
     batch_size: int = 1_000, 
+    app: str = "web", 
     *, 
     async_: Literal[True], 
     **request_kwargs, 
 ) -> AsyncIterator[dict]:
     ...
 def iter_subtitle_batches(
-    client: str | P115Client, 
-    file_ids: Iterable[int], 
+    client: str | P115Client | P115OpenClient, 
+    file_ids: Iterable[int | str], 
     batch_size: int = 1_000, 
+    app: str = "web", 
     *, 
     async_: Literal[False, True] = False, 
     **request_kwargs, 
@@ -786,7 +801,7 @@ def iter_subtitle_batches(
         目前看来 115 只支持：".srt"、".ass"、".ssa"，如果不能被 115 识别为字幕，将会被自动略过
 
     :param client: 115 客户端或 cookies
-    :param file_ids: 一组文件的 id（必须全是 115 所认为的字幕）
+    :param file_ids: 一组文件的 id 或 pickcode
     :param batch_size: 每一个批次处理的个量
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
@@ -797,33 +812,50 @@ def iter_subtitle_batches(
         client = P115Client(client, check_for_relogin=True)
     if batch_size <= 0:
         batch_size = 1_000
+    if not isinstance(client, P115Client) or app == "open":
+        fs_mkdir: Callable = client.fs_mkdir_open
+        fs_copy: Callable = client.fs_copy_open
+        fs_delete: Callable = client.fs_delete_open
+        fs_video_subtitle: Callable = client.fs_video_subtitle_open
+    elif app in ("", "web", "desktop", "harmony"):
+        fs_mkdir = client.fs_mkdir
+        fs_copy = client.fs_copy
+        fs_delete = client.fs_delete
+        fs_video_subtitle = client.fs_video_subtitle
+    else:
+        fs_mkdir = partial(client.fs_mkdir_app, app=app)
+        fs_copy = partial(client.fs_copy_app, app=app)
+        fs_delete = partial(client.fs_delete_app, app=app)
+        fs_video_subtitle = partial(client.fs_video_subtitle_app, app=app)
     def gen_step():
         do_next: Callable = anext if async_ else next
-        for ids in chunked(file_ids, batch_size):
+        for ids in batched(map(to_id, file_ids), batch_size):
             try:
-                resp = yield client.fs_mkdir(
+                resp = yield fs_mkdir(
                     f"subtitle-{uuid4()}", 
                     async_=async_, 
                     **request_kwargs, 
                 )
                 check_response(resp)
                 scid = resp["cid"]
-                resp = yield client.fs_copy(
+                resp = yield fs_copy(
                     ids, 
                     pid=scid, 
                     async_=async_, 
                     **request_kwargs, 
                 )
                 check_response(resp)
-                attr = yield do_next(iter_files_raw(
+                attr = yield do_next(iter_files(
                     client, 
                     scid, 
                     first_page_size=1, 
+                    normalize_attr=None, 
                     base_url=True, 
-                    async_=async_, 
+                    app=app, 
+                    async_=async_, # type: ignore
                     **request_kwargs, 
                 ))
-                resp = yield client.fs_video_subtitle(
+                resp = yield fs_video_subtitle(
                     attr["pc"], 
                     async_=async_, 
                     **request_kwargs, 
@@ -835,14 +867,15 @@ def iter_subtitle_batches(
             except (StopIteration, StopAsyncIteration):
                 pass
             finally:
-                yield client.fs_delete(scid, async_=async_, **request_kwargs)
+                yield fs_delete(scid, async_=async_, **request_kwargs)
     return run_gen_step_iter(gen_step, async_)
 
 
+# TODO: 要支持 open 接口
 @overload
 def make_strm(
     client: str | P115Client, 
-    cid: int = 0, 
+    cid: int | str = 0, 
     save_dir: bytes | str | PathLike = ".", 
     origin: str = "http://localhost:8000", 
     update: bool = False, 
@@ -868,7 +901,7 @@ def make_strm(
 @overload
 def make_strm(
     client: str | P115Client, 
-    cid: int = 0, 
+    cid: int | str = 0, 
     save_dir: bytes | str | PathLike = ".", 
     origin: str = "http://localhost:8000", 
     update: bool = False, 
@@ -893,7 +926,7 @@ def make_strm(
     ...
 def make_strm(
     client: str | P115Client, 
-    cid: int = 0, 
+    cid: int | str = 0, 
     save_dir: bytes | str | PathLike = ".", 
     origin: str = "http://localhost:8000", 
     update: bool = False, 
@@ -918,7 +951,7 @@ def make_strm(
     """生成 strm 保存到本地
 
     :param client: 115 客户端或 cookies
-    :param cid: 目录 id
+    :param cid: 目录 id 或 pickcode
     :param save_dir: 本地的保存目录，默认是当前工作目录
     :param origin: strm 文件的 `HTTP 源 <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin>`_
     :param update: 是否更新 strm 文件，如果为 False，则跳过已存在的路径
@@ -951,7 +984,7 @@ def make_strm(
     :param max_workers: 最大并发数，主要用于限制同时打开的文件数
     :param id_to_dirnode: 字典，保存 id 到对应文件的 `DirNode(name, parent_id)` 命名元组的字典
     :param path_already: 如果为 True，则说明 id_to_dirnode 中已经具备构建路径所需要的目录节点，所以不会再去拉取目录节点的信息
-    :param app: 使用某个 app （设备）的接口
+    :param app: 使用指定 app（设备）的接口
     :param fs_files_cooldown: `fs_files` 接口调用的冷却时间，大于 0，则使用此时间间隔执行并发
     :param fs_files_max_workers: `fs_files` 接口调用的最大并发数
     :param async_: 是否异步
@@ -1039,6 +1072,7 @@ def make_strm(
             append(ignored, path)
             return
         append(upserted, path)
+    cid = to_id(cid)
     def gen_step():
         nonlocal abspath_prefix_length, savedir
         start_t = time()
@@ -1120,8 +1154,10 @@ def make_strm(
 @overload
 def iter_download_nodes(
     client: str | P115Client, 
-    pickcode: int | str = "", 
+    pickcode: str | int = "", 
     files: bool = True, 
+    ensure_name: bool = False, 
+    id_to_dirnode: None | EllipsisType | MutableMapping[int, tuple[str, int] | DirNode] = ..., 
     max_workers: None | int = 1, 
     app: str = "android", 
     *, 
@@ -1132,8 +1168,10 @@ def iter_download_nodes(
 @overload
 def iter_download_nodes(
     client: str | P115Client, 
-    pickcode: int | str = "", 
+    pickcode: str | int = "", 
     files: bool = True, 
+    ensure_name: bool = False, 
+    id_to_dirnode: None | EllipsisType | MutableMapping[int, tuple[str, int] | DirNode] = ..., 
     max_workers: None | int = 1, 
     app: str = "android", 
     *, 
@@ -1143,8 +1181,10 @@ def iter_download_nodes(
     ...
 def iter_download_nodes(
     client: str | P115Client, 
-    pickcode: int | str = "", 
+    pickcode: str | int = "", 
     files: bool = True, 
+    ensure_name: bool = False, 
+    id_to_dirnode: None | EllipsisType | MutableMapping[int, tuple[str, int] | DirNode] = ..., 
     max_workers: None | int = 1, 
     app: str = "android", 
     *, 
@@ -1154,10 +1194,12 @@ def iter_download_nodes(
     """获取一个目录内所有的文件或者目录的信息（简略）
 
     :param client: 115 客户端或 cookies
-    :param pickcode: 目录的 提取码 或者 id
+    :param pickcode: 目录的 pickcode 或 id
     :param files: 如果为 True，则只获取文件，否则只获取目录
-    :param max_workers: 最大并发数，如果为 None 或 <= 0，则默认为 20
-    :param app: 使用某个 app （设备）的接口
+    :param ensure_name: 确保返回数据中有 "name" 字段
+    :param id_to_dirnode: 字典，保存 id 到对应文件的 `DirNode(name, parent_id)` 命名元组的字典
+    :param max_workers: 最大并发数，如果为 None 或 <= 0，则自动确定
+    :param app: 使用指定 app（设备）的接口
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -1166,23 +1208,69 @@ def iter_download_nodes(
     if isinstance(client, str):
         client = P115Client(client, check_for_relogin=True)
     get_base_url = cycle(("http://proapi.115.com", "https://proapi.115.com")).__next__
+    if async_:
+        if max_workers is None or max_workers <= 0:
+            max_workers = 20
+    elif max_workers is not None and max_workers <= 0:
+        max_workers = None
     if files:
         method = client.download_files
     else:
         method = client.download_folders
-    get_nodes = partial(method, async_=async_, **{"base_url": get_base_url, **request_kwargs})
+        if id_to_dirnode is None:
+            id_to_dirnode = ID_TO_DIRNODE_CACHE[client.user_id]
+    file_skim = client.fs_file_skim
+    @as_gen_step
+    def normalize_attrs(attrs: list[dict], /):
+        if files:
+            for i, info in enumerate(attrs):
+                attrs[i] = {
+                    "is_dir": False, 
+                    "id": to_id(info["pc"]), 
+                    "pickcode": info["pc"], 
+                    "parent_id": int(info["pid"]), 
+                    "size": info["fs"], 
+                }
+            if ensure_name:
+                resp = yield file_skim(
+                    (a["id"] for a in attrs), 
+                    method="POST", 
+                    async_=async_, 
+                    **request_kwargs, 
+                )
+                if resp.get("error") != "文件不存在":
+                    check_response(resp)
+                    nodes = {int(a["file_id"]): a for a in resp["data"]}
+                    for attr in attrs:
+                        if node := nodes.get(attr["id"]):
+                            attr["sha1"] = node["sha1"]
+                            attr["name"] = unescape_115_charref(node["file_name"])
+        else:
+            for i, info in enumerate(attrs):
+                attrs[i] = {
+                    "is_dir": True, 
+                    "id": int(info["fid"]), 
+                    "name": info["fn"], 
+                    "parent_id": int(info["pid"]), 
+                }
+            if id_to_dirnode is not ... and id_to_dirnode is not None:
+                for attr in attrs:
+                    id_to_dirnode[attr["id"]] = DirNode(attr["name"], attr["parent_id"])
+        return attrs
+    get_nodes = partial(
+        method, 
+        async_=async_, 
+        **{"base_url": get_base_url, **request_kwargs}, 
+    )
     if max_workers == 1:
-        def gen_step(pickcode):
-            if isinstance(pickcode, int):
-                resp = yield client.fs_file_skim(pickcode, async_=async_, **request_kwargs)
-                check_response(resp)
-                pickcode = resp["data"][0]["pick_code"]
+        def gen_step(pickcode: int | str, /):
+            pickcode = to_pickcode(pickcode)
             for i in count(1):
                 payload = {"pickcode": pickcode, "page": i}
                 resp = yield get_nodes(payload)
                 check_response(resp)
                 data = resp["data"]
-                yield YieldFrom(data["list"])
+                yield YieldFrom(normalize_attrs(data["list"]))
                 if not data["has_next_page"]:
                     break
     else:
@@ -1193,7 +1281,8 @@ def iter_download_nodes(
         else:
             q = SimpleQueue()
         get, put = q.get, q.put_nowait
-        def request(pickcode):
+        @as_gen_step
+        def request(pickcode: str, /):
             nonlocal max_page
             while True:
                 page = get_next_page()
@@ -1206,37 +1295,23 @@ def iter_download_nodes(
                     put(e)
                     return
                 data = resp["data"]
-                put(data["list"])
+                put((yield normalize_attrs(data["list"])))
                 if not data["has_next_page"]:
                     max_page = page
-        def gen_step(pickcode):
-            nonlocal max_workers, max_page, get_next_page
-            max_page = 0
-            get_next_page = count(1).__next__
+        def gen_step(pickcode: int | str, /):
             if async_:
-                if max_workers is None or max_workers <= 0:
-                    max_workers = 20
-                n = max_workers
+                n = cast(int, max_workers)
                 task_group = TaskGroup()
                 yield task_group.__aenter__()
                 create_task = task_group.create_task
                 submit: Callable = lambda f, /, *a, **k: create_task(f(*a, **k))
                 shutdown: Callable = lambda: task_group.__aexit__(None, None, None)
             else:
-                if max_workers is not None and max_workers <= 0:
-                    max_workers = None
                 executor = ThreadPoolExecutor(max_workers)
                 n = executor._max_workers
                 submit = executor.submit
                 shutdown = lambda: executor.shutdown(False, cancel_futures=True)
-            if isinstance(pickcode, int):
-                resp = yield client.fs_file_skim(
-                    pickcode, 
-                    async_=async_, # type: ignore
-                    **request_kwargs, 
-                )
-                check_response(resp)
-                pickcode = resp["data"][0]["pick_code"]
+            pickcode = to_pickcode(pickcode)
             try:
                 sentinel = object()
                 countdown: Callable
@@ -1253,8 +1328,8 @@ def iter_download_nodes(
                             n -= 1
                             if not n:
                                 put(sentinel)
-                for i in range(n):
-                    submit(run_gen_step, request(pickcode), async_=async_).add_done_callback(countdown)
+                for _ in range(n):
+                    submit(request, pickcode, async_=async_).add_done_callback(countdown)
                 while True:
                     ls = yield get()
                     if ls is sentinel:
@@ -1268,29 +1343,38 @@ def iter_download_nodes(
         return run_gen_step_iter(gen_step(pickcode), async_)
     else:
         def chain():
+            nonlocal max_page, get_next_page
+            pickcodes: list[str] = []
+            add_pickcode = pickcodes.append
             with with_iter_next(iterdir(
                 client, 
-                ensure_file=False, 
+                ensure_file=None if files else False, 
                 app=app, 
                 normalize_attr=normalize_attr_simple, 
+                id_to_dirnode=id_to_dirnode, 
                 raise_for_changed_count=True, 
                 async_=async_, 
                 **request_kwargs, 
             )) as get_next:
                 while True:
                     attr = yield get_next()
-                    if not files:
-                        yield Yield(
-                            {"fid": str(attr["id"]), "pid": "0", "fn": attr["name"]}
-                        )
-                    yield YieldFrom(run_gen_step_iter(gen_step(attr["pickcode"]), async_))
+                    if attr["is_dir"]:
+                        if not files:
+                            yield Yield(attr)
+                        add_pickcode(attr["pickcode"])
+                    elif files:
+                        yield Yield(attr)
+            for pickcode in pickcodes:
+                yield YieldFrom(run_gen_step_iter(gen_step(pickcode), async_))             
+                max_page = 0
+                get_next_page = count(1).__next__
         return run_gen_step_iter(chain, async_)
 
 
 @overload
 def iter_download_files(
     client: str | P115Client, 
-    cid: int = 0, 
+    cid: int | str = 0, 
     id_to_dirnode: None | EllipsisType | MutableMapping[int, tuple[str, int] | DirNode] = None, 
     escape: None | bool | Callable[[str], str] = True, 
     with_ancestors: bool = True, 
@@ -1304,7 +1388,7 @@ def iter_download_files(
 @overload
 def iter_download_files(
     client: str | P115Client, 
-    cid: int = 0, 
+    cid: int | str = 0, 
     id_to_dirnode: None | EllipsisType | MutableMapping[int, tuple[str, int] | DirNode] = None, 
     escape: None | bool | Callable[[str], str] = True, 
     with_ancestors: bool = True, 
@@ -1317,7 +1401,7 @@ def iter_download_files(
     ...
 def iter_download_files(
     client: str | P115Client, 
-    cid: int = 0, 
+    cid: int | str = 0, 
     id_to_dirnode: None | EllipsisType | MutableMapping[int, tuple[str, int] | DirNode] = None, 
     escape: None | bool | Callable[[str], str] = True, 
     with_ancestors: bool = True, 
@@ -1330,12 +1414,10 @@ def iter_download_files(
     """获取一个目录内所有的文件信息（简略），且包括 "dir_ancestors"、"dirname"
 
     .. note::
-        并不提供文件的 id 和 name，但有 pickcode，如果需要获得 name，你可以在之后获取下载链接，然后从下载链接中获取实际的名字
-
-        如果要通过 pickcode 获取基本信息，请用 `P115Client.fs_supervision`
+        并不提供文件的 name，如果需要获得 name，你可以在之后获取下载链接，然后从下载链接中获取实际的名字
 
     :param client: 115 客户端或 cookies
-    :param cid: 目录 id
+    :param cid: 目录 id 或 pickcode
     :param escape: 对文件名进行转义
 
         - 如果为 None，则不处理；否则，这个函数用来对文件名中某些符号进行转义，例如 "/" 等
@@ -1345,8 +1427,8 @@ def iter_download_files(
 
     :param with_ancestors: 文件信息中是否要包含 "ancestors"
     :param id_to_dirnode: 字典，保存 id 到对应文件的 `DirNode(name, parent_id)` 命名元组的字典
-    :param max_workers: 最大并发数，如果为 None 或 <= 0，则默认为 20
-    :param app: 使用某个 app （设备）的接口
+    :param max_workers: 最大并发数，如果为 None 或 <= 0，则自动确定
+    :param app: 使用指定 app（设备）的接口
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -1356,7 +1438,7 @@ def iter_download_files(
         client = P115Client(client, check_for_relogin=True)
     if id_to_dirnode is None:
         id_to_dirnode = ID_TO_DIRNODE_CACHE[client.user_id]
-    else:
+    elif id_to_dirnode is ...:
         id_to_dirnode = {}
     if isinstance(escape, bool):
         if escape:
@@ -1396,21 +1478,86 @@ def iter_download_files(
         else:
             dirname = id_to_path[pid] = get_path(id_to_dirnode[pid]) + "/"
         return dirname + name
-    def norm_attr(info: dict, /) -> dict:
-        pid = int(info["pid"])
-        attr = {"parent_id": pid, "pickcode": info["pc"], "size": info["fs"]}
+    def norm_attr(attr: dict, /) -> dict:
+        pid = attr["parent_id"]
         pnode = id_to_dirnode[pid]
         if with_ancestors:
             attr["dir_ancestors"] = get_ancestors(pid, pnode)
         attr["dirname"] = get_path(pnode)
         return attr
-    def gen_step(pickcode: str = ""):
-        if not cid:
+    ancestors_loaded: None | bool = False
+    @as_gen_step
+    def load_ancestors(pickcode: str, /):
+        nonlocal ancestors_loaded
+        try:
+            yield through(iter_download_nodes(
+                client, 
+                pickcode, 
+                files=False, 
+                id_to_dirnode=id_to_dirnode, 
+                max_workers=max_workers, 
+                app=app, 
+                async_=async_, 
+                **request_kwargs, 
+            ))
+        finally:
+            ancestors_loaded = True
+    def gen_step(pickcode: str = to_pickcode(cid), /):
+        nonlocal ancestors_loaded
+        if pickcode:
+            if cid:
+                from .iterdir import _iter_fs_files
+                do_next: Callable = anext if async_ else next
+                yield do_next(_iter_fs_files(
+                    client, 
+                    to_id(cid), 
+                    page_size=1, 
+                    id_to_dirnode=id_to_dirnode, 
+                    async_=async_, 
+                    **request_kwargs, 
+                ))
+            if async_:
+                task: Any = create_task(load_ancestors(pickcode))
+            else:
+                task = run_as_thread(load_ancestors, pickcode)
+            cache: list[dict] = []
+            add_to_cache = cache.append
+            with with_iter_next(iter_download_nodes(
+                client, 
+                pickcode, 
+                files=True, 
+                max_workers=max_workers, 
+                app=app, 
+                async_=async_, 
+                **request_kwargs, 
+            )) as get_next:
+                while True:
+                    attr = yield get_next()
+                    if ancestors_loaded is None:
+                        yield Yield(norm_attr(attr))
+                    elif ancestors_loaded:
+                        yield YieldFrom(map(norm_attr, cache))
+                        cache.clear()
+                        if async_:
+                            yield task
+                        else:
+                            task.result()
+                        ancestors_loaded = None
+                    else:
+                        add_to_cache(attr)
+            if cache:
+                if async_:
+                    yield task
+                else:
+                    task.result()
+                yield YieldFrom(map(norm_attr, cache))
+        else:
             defaults = {
                 "dir_ancestors": [{"id": 0, "parent_id": 0, "name": ""}],
                 "dirname": "/",
             }
             pickcodes: list[str] = []
+            add_pickcode = pickcodes.append
             with with_iter_next(iterdir(
                 client, 
                 id_to_dirnode=id_to_dirnode, 
@@ -1422,7 +1569,7 @@ def iter_download_files(
                 while True:
                     attr = yield get_next()
                     if attr["is_dir"]:
-                        pickcodes.append(attr["pickcode"])
+                        add_pickcode(attr["pickcode"])
                     else:
                         yield Yield({
                             "parent_id": attr["parent_id"], 
@@ -1432,82 +1579,13 @@ def iter_download_files(
                         })
             for pickcode in pickcodes:
                 yield YieldFrom(run_gen_step_iter(gen_step(pickcode), async_))
-            return
-        if not pickcode:
-            resp = yield client.fs_file_skim(cid, async_=async_, **request_kwargs)
-            check_response(resp)
-            info = resp["data"][0]
-            if info["sha1"]:
-                raise NotADirectoryError(ENOTDIR, info)
-            pickcode = info["pick_code"]
-        ancestors_loaded: None | bool = False
-        def load_ancestors():
-            nonlocal ancestors_loaded
-            if cid:
-                resp = yield client.fs_files(
-                    {"cid": cid, "limit": 1}, 
-                    async_=async_, 
-                    **request_kwargs, 
-                )
-                check_response(resp)
-                for info in resp["path"][1:]:
-                    id_to_dirnode[int(info["cid"])] = DirNode(info["name"], int(info["pid"]))
-            try:
-                with with_iter_next(iter_download_nodes(
-                    client, 
-                    pickcode, 
-                    files=False, 
-                    max_workers=max_workers, 
-                    app=app, 
-                    async_=async_, 
-                    **request_kwargs, 
-                )) as get_next:
-                    while True:
-                        info = yield get_next()
-                        id_to_dirnode[int(info["fid"])] = DirNode(info["fn"], int(info["pid"]))
-            finally:
-                ancestors_loaded = True
-        if async_:
-            task: Any = create_task(run_gen_step(load_ancestors, True))
-        else:
-            task = run_as_thread(run_gen_step, load_ancestors)
-        cache: list[dict] = []
-        add_to_cache = cache.append
-        with with_iter_next(iter_download_nodes(
-            client, 
-            pickcode, 
-            files=True, 
-            max_workers=max_workers, 
-            app=app, 
-            async_=async_, # type: ignore
-            **request_kwargs, 
-        )) as get_next:
-            while True:
-                info = yield get_next()
-                if ancestors_loaded is None:
-                    yield Yield(norm_attr(info))
-                elif ancestors_loaded:
-                    yield YieldFrom(map(norm_attr, cache))
-                    cache.clear()
-                    if async_:
-                        yield task
-                    else:
-                        task.result()
-                    ancestors_loaded = None
-                else:
-                    add_to_cache(info)
-        if cache:
-            if async_:
-                yield task
-            else:
-                task.result()
-            yield YieldFrom(map(norm_attr, cache))
+                ancestors_loaded = False
     return run_gen_step_iter(gen_step, async_)
 
 
 @overload
 def get_remaining_open_count(
-    client: str | P115Client, 
+    client: str | P115Client | P115OpenClient, 
     app: str = "android", 
     *, 
     async_: Literal[False] = False, 
@@ -1516,7 +1594,7 @@ def get_remaining_open_count(
     ...
 @overload
 def get_remaining_open_count(
-    client: str | P115Client, 
+    client: str | P115Client | P115OpenClient, 
     app: str = "android", 
     *, 
     async_: Literal[True], 
@@ -1524,7 +1602,7 @@ def get_remaining_open_count(
 ) -> Coroutine[Any, Any, int]:
     ...
 def get_remaining_open_count(
-    client: str | P115Client, 
+    client: str | P115Client | P115OpenClient, 
     app: str = "android", 
     *, 
     async_: Literal[False, True] = False, 
@@ -1536,7 +1614,7 @@ def get_remaining_open_count(
         假设总数是 n，通常总数是 10，偶尔会调整，如果已经有 m 个被打开的链接，则返回的数字是 n-m
 
     :param client: 115 客户端或 cookies
-    :param app: 使用某个 app （设备）的接口
+    :param app: 使用指定 app（设备）的接口
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -1554,18 +1632,28 @@ def get_remaining_open_count(
         cache: list = []
         add_to_cache = cache.append
         try:
-            with with_iter_next(iter_download_nodes(
-                client, 
-                app=app, 
-                async_=async_, 
-                **request_kwargs, 
-            )) as get_next:
+            if isinstance(client, P115OpenClient):
+                it: Iterator[dict] | AsyncIterator[dict] = iter_files(
+                    client, 
+                    type=4, 
+                    app=app, 
+                    async_=async_, # type: ignore
+                    **request_kwargs, 
+                )
+            else:
+                it = iter_download_nodes(
+                    client, 
+                    app=app, 
+                    async_=async_, 
+                    **request_kwargs, 
+                )
+            with with_iter_next(it) as get_next:
                 while True:
-                    info = yield get_next()
-                    if int(info["fs"]) <= 1024 * 1024 * 200:
+                    attr = yield get_next()
+                    if attr["size"] <= 1024 * 1024 * 200:
                         continue
                     try:
-                        url = yield get_url(info["pc"], async_=async_)
+                        url = yield get_url(attr["pickcode"], async_=async_)
                     except FileNotFoundError:
                         continue
                     request = Request(url, headers={"user-agent": ""})