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

p115client/tool/edit.py

@@ -8,14 +8,14 @@ __all__ = [
 ]
 __doc__ = "这个模块提供了一些和修改文件或目录信息有关的函数"
 
-from collections.abc import AsyncIterable, AsyncIterator, Coroutine, Iterable, Iterator
+from collections.abc import AsyncIterable, Coroutine, Iterable
 from functools import partial
-from typing import cast, overload, Any, Literal
+from typing import overload, Any, Literal
 
-from asynctools import to_list
-from concurrenttools import taskgroup_map, threadpool_map
-from iterutils import chunked, run_gen_step, foreach, through, async_through
+from concurrenttools import conmap
+from iterutils import chunked, map as do_map, run_gen_step, through
 from p115client import check_response, P115Client
+from p115pickcode import to_id
 
 
 @overload
@@ -61,7 +61,7 @@ def update_abstract(
     """批量设置文件或目录
 
     :param client: 115 客户端或 cookies
-    :param ids: 一组文件或目录的 id
+    :param ids: 一组文件或目录的 id 或 pickcode
     :param method: 方法名
     :param value: 要设置的值
     :param batch_size: 批次大小，分批次，每次提交的 id 数
@@ -73,24 +73,17 @@ def update_abstract(
         client = P115Client(client, check_for_relogin=True)
     if max_workers is None or max_workers <= 0:
         max_workers = 20 if async_ else None
+    ids = do_map(to_id, ids)
     def gen_step():
         setter = partial(getattr(client, method), async_=async_, **request_kwargs)
         def call(batch, /):
             return check_response(setter(batch, value))
-        if max_workers == 1:
-            yield foreach(call, chunked(ids, batch_size))
-        elif async_: 
-            yield async_through(taskgroup_map(
-                call, 
-                chunked(ids, batch_size), 
-                max_workers=max_workers, 
-            ))
-        else:
-            through(threadpool_map(
-                call, 
-                chunked(ids, batch_size), 
-                max_workers=max_workers
-            ))
+        yield through(conmap(
+            call, 
+            chunked(ids, batch_size), 
+            max_workers=max_workers, 
+            async_=async_, 
+        ))
     return run_gen_step(gen_step, async_)
 
 
@@ -611,28 +604,27 @@ def batch_unstar(
         raise KeyError
     def gen_step():
         from .iterdir import _iter_fs_files
-        it = _iter_fs_files(
-            client, 
-            payload={"cid": 0, "count_folders": 1, "cur": 0, "fc_mix": 0, "offset": 0, "show_dir": 1, "star": 1}, 
-            ensure_file=ensure_file, 
-            app=app, 
-            cooldown=0.5, 
-            async_=async_, 
-            **request_kwargs, 
-        )
-        if async_:
-            ids: list[int] = yield to_list(get_id(info) async for info in cast(AsyncIterator[dict], it))
-        else:
-            ids = [get_id(info) for info in cast(Iterator[dict], it)]
         yield update_star(
             client, 
-            ids, 
+            do_map(get_id, _iter_fs_files(
+                client, 
+                payload={
+                    "cid": 0, "count_folders": 1, "cur": 0, "fc_mix": 0, 
+                    "offset": 0, "show_dir": 1, "star": 1
+                }, 
+                ensure_file=ensure_file, 
+                app=app, 
+                cooldown=0.5, 
+                async_=async_, 
+                **request_kwargs, 
+            )), 
             star=False, 
             batch_size=batch_size, 
             max_workers=max_workers, 
             app=app, 
-            async_=async_, # type: ignore
+            async_=async_, 
             **request_kwargs, 
         )
     return run_gen_step(gen_step, async_)
 
+# TODO: 上面这些，要支持 open 接口

p115client/tool/export_dir.py

@@ -3,13 +3,16 @@
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
 __all__ = [
-    "parse_export_dir_as_dict_iter", "parse_export_dir_as_path_iter", "parse_export_dir_as_patht_iter", 
-    "export_dir", "export_dir_result", "export_dir_parse_iter", 
+    "parse_export_dir_as_dict_iter", "parse_export_dir_as_path_iter", 
+    "parse_export_dir_as_patht_iter", "export_dir", "export_dir_result", 
+    "export_dir_parse_iter", 
 ]
 __doc__ = "这个模块提供了一些和导出目录树有关的函数"
 
 from asyncio import sleep as async_sleep
-from collections.abc import AsyncIterable, AsyncIterator, Callable, Coroutine, Iterable, Iterator
+from collections.abc import (
+    AsyncIterable, AsyncIterator, Callable, Coroutine, Iterable, Iterator, 
+)
 from functools import partial
 from io import BufferedReader, TextIOWrapper
 from itertools import count
@@ -20,8 +23,12 @@ from typing import cast, overload, Any, Final, IO, Literal
 
 from asynctools import ensure_async, ensure_aiter
 from filewrap import AsyncBufferedReader, AsyncTextIOWrapper
-from iterutils import backgroud_loop, context, run_gen_step, run_gen_step_iter, Yield, YieldFrom
+from iterutils import (
+    as_gen_step, backgroud_loop, context, run_gen_step, run_gen_step_iter, 
+    Yield, YieldFrom, 
+)
 from p115client import check_response, P115Client
+from p115pickcode import to_id, is_valid_pickcode
 
 
 CRE_TREE_PREFIX_match: Final = re_compile(r"^(?:\| )+\|-(.*)").match
@@ -177,7 +184,7 @@ def parse_export_dir_as_path_iter(
         if escape:
             from posixpatht import escape
         else:
-            from .iterdir import posix_escape_name
+            from .util import posix_escape_name as escape
     escape = cast(None | Callable[[str], str], escape)
     def gen_step():
         it = ensure_aiter(file, threaded=True) if async_ else file
@@ -190,10 +197,12 @@ def parse_export_dir_as_path_iter(
         root = root.removesuffix("\n")[3:]
         if root == "根目录":
             stack = [""]
+            root = "/"
         else:
             if escape is not None:
                 root = escape(root)
-            stack = ["/" + root]
+            root = "/" + root
+            stack = [root]
         push = stack.append
         try:
             depth = 0
@@ -208,7 +217,7 @@ def parse_export_dir_as_path_iter(
                 elif depth:
                     yield Yield(stack[depth])
                 else:
-                    yield "/" if root == "根目录" else root
+                    yield Yield(root)
                 name = m[1]
                 depth = (len(line) - len(name)) // 2 - 1
                 if escape is not None:
@@ -354,8 +363,8 @@ def export_dir(
     """导出目录树
 
     :param client: 115 客户端或 cookies
-    :param export_file_ids: 待导出的目录 id 或 路径（如果有多个，需传入可迭代对象）
-    :param target_pid: 导出到的目标目录 id 或 路径
+    :param export_file_ids: 待导出的目录 id 或 pickcode
+    :param target_pid: 导出到的目标目录 id 或 pickcode
     :param layer_limit: 层级深度，小于等于 0 时不限
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
@@ -366,41 +375,14 @@ def export_dir(
         client = P115Client(client, check_for_relogin=True)
     def gen_step():
         nonlocal export_file_ids, target_pid
-        from .iterdir import get_id_to_path
         if isinstance(export_file_ids, int):
             pass
         elif isinstance(export_file_ids, str):
-            export_file_ids = yield get_id_to_path(
-                client, 
-                export_file_ids, 
-                ensure_file=False, 
-                async_=async_, 
-                **request_kwargs, 
-            )
+            if "," not in export_file_ids:
+                export_file_ids = to_id(export_file_ids)
         else:
-            cids: set[int] = set()
-            add_cid = cids.add
-            for cid in export_file_ids:
-                if isinstance(cid, str):
-                    cid = yield get_id_to_path(
-                        client, 
-                        cid, 
-                        ensure_file=False, 
-                        async_=async_, 
-                        **request_kwargs, 
-                    )
-                add_cid(cast(int, cid))
-            if not cids:
-                raise ValueError("`export_file_ids` is empty")
-            export_file_ids = ",".join(map(str, cids))
-        if isinstance(target_pid, str):
-            target_pid = yield get_id_to_path(
-                client, 
-                target_pid, 
-                ensure_file=False, 
-                async_=async_, 
-                **request_kwargs, 
-            )
+            export_file_ids = ",".join(str(to_id(eid)) for eid in export_file_ids)
+        target_pid = to_id(target_pid)
         payload = {"file_ids": export_file_ids, "target": f"U_0_{target_pid}"}
         if layer_limit > 0:
             payload["layer_limit"] = layer_limit
@@ -544,9 +526,9 @@ def export_dir_parse_iter(
     """导出目录树到文件，读取文件并解析后返回迭代器，关闭后自动删除导出的文件
 
     :param client: 115 客户端或 cookies
-    :param export_file_ids: 待导出的目录 id 或 路径（如果有多个，需传入可迭代对象）
+    :param export_file_ids: 待导出的目录 id、pickcode 或 路径（如果有多个，需传入可迭代对象）
     :param export_id: 优先级高于 `export_file_ids`，之前提交的 `export_dir` 任务的 id，如果是 str，则视为导出的目录树文件的提取码（因此无需导出）
-    :param target_pid: 导出到的目标目录 id 或 路径
+    :param target_pid: 导出到的目标目录 id 或 pickcode
     :param layer_limit: 层级深度，小于等于 0 时不限
     :param parse_iter: 解析打开的二进制文件，返回可迭代对象
     :param delete: 最终删除目录树文件（如果 export_id 为 str（即提取码），则这个值不生效，必不删除）

p115client/tool/fs_files.py

@@ -115,20 +115,20 @@ def iter_fs_files(
         "limit": first_page_size, "show_dir": 1, **payload, 
     }
     cid = int(payload["cid"])
-    @as_gen_step
-    def get_files(payload: dict, /):
+    def gen_step():
         nonlocal count
         while True:
-            try:
-                resp = yield fs_files(payload, async_=async_)
-                check_response(resp)
-            except DataError:
-                if payload["limit"] <= 1150:
-                    raise
-                payload["limit"] -= 1_000
-                if payload["limit"] < 1150:
-                    payload["limit"] = 1150
-            else:
+            while True:
+                try:
+                    resp = yield fs_files(payload, async_=async_)
+                    check_response(resp)
+                except DataError:
+                    if payload["limit"] <= 1150:
+                        raise
+                    payload["limit"] -= 1_000
+                    if payload["limit"] < 1150:
+                        payload["limit"] = 1150
+                    continue
                 if cid and int(resp["path"][-1]["cid"]) != cid:
                     if count < 0:
                         raise NotADirectoryError(ENOTDIR, cid)
@@ -146,10 +146,7 @@ def iter_fs_files(
                     count = count_new
                 if callback is not None:
                     resp["callback"] = yield callback(resp)
-                return resp
-    def gen_step():
-        while True:
-            resp = yield get_files(payload)
+                break
             payload["limit"] = page_size
             yield Yield(resp)
             payload["offset"] += len(resp["data"])

p115client/tool/history.py

@@ -2,26 +2,42 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__all__ = ["iter_history_list_once", "iter_history_list"]
+__all__ = [
+    "HISTORY_NAME_TO_TYPE", "HISTORY_TYPE_TO_NAME", 
+    "iter_history_once", "iter_history", "iter_history_list", 
+]
 __doc__ = "这个模块提供了一些和 115 的历史记录有关的函数"
 
 from asyncio import sleep as async_sleep
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator, Container, Iterator
 from functools import partial
 from itertools import cycle
 from time import time, sleep
-from typing import overload, Literal
+from typing import overload, Final, Literal
 
 from iterutils import run_gen_step_iter, with_iter_next, Yield
 from p115client import check_response, P115Client
 
 
+#: 115 生活操作事件名称到类型的映射
+HISTORY_NAME_TO_TYPE: Final = {
+    "offline_download": 2, 
+    "browse_video": 3, 
+    "upload": 4, 
+    "receive": 7, 
+    "move": 8, 
+}
+#: 115 生活操作事件类型到名称的映射
+HISTORY_TYPE_TO_NAME: Final = {v: k for k, v in HISTORY_NAME_TO_TYPE.items()}
+
+
 @overload
-def iter_history_list_once(
+def iter_history_once(
     client: str | P115Client, 
     from_time: int | float = 0, 
     from_id: int = 0, 
     type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
     first_batch_size = 0, 
     app: str = "web", 
     cooldown: int | float = 0, 
@@ -31,11 +47,12 @@ def iter_history_list_once(
 ) -> Iterator[dict]:
     ...
 @overload
-def iter_history_list_once(
+def iter_history_once(
     client: str | P115Client, 
     from_time: int | float = 0, 
     from_id: int = 0, 
     type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
     first_batch_size = 0, 
     app: str = "web", 
     cooldown: int | float = 0, 
@@ -44,11 +61,12 @@ def iter_history_list_once(
     **request_kwargs, 
 ) -> AsyncIterator[dict]:
     ...
-def iter_history_list_once(
+def iter_history_once(
     client: str | P115Client, 
     from_time: int | float = 0, 
     from_id: int = 0, 
     type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
     first_batch_size = 0, 
     app: str = "web", 
     cooldown: int | float = 0, 
@@ -73,6 +91,7 @@ def iter_history_list_once(
         - 接收: 7
         - 移动: 8
 
+    :param ignore_types: 一组要被忽略的操作事件类型代码，仅当 `type` 为空时生效
     :param first_batch_size: 首批的拉取数目
     :param app: 使用某个 app （设备）的接口
     :param cooldown: 冷却时间，大于 0 时，两次接口调用之间至少间隔这么多秒
@@ -105,7 +124,8 @@ def iter_history_list_once(
                 if from_id and event_id <= from_id or from_time and int(event["update_time"]) < from_time:
                     return
                 if event_id not in seen:
-                    yield Yield(event)
+                    if type or not ignore_types or event["type"] not in ignore_types:
+                        yield Yield(event)
                     seen_add(event_id)
             offset += len(events)
             if offset >= int(resp["data"]["total"]):
@@ -123,11 +143,12 @@ def iter_history_list_once(
 
 
 @overload
-def iter_history_list(
+def iter_history(
     client: str | P115Client, 
     from_time: int | float = 0, 
     from_id: int = 0, 
     type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
     app: str = "web", 
     cooldown: int | float = 0, 
     interval: int | float = 0, 
@@ -137,11 +158,12 @@ def iter_history_list(
 ) -> Iterator[dict]:
     ...
 @overload
-def iter_history_list(
+def iter_history(
     client: str | P115Client, 
     from_time: int | float = 0, 
     from_id: int = 0, 
     type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
     app: str = "web", 
     cooldown: int | float = 0, 
     interval: int | float = 0, 
@@ -150,11 +172,12 @@ def iter_history_list(
     **request_kwargs, 
 ) -> AsyncIterator[dict]:
     ...
-def iter_history_list(
+def iter_history(
     client: str | P115Client, 
     from_time: int | float = 0, 
     from_id: int = 0, 
     type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
     app: str = "web", 
     cooldown: int | float = 0, 
     interval: int | float = 0, 
@@ -179,6 +202,7 @@ def iter_history_list(
         - 接收: 7
         - 移动: 8
 
+    :param ignore_types: 一组要被忽略的操作事件类型代码，仅当 `type` 为空时生效
     :param cooldown: 冷却时间，大于 0 时，两次接口调用之间至少间隔这么多秒
     :param interval: 两个批量拉取之间的睡眠时间间隔，如果小于等于 0，则不睡眠
     :param app: 使用某个 app （设备）的接口
@@ -202,7 +226,7 @@ def iter_history_list(
                     yield async_sleep(interval)
                 else:
                     sleep(interval)
-            with with_iter_next(iter_history_list_once(
+            with with_iter_next(iter_history_once(
                 client, 
                 from_time, 
                 from_id, 
@@ -219,6 +243,106 @@ def iter_history_list(
                         from_id = int(event["id"])
                         from_time = int(event["update_time"])
                         sub_first_loop = False
+                    if not type and ignore_types and event["type"] in ignore_types:
+                        continue
                     yield Yield(event)
     return run_gen_step_iter(gen_step, async_)
 
+
+@overload
+def iter_history_list(
+    client: str | P115Client, 
+    from_time: int | float = 0, 
+    from_id: int = 0, 
+    type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
+    app: str = "web", 
+    cooldown: int | float = 0, 
+    *, 
+    async_: Literal[False] = False, 
+    **request_kwargs, 
+) -> Iterator[dict]:
+    ...
+@overload
+def iter_history_list(
+    client: str | P115Client, 
+    from_time: int | float = 0, 
+    from_id: int = 0, 
+    type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
+    app: str = "web", 
+    cooldown: int | float = 0, 
+    *, 
+    async_: Literal[True], 
+    **request_kwargs, 
+) -> AsyncIterator[dict]:
+    ...
+def iter_history_list(
+    client: str | P115Client, 
+    from_time: int | float = 0, 
+    from_id: int = 0, 
+    type: int | str = 0, 
+    ignore_types: None | Container[int] = None, 
+    app: str = "web", 
+    cooldown: int | float = 0, 
+    *, 
+    async_: Literal[False, True] = False, 
+    **request_kwargs, 
+) -> AsyncIterator[dict] | Iterator[dict]:
+    """持续拉取 115 的历史记录
+
+    :param client: 115 客户端或 cookies
+    :param from_time: 开始时间（含），若为 0 则从当前时间开始，若小于 0 则从最早开始
+    :param from_id: 开始的事件 id （不含）
+    :param type: 拉取指定类型的历史记录（？？表示还未搞清楚），多个用逗号 "," 隔开
+
+        - 全部: 0
+        - ？？: 1
+        - 离线下载: 2
+        - 播放视频: 3
+        - 上传: 4
+        - ？？: 5
+        - ？？: 6
+        - 接收: 7
+        - 移动: 8
+
+    :param ignore_types: 一组要被忽略的操作事件类型代码，仅当 `type` 为空时生效
+    :param cooldown: 冷却时间，大于 0 时，两次接口调用之间至少间隔这么多秒
+    :param app: 使用某个 app （设备）的接口
+    :param async_: 是否异步
+    :param request_kwargs: 其它请求参数
+
+    :return: 迭代器，产生 115 的历史记录数据字典
+    """
+    if isinstance(client, str):
+        client = P115Client(client, check_for_relogin=True)
+    def gen_step():
+        nonlocal from_time, from_id
+        if from_time == 0:
+            from_time = time()
+        while True:
+            ls: list[dict] = []
+            push = ls.append
+            with with_iter_next(iter_history_once(
+                client, 
+                from_time, 
+                from_id, 
+                type=type, 
+                app=app, 
+                cooldown=cooldown, 
+                async_=async_, 
+                **request_kwargs, 
+            )) as get_next:
+                first_loop = True
+                while True:
+                    event = yield get_next()
+                    if first_loop:
+                        from_id = int(event["id"])
+                        from_time = int(event["update_time"])
+                        first_loop = False
+                    if not type and ignore_types and event["type"] in ignore_types:
+                        continue
+                    push(event)
+            yield Yield(ls)
+    return run_gen_step_iter(gen_step, async_)
+