p115client 0.0.5.8.3__tar.gz → 0.0.5.8.4__tar.gz

{p115client-0.0.5.8.3 → p115client-0.0.5.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: p115client
-Version: 0.0.5.8.3
+Version: 0.0.5.8.4
 Summary: Python 115 webdisk client.
 Home-page: https://github.com/ChenyangGao/p115client
 License: MIT
@@ -40,7 +40,7 @@ Requires-Dist: python-filewrap (>=0.2.8)
 Requires-Dist: python-hashtools (>=0.0.3.3)
 Requires-Dist: python-http_request (>=0.0.6)
 Requires-Dist: python-httpfile (>=0.0.5.2)
-Requires-Dist: python-iterutils (>=0.1.8)
+Requires-Dist: python-iterutils (>=0.1.10)
 Requires-Dist: python-property (>=0.0.3)
 Requires-Dist: python-startfile (>=0.0.2)
 Requires-Dist: python-undefined (>=0.0.3)

{p115client-0.0.5.8.3 → p115client-0.0.5.8.4}/p115client/_upload.py

@@ -10,8 +10,8 @@ __all__ = [
 
 from base64 import b64encode
 from collections.abc import (
-    AsyncGenerator, AsyncIterable, AsyncIterator, Awaitable, Callable, Coroutine, Generator, 
-    ItemsView, Iterable, Iterator, Mapping, Sequence, Sized, 
+    AsyncGenerator, AsyncIterable, AsyncIterator, Awaitable, Buffer, Callable, 
+    Coroutine, Generator, ItemsView, Iterable, Iterator, Mapping, Sequence, Sized, 
 )
 from datetime import datetime
 from email.utils import formatdate
@@ -25,7 +25,7 @@ from xml.etree.ElementTree import fromstring
 
 from asynctools import ensure_aiter, ensure_async
 from filewrap import (
-    Buffer, SupportsRead, 
+    SupportsRead, buffer_length, 
     bio_chunk_iter, bio_chunk_async_iter, 
     bio_skip_iter, bio_skip_async_iter, 
     bytes_iter_to_async_reader, bytes_iter_to_reader, 
@@ -41,20 +41,13 @@ from .exception import MultipartUploadAbort
 from .type import MultipartResumeData
 
 
-def buffer_length(b: Buffer, /) -> int:
-    if isinstance(b, Sized):
-        return len(b)
-    else:
-        return len(memoryview(b))
-
-
-def to_base64(s: bytes | str, /) -> str:
+def to_base64(s: Buffer | str, /) -> str:
     if isinstance(s, str):
         s = bytes(s, "utf-8")
     return str(b64encode(s), "ascii")
 
 
-def to_integer(n, /):
+def maybe_integer(n: int | str, /) -> int | str:
     if isinstance(n, str) and n.isdecimal():
         n = int(n)
     return n
@@ -155,19 +148,19 @@ def oss_upload_sign(
     #     "replicationProgress", "requestPayment", "requesterQosInfo", "resourceGroup", "resourcePool", 
     #     "resourcePoolBuckets", "resourcePoolInfo", "response-cache-control", "response-content-disposition", 
     #     "response-content-encoding", "response-content-language", "response-content-type", "response-expires", 
-    #     "restore", "security-token", "sequential", "startTime", "stat", "status", "style", "styleName", "symlink", 
-    #     "tagging", "transferAcceleration", "uploadId", "uploads", "versionId", "versioning", "versions", "vod", 
-    #     "website", "worm", "wormExtend", "wormId", "x-oss-ac-forward-allow", "x-oss-ac-source-ip", 
-    #     "x-oss-ac-subnet-mask", "x-oss-ac-vpc-id", "x-oss-access-point-name", "x-oss-async-process", "x-oss-process", 
-    #     "x-oss-redundancy-transition-taskid", "x-oss-request-payer", "x-oss-target-redundancy-type", 
-    #     "x-oss-traffic-limit", "x-oss-write-get-object-response", 
+    #     "restore", "security-token", "sequential", "startTime", "stat", "status", "style", "styleName", 
+    #     "symlink", "tagging", "transferAcceleration", "uploadId", "uploads", "versionId", "versioning", 
+    #     "versions", "vod", "website", "worm", "wormExtend", "wormId", "x-oss-ac-forward-allow", 
+    #     "x-oss-ac-source-ip", "x-oss-ac-subnet-mask", "x-oss-ac-vpc-id", "x-oss-access-point-name", 
+    #     "x-oss-async-process", "x-oss-process", "x-oss-redundancy-transition-taskid", "x-oss-request-payer", 
+    #     "x-oss-target-redundancy-type", "x-oss-traffic-limit", "x-oss-write-get-object-response", 
     # )
     date = formatdate(usegmt=True)
     if params is None:
         params = ""
     elif not isinstance(params, str):
         params = urlencode(params)
-    if params:
+    if params and not params.startswith("?"):
         params = "?" + params
     if headers:
         if isinstance(headers, Mapping):
@@ -183,7 +176,7 @@ def oss_upload_sign(
         headers_str = ""
     content_md5 = headers.setdefault("content-md5", "")
     content_type = headers.setdefault("content-type", "")
-    date = headers.get("x-oss-date") or headers.get("date", "")
+    date = headers.get("x-oss-date") or headers.get("date") or ""
     if not date:
         date = headers["date"] = formatdate(usegmt=True)
     signature_data = f"""\
@@ -269,13 +262,16 @@ def oss_multipart_part_iter(
 ) -> Iterator[dict] | AsyncIterator[dict]:
     """罗列某个分块上传任务，已经上传的分块
     """
+    request_kwargs.update(
+        method="GET", 
+        params={"uploadId": upload_id}, 
+        headers={"x-oss-security-token": token["SecurityToken"]}, 
+    )
+    request_kwargs.setdefault("parse", lambda _, content: fromstring(content))
     def gen_step():
-        request_kwargs["method"] = "GET"
-        request_kwargs["headers"] = {"x-oss-security-token": token["SecurityToken"]}
-        request_kwargs["params"] = params = {"uploadId": upload_id}
-        request_kwargs.setdefault("parse", False)
+        params = request_kwargs["params"]
         while True:
-            content = yield oss_upload_request(
+            etree = yield oss_upload_request(
                 request, 
                 url=url, 
                 bucket=bucket, 
@@ -284,12 +280,11 @@ def oss_multipart_part_iter(
                 async_=async_, 
                 **request_kwargs, 
             )
-            etree = fromstring(content)
             for el in etree.iterfind("Part"):
-                yield Yield({sel.tag: to_integer(sel.text) for sel in el}, identity=True)
-            if etree.find("IsTruncated").text == "false": # type: ignore
+                yield Yield({sel.tag: maybe_integer(sel.text) for sel in el}, identity=True)
+            if getattr(etree.find("IsTruncated"), "text") == "false":
                 break
-            params["part-number-marker"] = etree.find("NextPartNumberMarker").text # type: ignore
+            params["part-number-marker"] = getattr(etree.find("NextPartNumberMarker"), "text")
     return run_gen_step_iter(gen_step, async_=async_)
 
 
@@ -327,12 +322,14 @@ def oss_multipart_upload_init(
     async_: Literal[False, True] = False, 
     **request_kwargs, 
 ) -> str | Coroutine[Any, Any, str]:
-    """分片上传的初始化，获取 upload_id
+    """分块上传的初始化，获取 upload_id
     """
+    request_kwargs.update(
+        method="POST", 
+        params={"sequential": "1", "uploads": "1"}, 
+        headers={"x-oss-security-token": token["SecurityToken"]}, 
+    )
     request_kwargs.setdefault("parse", parse_upload_id)
-    request_kwargs["method"] = "POST"
-    request_kwargs["params"] = {"sequential": "1", "uploads": "1"}
-    request_kwargs["headers"] = {"x-oss-security-token": token["SecurityToken"]}
     return oss_upload_request(
         request, 
         url=url, 
@@ -387,20 +384,26 @@ def oss_multipart_upload_complete(
     async_: Literal[False, True] = False, 
     **request_kwargs, 
 ) -> dict | Coroutine[Any, Any, dict]:
-    """完成分片上传任务，会执行回调然后 115 上就能看到文件
+    """完成分块上传任务，会在请求头中包含回调数据，请求体中包含分块信息
     """
-    request_kwargs["method"] = "POST"
-    request_kwargs["params"] = {"uploadId": upload_id}
-    request_kwargs["headers"] = {
-        "x-oss-security-token": token["SecurityToken"], 
-        "x-oss-callback": to_base64(callback["callback"]), 
-        "x-oss-callback-var": to_base64(callback["callback_var"]), 
-        "content-type": "text/xml"
-    }
-    request_kwargs["data"] = ("<CompleteMultipartUpload>%s</CompleteMultipartUpload>" % "".join(map(
-        "<Part><PartNumber>{PartNumber}</PartNumber><ETag>{ETag}</ETag></Part>".format_map, 
-        parts, 
-    ))).encode()
+    request_kwargs.update(
+        method="POST", 
+        params={"uploadId": upload_id}, 
+        data=b"".join((
+            b"<CompleteMultipartUpload>", 
+            *map(
+                b"<Part><PartNumber>%d</PartNumber><ETag>%s</ETag></Part>".__mod__, 
+                ((part["PartNumber"], bytes(part["ETag"], "ascii")) for part in parts), 
+            ), 
+            b"</CompleteMultipartUpload>", 
+        )), 
+        headers={
+            "x-oss-security-token": token["SecurityToken"], 
+            "x-oss-callback": to_base64(callback["callback"]), 
+            "x-oss-callback-var": to_base64(callback["callback_var"]), 
+            "content-type": "text/xml", 
+        }, 
+    )
     return oss_upload_request(
         request, 
         url=url, 
@@ -449,12 +452,14 @@ def oss_multipart_upload_cancel(
     async_: Literal[False, True] = False, 
     **request_kwargs, 
 ) -> bool | Coroutine[Any, Any, bool]:
-    """取消分片上传任务，返回成功与否
+    """取消分块上传任务，返回成功与否
     """
+    request_kwargs.update(
+        method="DELETE", 
+        params={"uploadId": upload_id}, 
+        headers={"x-oss-security-token": token["SecurityToken"]}, 
+    )
     request_kwargs.setdefault("parse", lambda resp: 200 <= resp.status_code < 300 or resp.status_code == 404)
-    request_kwargs["method"] = "DELETE"
-    request_kwargs["params"] = {"uploadId": upload_id}
-    request_kwargs["headers"] = {"x-oss-security-token": token["SecurityToken"]}
     return oss_upload_request(
         request, 
         url=url, 
@@ -520,7 +525,7 @@ def oss_multipart_upload_part(
 ) -> dict | Coroutine[Any, Any, dict]:
     """上传一个分片，返回一个字典，包含如下字段：
 
-    .. python:
+    .. code:: python
 
         {
             "PartNumber": int,    # 分块序号，从 1 开始计数
@@ -924,3 +929,22 @@ def oss_multipart_upload(
                 yield close_reporthook
     return run_gen_step(gen_step, async_=async_)
 
+
+# class MultipartUploader:
+#     def __init__
+#     def __del__
+#     async def __aiter__
+#     def __iter__
+#     async def __aenter__
+#     async def __aexit__
+#     def __enter__
+#     def __exit__
+#     # 0. 应该设计 1 个类，支持同步和异步，实例化不会进行初始化（为了对异步进行适配）
+#     # 1. 可以作为上下文管理器或者迭代器使用
+#     # 2. 上下文管理器也返回迭代器（迭代器迭代时，如果未打开文件或者没有上传信息，则会初始化以获取）
+#     # 3. 中途可以暂停或取消
+#     # 4. seekable: path, url (支持 range request), file reader (seekable)
+#     # 5. 支持进度条
+#     # 6. 设计一个工具函数，放到 p115client.tool.upload 模块中
+#     ...
+

{p115client-0.0.5.8.3 → p115client-0.0.5.8.4}/p115client/client.py

@@ -3985,6 +3985,13 @@ class P115OpenClient(ClientRequestMixin):
 class P115Client(P115OpenClient):
     """115 的客户端对象
 
+    .. note::
+        目前允许 1 个用户同时登录多个开放平台应用（用 AppID 区别），但如果多次登录同 1 个应用，则只有最近登录的有效
+
+        目前不允许短时间内再次用 `refresh_token` 刷新 `access_token`，但你可以用登录的方式再次授权登录以获取 `access_token`，即可不受频率限制
+
+        1 个 `refresh_token` 只能使用 1 次，可获取新的 `refresh_token` 和 `access_token`，如果请求刷新时，发送成功但读取失败，可能导致 `refresh_token` 报废，这时需要重新授权登录
+
     :param cookies: 115 的 cookies，要包含 `UID`、`CID`、`KID` 和 `SEID` 等
 
         - 如果是 None，则会要求人工扫二维码登录
@@ -4910,14 +4917,14 @@ class P115Client(P115OpenClient):
             data = resp["data"]
             if replace is False:
                 inst: P115OpenClient | Self = P115OpenClient.from_token(data["access_token"], data["refresh_token"])
-                inst.app_id = app_id
             else:
                 if replace is True:
                     inst = self
                 else:
                     inst = replace
                 inst.refresh_token = data["refresh_token"]
-                setattr(inst, "access_token", data["access_token"])
+                inst.access_token = data["access_token"]
+            inst.app_id = app_id
             return inst
         return run_gen_step(gen_step, async_=async_)
 
@@ -5195,10 +5202,14 @@ class P115Client(P115OpenClient):
         elif data is not None:
             request_kwargs["data"] = data
         request_kwargs.setdefault("parse", default_parse)
-        if url.startswith("https://proapi.115.com/open/"):
+        use_cookies = not url.startswith("https://proapi.115.com/open/")
+        if not use_cookies:
             headers["cookie"] = ""
-            return request(url=url, method=method, **request_kwargs)
         def gen_step():
+            if async_:
+                lock: Lock | AsyncLock = self.request_alock
+            else:
+                lock = self.request_lock
             check_for_relogin = self.check_for_relogin
             cant_relogin = not callable(check_for_relogin)
             if get_cookies is not None:
@@ -5208,59 +5219,86 @@ class P115Client(P115OpenClient):
             for i in count(0):
                 exc = None
                 try:
-                    if get_cookies is None:
-                        if need_set_cookies:
-                            cookies_old = headers["cookie"] = self.cookies_str
-                    else:
-                        if get_cookies_need_arg:
-                            cookies_ = yield get_cookies(async_)
+                    if use_cookies:
+                        if get_cookies is None:
+                            if need_set_cookies:
+                                cookies_old = headers["cookie"] = self.cookies_str
                         else:
-                            cookies_ = yield get_cookies()
-                        if not cookies_:
-                            raise ValueError("can't get new cookies")
-                        headers["cookie"] = cookies_
-                    return partial(request, url=url, method=method, **request_kwargs)
+                            if get_cookies_need_arg:
+                                cookies_ = yield get_cookies(async_)
+                            else:
+                                cookies_ = yield get_cookies()
+                            if not cookies_:
+                                raise ValueError("can't get new cookies")
+                            headers["cookie"] = cookies_
+                    resp = yield partial(request, url=url, method=method, **request_kwargs)
+                    return resp
                 except BaseException as e:
                     exc = e
-                    if cant_relogin or not need_set_cookies:
+                    if cant_relogin or use_cookies and not need_set_cookies:
                         raise
                     if isinstance(e, (AuthenticationError, LoginError)):
-                        if get_cookies is not None or cookies_old != self.cookies_str or cookies_old != self._read_cookies():
+                        if use_cookies and (
+                            get_cookies is not None or 
+                            cookies_old != self.cookies_str or 
+                            cookies_old != self._read_cookies()
+                        ):
                             continue
                         raise
                     res = yield partial(cast(Callable, check_for_relogin), e)
                     if not res if isinstance(res, bool) else res != 405:
                         raise
-                    if get_cookies is not None:
-                        continue
-                    cookies = self.cookies_str
-                    if not cookies_equal(cookies, cookies_old):
-                        continue
-                    cookies_mtime = getattr(self, "cookies_mtime", 0)
-                    if async_:
-                        lock: Lock | AsyncLock = self.request_alock
-                        yield lock.acquire()
+                    if use_cookies:
+                        if get_cookies is not None:
+                            continue
+                        cookies = self.cookies_str
+                        if not cookies_equal(cookies, cookies_old):
+                            continue
+                        cookies_mtime = getattr(self, "cookies_mtime", 0)
+                        yield lock.acquire
+                        try:
+                            cookies_new = self.cookies_str
+                            cookies_mtime_new = getattr(self, "cookies_mtime", 0)
+                            if cookies_equal(cookies, cookies_new):
+                                m = CRE_COOKIES_UID_search(cookies)
+                                uid = "" if m is None else m[0]
+                                need_read_cookies = cookies_mtime_new > cookies_mtime
+                                if need_read_cookies:
+                                    cookies_new = self._read_cookies()
+                                if i and cookies_equal(cookies_old, cookies_new):
+                                    raise
+                                if not (need_read_cookies and cookies_new):
+                                    warn(f"relogin to refresh cookies: UID={uid!r} app={self.login_app()!r}", category=P115Warning)
+                                    yield self.login_another_app(
+                                        replace=True, 
+                                        async_=async_, # type: ignore
+                                    )
+                        finally:
+                            lock.release()
                     else:
-                        lock = self.request_lock
-                        lock.acquire()
-                    try:
-                        cookies_new = self.cookies_str
-                        cookies_mtime_new = getattr(self, "cookies_mtime", 0)
-                        if cookies_equal(cookies, cookies_new):
-                            m = CRE_COOKIES_UID_search(cookies)
-                            uid = "" if m is None else m[0]
-                            need_read_cookies = cookies_mtime_new > cookies_mtime
-                            if need_read_cookies:
-                                cookies_new = self._read_cookies()
-                            if i and cookies_equal(cookies_old, cookies_new):
-                                raise
-                            if not (need_read_cookies and cookies_new):
-                                warn(f"relogin to refresh cookies: UID={uid!r} app={self.login_app()!r}", category=P115Warning)
-                                yield self.login_another_app(replace=True, async_=async_) # type: ignore
-                    finally:
-                        lock.release()
+                        access_token = self.access_token
+                        yield lock.acquire
+                        try:
+                            if access_token != self.access_token:
+                                continue
+                            if hasattr(self, "app_id"):
+                                app_id = self.app_id
+                                yield self.login_another_open(
+                                    app_id, 
+                                    replace=True, 
+                                    async_=async_, # type: ignore
+                                )
+                                warn(f"relogin to refresh token: {app_id=}", category=P115Warning)
+                            else:
+                                resp = yield self.refresh_access_token(
+                                    async_=async_, # type: ignore
+                                )
+                                check_response(resp)
+                                warn("relogin to refresh token (using refresh_token)", category=P115Warning)
+                        finally:
+                            lock.release()
                 finally:
-                    if (cookies_ and 
+                    if (use_cookies and cookies_ and 
                         get_cookies is not None and 
                         revert_cookies is not None and (
                             not exc or not (

{p115client-0.0.5.8.3 → p115client-0.0.5.8.4}/p115client/tool/download.py

@@ -5,7 +5,7 @@ __author__ = "ChenyangGao <https://chenyanggao.github.io>"
 __all__ = [
     "reduce_image_url_layers", "batch_get_url", "iter_url_batches", "iter_files_with_url", 
     "iter_images_with_url", "iter_subtitles_with_url", "iter_subtitle_batches", "make_strm", 
-    "iter_download_nodes", "iter_download_files", 
+    "iter_download_nodes", "iter_download_files", "get_remaining_open_count", 
 ]
 __doc__ = "这个模块提供了一些和下载有关的函数"
 
@@ -21,10 +21,12 @@ from mimetypes import guess_type
 from os import fsdecode, makedirs, remove, PathLike
 from os.path import abspath, dirname, join as joinpath, normpath, splitext
 from queue import SimpleQueue
+from shutil import rmtree
 from threading import Lock
 from time import time
 from typing import cast, overload, Any, Final, Literal, TypedDict
 from urllib.parse import quote, urlsplit
+from urllib.request import urlopen, Request
 from uuid import uuid4
 from warnings import warn
 
@@ -91,7 +93,7 @@ def batch_get_url(
 
     :param client: 115 客户端或 cookies
     :param id_or_pickcode: 如果是 int，视为 id，如果是 str，视为 pickcode
-    :param user_agent: "User-Agent" 请求头的值
+    :param user_agent: "user-agent" 请求头的值
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -100,9 +102,9 @@ def batch_get_url(
     if isinstance(client, str):
         client = P115Client(client, check_for_relogin=True)
     if headers := request_kwargs.get("headers"):
-        request_kwargs["headers"] = dict(headers, **{"User-Agent": user_agent})
+        request_kwargs["headers"] = dict(headers, **{"user-agent": user_agent})
     else:
-        request_kwargs["headers"] = {"User-Agent": user_agent}
+        request_kwargs["headers"] = {"user-agent": user_agent}
     def gen_step():
         if isinstance(id_or_pickcode, int):
             resp = yield client.fs_file_skim(
@@ -200,7 +202,7 @@ def iter_url_batches(
 
     :param client: 115 客户端或 cookies
     :param pickcodes: 一个迭代器，产生提取码 pickcode
-    :param user_agent: "User-Agent" 请求头的值
+    :param user_agent: "user-agent" 请求头的值
     :param batch_size: 每一个批次处理的个量
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
@@ -210,9 +212,9 @@ def iter_url_batches(
     if isinstance(client, str):
         client = P115Client(client, check_for_relogin=True)
     if headers := request_kwargs.get("headers"):
-        request_kwargs["headers"] = dict(headers, **{"User-Agent": user_agent})
+        request_kwargs["headers"] = dict(headers, **{"user-agent": user_agent})
     else:
-        request_kwargs["headers"] = {"User-Agent": user_agent}
+        request_kwargs["headers"] = {"user-agent": user_agent}
     if batch_size <= 0:
         batch_size = 1
     def gen_step():
@@ -243,7 +245,6 @@ def iter_url_batches(
     return run_gen_step_iter(gen_step, async_=async_)
 
 
-# TODO: 支持按批获取 url，以减少总的耗时
 @overload
 def iter_files_with_url(
     client: str | P115Client, 
@@ -336,7 +337,7 @@ def iter_files_with_url(
     :param id_to_dirnode: 字典，保存 id 到对应文件的 `DirNode(name, parent_id)` 命名元组的字典
     :param app: 使用某个 app （设备）的接口
     :param raise_for_changed_count: 分批拉取时，发现总数发生变化后，是否报错
-    :param user_agent: "User-Agent" 请求头的值
+    :param user_agent: "user-agent" 请求头的值
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -846,8 +847,9 @@ def make_strm(
     origin: str = "http://localhost:8000", 
     update: bool = False, 
     discard: bool = True, 
-    use_abspath: None | bool = True, 
+    use_abspath: bool = True, 
     with_root: bool = False, 
+    with_tree: bool = True, 
     without_suffix: bool = True, 
     complete_url: bool = True, 
     suffix: str = "", 
@@ -871,8 +873,9 @@ def make_strm(
     origin: str = "http://localhost:8000", 
     update: bool = False, 
     discard: bool = True, 
-    use_abspath: None | bool = True, 
+    use_abspath: bool = True, 
     with_root: bool = False, 
+    with_tree: bool = True, 
     without_suffix: bool = True, 
     complete_url: bool = True, 
     suffix: str = "", 
@@ -895,8 +898,9 @@ def make_strm(
     origin: str = "http://localhost:8000", 
     update: bool = False, 
     discard: bool = True, 
-    use_abspath: None | bool = True, 
+    use_abspath: bool = True, 
     with_root: bool = False, 
+    with_tree: bool = True, 
     without_suffix: bool = True, 
     complete_url: bool = True, 
     suffix: str = "", 
@@ -923,9 +927,9 @@ def make_strm(
 
         - 如果为 True，则使用 115 的完整路径
         - 如果为 False，则使用从 `cid` 的目录开始的相对路径
-        - 如果为 None，则所有文件保存在到同一个目录内
 
-    :param with_root: 如果为 True，则当 use_abspath 为 False 或 None 时，在 `save_dir` 下创建一个和 `cid` 目录名字相同的目录，作为实际的 `save_dir`
+    :param with_root: 仅在 use_abspath 为 False 时生效。如果为 True，则在 `save_dir` 下创建一个和 `cid` 目录名字相同的目录，作为实际的 `save_dir`
+    :param with_tree: 如果为 False，则所有文件直接保存到 `save_dir` 下，不构建多级的目录结构
     :param without_suffix: 是否去除原来的扩展名。如果为 False，则直接用 ".strm" 拼接到原来的路径后面；如果为 True，则去掉原来的扩展名后再拼接
     :param complete_url: 是否需要完整的 url
 
@@ -965,20 +969,42 @@ def make_strm(
     ignored: list[str] = []
     removed: list[str] = []
     append = list.append
+    add    = set.add
     if discard:
         seen: set[str] = set()
         seen_add = seen.add
         existing: set[str] = set()
         def do_discard():
+            if not seen:
+                rmtree(savedir)
+                makedirs(savedir, exist_ok=True)
+                return
+            dirs: set[str] = {""}
+            for path in seen:
+                while path := dirname(path):
+                    add(dirs, path)
+            removed_dirs: set[str] = set()
             for path in existing - seen:
-                path = joinpath(savedir, path)
-                remove(path)
+                d = dirname(path)
+                if d in dirs:
+                    path = joinpath(savedir, path)
+                    remove(path)
+                elif d not in removed_dirs:
+                    while True:
+                        add(removed_dirs, d)
+                        pdir = dirname(d)
+                        if not pdir or pdir in dirs:
+                            rmtree(joinpath(savedir, d))
+                            break
+                        elif pdir in removed_dirs:
+                            break
+                        d = pdir
                 append(removed, path)
     def normalize_path(attr: dict, /) -> str:
-        if use_abspath is None:
-            path = attr["name"]
-        else:
+        if with_tree:
             path = attr["path"][abspath_prefix_length:]
+        else:
+            path = attr["name"]
         if without_suffix:
             path = splitext(path)[0]
         relpath = normpath(path) + ".strm"
@@ -1016,14 +1042,8 @@ def make_strm(
     def gen_step():
         nonlocal abspath_prefix_length, savedir
         start_t = time()
-        if discard:
-            strm_files = iglob("**/*.strm", root_dir=savedir, recursive=True)
-            if async_:
-                task: Any = create_task(to_thread(existing.update, strm_files))
-            else:
-                task = run_as_thread(existing.update, strm_files)
         if cid:
-            if use_abspath is False:
+            if use_abspath or with_tree:
                 root = yield get_path_to_cid(
                     client, 
                     cid, 
@@ -1033,7 +1053,12 @@ def make_strm(
                     **request_kwargs, 
                 )
                 abspath_prefix_length = len(root) + 1
-            if with_root and not use_abspath:
+                if use_abspath:
+                    savedir += normpath(root)
+                elif with_root:
+                    name = root.rpartition("/")[-1]
+                    savedir = joinpath(savedir, name)
+            elif with_root:
                 resp = yield client.fs_file_skim(
                     cid, 
                     async_=async_, # type: ignore
@@ -1042,6 +1067,12 @@ def make_strm(
                 check_response(resp)
                 name = posix_escape_name(unescape_115_charref(resp["data"][0]["file_name"]))
                 savedir = joinpath(savedir, name)
+        if discard:
+            strm_files = iglob("**/*.strm", root_dir=savedir, recursive=True)
+            if async_:
+                task: Any = create_task(to_thread(existing.update, strm_files))
+            else:
+                task = run_as_thread(existing.update, strm_files)
         params: dict[str, Any] = {}
         if use_abspath is not None:
             params["path_already"] = path_already
@@ -1089,9 +1120,10 @@ def make_strm(
 @overload
 def iter_download_nodes(
     client: str | P115Client, 
-    pickcode: int | str, 
+    pickcode: int | str = "", 
     files: bool = True, 
     max_workers: None | int = 1, 
+    app: str = "android", 
     *, 
     async_: Literal[False] = False, 
     **request_kwargs, 
@@ -1100,9 +1132,10 @@ def iter_download_nodes(
 @overload
 def iter_download_nodes(
     client: str | P115Client, 
-    pickcode: int | str, 
+    pickcode: int | str = "", 
     files: bool = True, 
     max_workers: None | int = 1, 
+    app: str = "android", 
     *, 
     async_: Literal[True], 
     **request_kwargs, 
@@ -1110,9 +1143,10 @@ def iter_download_nodes(
     ...
 def iter_download_nodes(
     client: str | P115Client, 
-    pickcode: int | str, 
+    pickcode: int | str = "", 
     files: bool = True, 
     max_workers: None | int = 1, 
+    app: str = "android", 
     *, 
     async_: Literal[False, True] = False, 
     **request_kwargs, 
@@ -1123,6 +1157,7 @@ def iter_download_nodes(
     :param pickcode: 目录的 提取码 或者 id
     :param files: 如果为 True，则只获取文件，否则只获取目录
     :param max_workers: 最大并发数，如果为 None 或 <= 0，则默认为 20
+    :param app: 使用某个 app （设备）的接口
     :param async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -1130,18 +1165,18 @@ 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 files:
         method = client.download_files
     else:
         method = client.download_folders
     if max_workers == 1:
-        def gen_step():
-            nonlocal pickcode
+        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"]
-            request_kwargs.setdefault("base_url", cycle(("http://proapi.115.com", "https://proapi.115.com")).__next__)
+            request_kwargs.setdefault("base_url", get_base_url)
             for i in count(1):
                 payload = {"pickcode": pickcode, "page": i}
                 resp = yield method(payload, async_=async_, **request_kwargs)
@@ -1158,7 +1193,7 @@ def iter_download_nodes(
             q = SimpleQueue()
         get, put = q.get, q.put_nowait
         max_page = 0
-        def request():
+        def request(pickcode):
             nonlocal max_page
             while True:
                 page = get_next_page()
@@ -1178,8 +1213,8 @@ def iter_download_nodes(
                 put(data["list"])
                 if not data["has_next_page"]:
                     max_page = page
-        def gen_step():
-            nonlocal max_workers, pickcode
+        def gen_step(pickcode):
+            nonlocal max_workers
             if async_:
                 if max_workers is None or max_workers <= 0:
                     max_workers = 20
@@ -1222,7 +1257,7 @@ def iter_download_nodes(
                             if not n:
                                 put(sentinel)
                 for i in range(n):
-                    submit(run_gen_step, request, async_=async_).add_done_callback(countdown)
+                    submit(run_gen_step, request(pickcode), async_=async_).add_done_callback(countdown)
                 while True:
                     ls = yield get
                     if ls is sentinel:
@@ -1232,7 +1267,26 @@ def iter_download_nodes(
                     yield YieldFrom(ls, identity=True)
             finally:
                 yield shutdown
-    return run_gen_step_iter(gen_step, async_=async_)
+    if pickcode:
+        return run_gen_step_iter(gen_step(pickcode), async_=async_)
+    else:
+        def chain():
+            with with_iter_next(iterdir(
+                client, 
+                ensure_file=False, 
+                app=app, 
+                normalize_attr=normalize_attr_simple, 
+                raise_for_changed_count=True, 
+                async_=async_, 
+                **request_kwargs, 
+            )) as get_next:
+                while True:
+                    attr = yield get_next
+                    yield YieldFrom(
+                        run_gen_step_iter(gen_step(attr["pickcode"]), async_=async_), 
+                        identity=True, 
+                    )
+        return run_gen_step_iter(chain, async_=async_)
 
 
 @overload
@@ -1243,6 +1297,7 @@ def iter_download_files(
     escape: None | bool | Callable[[str], str] = True, 
     with_ancestors: bool = True, 
     max_workers: None | int = None, 
+    app: str = "android", 
     *, 
     async_: Literal[False] = False, 
     **request_kwargs, 
@@ -1256,6 +1311,7 @@ def iter_download_files(
     escape: None | bool | Callable[[str], str] = True, 
     with_ancestors: bool = True, 
     max_workers: None | int = None, 
+    app: str = "android", 
     *, 
     async_: Literal[True], 
     **request_kwargs, 
@@ -1268,6 +1324,7 @@ def iter_download_files(
     escape: None | bool | Callable[[str], str] = True, 
     with_ancestors: bool = True, 
     max_workers: None | int = None, 
+    app: str = "android", 
     *, 
     async_: Literal[False, True] = False, 
     **request_kwargs, 
@@ -1291,6 +1348,7 @@ 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 async_: 是否异步
     :param request_kwargs: 其它请求参数
 
@@ -1358,9 +1416,9 @@ def iter_download_files(
             with with_iter_next(iterdir(
                 client, 
                 id_to_dirnode=id_to_dirnode, 
-                app="android", 
+                app=app, 
                 raise_for_changed_count=True, 
-                async_=async_, # type: ignore
+                async_=async_, 
                 **request_kwargs, 
             )) as get_next:
                 while True:
@@ -1375,7 +1433,10 @@ def iter_download_files(
                             **defaults, 
                         }, identity=True)
             for pickcode in pickcodes:
-                yield YieldFrom(run_gen_step_iter(gen_step(pickcode), async_=async_), identity=True)
+                yield YieldFrom(
+                    run_gen_step_iter(gen_step(pickcode), async_=async_), 
+                    identity=True, 
+                )
             return
         if not pickcode:
             resp = yield client.fs_file_skim(cid, async_=async_, **request_kwargs)
@@ -1402,6 +1463,7 @@ def iter_download_files(
                     pickcode, 
                     files=False, 
                     max_workers=max_workers, 
+                    app=app, 
                     async_=async_, 
                     **request_kwargs, 
                 )) as get_next:
@@ -1421,6 +1483,7 @@ def iter_download_files(
             pickcode, 
             files=True, 
             max_workers=max_workers, 
+            app=app, 
             async_=async_, # type: ignore
             **request_kwargs, 
         )) as get_next:
@@ -1446,3 +1509,79 @@ def iter_download_files(
             yield YieldFrom(map(norm_attr, cache), identity=True)
     return run_gen_step_iter(gen_step, async_=async_)
 
+
+@overload
+def get_remaining_open_count(
+    client: str | P115Client, 
+    app: str = "android", 
+    *, 
+    async_: Literal[False] = False, 
+    **request_kwargs, 
+) -> int:
+    ...
+@overload
+def get_remaining_open_count(
+    client: str | P115Client, 
+    app: str = "android", 
+    *, 
+    async_: Literal[True], 
+    **request_kwargs, 
+) -> Coroutine[Any, Any, int]:
+    ...
+def get_remaining_open_count(
+    client: str | P115Client, 
+    app: str = "android", 
+    *, 
+    async_: Literal[False, True] = False, 
+    **request_kwargs, 
+) -> int | Coroutine[Any, Any, int]:
+    """获取剩余的可打开下载链接数
+
+    .. note::
+        假设总数是 n，通常总数是 10，偶尔会调整，如果已经有 m 个被打开的链接，则返回的数字是 n-m
+
+    :param client: 115 客户端或 cookies
+    :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":
+        get_url: Callable[..., P115URL] = client.download_url_open
+    elif app in ("", "web", "desktop", "harmony"):
+        get_url = client.download_url
+    else:
+        get_url = partial(client.download_url, app=app)
+    def gen_step():
+        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:
+                while True:
+                    info = yield get_next
+                    if int(info["fs"]) <= 1024 * 1024 * 200:
+                        continue
+                    try:
+                        url = yield get_url(info["pc"], async_=async_)
+                    except FileNotFoundError:
+                        continue
+                    request = Request(url, headers={"user-agent": ""})
+                    if async_:
+                        file = yield to_thread(urlopen, request)
+                    else:
+                        file = urlopen(request)
+                    add_to_cache(file)
+        finally:
+            for f in cache:
+                f.close()
+            return len(cache)
+    return run_gen_step(gen_step, async_=async_)
+

{p115client-0.0.5.8.3 → p115client-0.0.5.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "p115client"
-version = "0.0.5.8.3"
+version = "0.0.5.8.4"
 description = "Python 115 webdisk client."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
@@ -48,7 +48,7 @@ python-filewrap = ">=0.2.8"
 python-hashtools = ">=0.0.3.3"
 python-httpfile = ">=0.0.5.2"
 python-http_request = ">=0.0.6"
-python-iterutils = ">=0.1.8"
+python-iterutils = ">=0.1.10"
 python-property = ">=0.0.3"
 python-startfile = ">=0.0.2"
 python-undefined = ">=0.0.3"