p115client 0.0.5.8.7__py3-none-any.whl → 0.0.5.9.1__py3-none-any.whl

p115client/tool/pool.py

@@ -1,25 +1,54 @@
 #!/usr/bin/env python3
 # encoding: utf-8
 
+from __future__ import annotations
+
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
 __all__ = [
-    "generate_cookies_factory", "generate_client_factory", "cookies_pool", "client_pool", 
-    "call_wrap_with_cookies_pool", 
+    "generate_auth_factory", "generate_cookies_factory", "generate_client_factory", 
+    "auth_pool", "cookies_pool", "client_pool", "call_wrap_with_pool", 
 ]
 __doc__ = "这个模块提供了一些和 cookies 池有关的函数"
 
 from asyncio import Lock as AsyncLock
-from collections import deque
-from collections.abc import Callable, Iterable, Sequence
-from functools import partial, update_wrapper
+from collections.abc import Callable, Iterable
+from functools import partial, total_ordering, update_wrapper
+from heapq import heappop, heappush, heapify
+from itertools import cycle, repeat
+from math import inf, isinf
 from threading import Lock
 from time import time
-from typing import Any
+from typing import cast, Any
 
 from iterutils import run_gen_step
 from p115client import check_response, P115Client
-from p115client.const import APP_TO_SSOENT
-from p115client.exception import P115OSError, AuthenticationError
+from p115client.exception import P115OSError, AuthenticationError, LoginError
+
+
+@total_ordering
+class ComparedWithID[T]:
+    value: T
+
+    def __new__(cls, value: T | ComparedWithID[T], /):
+        if isinstance(value, ComparedWithID):
+            return value
+        else:
+            self = super().__new__(cls)
+            self.value = value
+            return self
+
+    def __eq__(self, other, /) -> bool:
+        if isinstance(other, ComparedWithID):
+            return id(self) == id(other.value)
+        return id(self) == id(other)
+
+    def __lt__(self, other, /) -> bool:
+        if isinstance(other, ComparedWithID):
+            return id(self) < id(other.value)
+        return id(self) < id(other)
+
+    def __repr__(self, /) -> str:
+        return f"{type(self).__qualname__}({self.value!r})"
 
 
 def get_status(e: BaseException, /) -> None | int:
@@ -48,107 +77,171 @@ def is_timeouterror(exc: Exception) -> bool:
     return False
 
 
-def generate_cookies_factory(
+def generate_auth_factory(
     client: str | P115Client, 
-    app: str = "", 
+    app_ids: Iterable[int] = range(100195123, 100196659, 2), 
     **request_kwargs, 
 ) -> Callable:
-    """利用一个已登录设备的 cookies，产生另一个设备的若干 cookies
+    """利用一个已登录设备的 cookies，产生若干开放应用的 access_token
 
     :param client: 115 客户端或 cookies
-    :param app: 自动扫码后绑定的 app
+    :param app_ids: 一组开放应用的 AppID
     :param request_kwargs: 其它请求参数
 
-    :return: 函数，调用以返回一个 cookies
+    :return: 函数，调用以返回一个字典，包含 authorization 请求头
     """
     if isinstance(client, str):
         client = P115Client(client, check_for_relogin=True)
-    if app:
-        if APP_TO_SSOENT.get(app) == client.login_ssoent:
-            raise ValueError("same login device will cause conflicts")
-    else:
-        app = "tv" if client.login_ssoent == "R2" else "alipaymini"
-    login = client.login_with_app
+    login = client.login_with_open
+    get_app_id = cycle(app_ids).__next__
     def make_cookies(async_: bool = False):
-        def call():
+        def gen_step():
             while True:
+                app_id = get_app_id()
                 try:
-                    resp = yield login(app, async_=async_, **request_kwargs) # type: ignore
+                    resp = yield login(
+                        get_app_id(), 
+                        async_=async_, # type: ignore
+                        **request_kwargs, 
+                    )
                 except Exception as e:
                     if not is_timeouterror(e):
                         raise
                 check_response(resp)
-                return "; ".join(f"{k}={v}" for k, v in resp["data"]["cookie"].items())
-        return run_gen_step(call, async_=async_)
+                return {
+                    "authorization": "Bearer " + resp["data"]["access_token"], 
+                    "app_id": str(app_id), 
+                }
+        return run_gen_step(gen_step, async_=async_)
     return make_cookies
 
 
-def generate_client_factory(
+def generate_cookies_factory(
     client: str | P115Client, 
-    app: str = "", 
+    app: str | Iterable[str] = "", 
     **request_kwargs, 
 ) -> Callable:
-    """利用一个已登录设备的 client，产生另一个设备的若干 client
+    """利用一个已登录设备的 cookies，产生另一个设备的若干 cookies
 
     :param client: 115 客户端或 cookies
-    :param app: 自动扫码后绑定的 app
+    :param app: 自动扫码后绑定的 app（多个则传入一组 app 的可迭代对象）
     :param request_kwargs: 其它请求参数
 
-    :return: 函数，调用以返回一个 client
+    :return: 函数，调用以返回一个字典，包含 cookie 请求头
     """
     if isinstance(client, str):
         client = P115Client(client, check_for_relogin=True)
-    if app:
-        if APP_TO_SSOENT.get(app) == client.login_ssoent:
-            raise ValueError("same login device will cause conflicts")
+    if isinstance(app, str):
+        if app:
+            if app == client.login_app():
+                raise ValueError(f"same login device (app={app!r}) will cause conflicts")
+        else:
+            app = "tv" if client.login_ssoent == "R2" else "alipaymini"
+        get_app = repeat(app).__next__
     else:
-        app = "tv" if client.login_ssoent == "R2" else "alipaymini"
-    login = client.login_another_app
-    def make_client(async_: bool = False):
-        def call():
+        app = tuple(app)
+        if client.login_app() in app:
+            raise ValueError(f"same login device (app={app!r}) will cause conflicts")
+        elif not app:
+            app = "tv" if client.login_ssoent == "R2" else "alipaymini"
+            get_app = repeat(app).__next__
+        else:
+            get_app = cycle(app).__next__
+    login = client.login_with_app
+    def make_cookies(async_: bool = False):
+        def gen_step():
             while True:
+                app = get_app()
                 try:
-                    return (yield login(app, async_=async_, **request_kwargs)) # type: ignore
+                    resp = yield login(
+                        app, 
+                        async_=async_, # type: ignore
+                        **request_kwargs, 
+                    )
                 except Exception as e:
                     if not is_timeouterror(e):
                         raise
-        return run_gen_step(call, async_=async_)
+                check_response(resp)
+                return {
+                    "cookie": "; ".join(f"{k}={v}" for k, v in resp["data"]["cookie"].items()), 
+                    "app": app, 
+                }
+        return run_gen_step(gen_step, async_=async_)
+    return make_cookies
+
+
+def generate_client_factory(
+    client: str | P115Client, 
+    app: str | Iterable[str] = "", 
+    **request_kwargs, 
+) -> Callable:
+    """利用一个已登录设备的 client，产生另一个设备的若干 client
+
+    :param client: 115 客户端或 cookies
+    :param app: 自动扫码后绑定的 app（多个则传入一组 app 的可迭代对象）
+    :param request_kwargs: 其它请求参数
+
+    :return: 函数，调用以返回一个 client
+    """
+    cls = type(client)
+    call = generate_cookies_factory(client, app, **request_kwargs)
+    def make_client(async_: bool = False):
+        def gen_step():
+            headers = yield call(async_=async_)
+            return cls(headers["cookie"])
+        return run_gen_step(gen_step, async_=async_)
     return make_client
 
 
-def make_pool(
+def make_pool[T](
     generate_factory: Callable, 
-    initial_values: Iterable = (), 
+    heap: None | list[tuple[float, T | ComparedWithID[T]]] = None, 
     cooldown_time: int | float = 1, 
+    live_time: int | float = inf, 
     lock: bool = True, 
     **request_kwargs, 
 ) -> Callable:
-    """值の池
+    """创建池
 
     :param generate_factory: 产生值的工厂函数
-    :param initial_values: 一组初始值
-    :param cooldown_time: cookies 的冷却时间
+    :param heap: 最小堆，可以包含一组初始值，各是一个元组，包含（上一次获取时刻, 值）
+    :param cooldown_time: 值的冷却时间
+    :param live_time: 值的存活时间，默认是无穷大
     :param lock: 是否需要锁
     :param request_kwargs: 其它请求参数
 
     :return: 返回一个函数，调用后返回一个元组，包含 值 和 一个调用以在完成后把 值 返还池中
     """
     generate = generate_factory(**request_kwargs)
-    dq: deque[tuple[Any, float, int]] = deque(((a, time(), 0) for a in initial_values))
-    push, pop = dq.append, dq.popleft
+    if heap is None:
+        heap_: list[tuple[float,  ComparedWithID[T]]] = []
+    else:
+        for i, (a, b) in enumerate(heap):
+            heap[i] = (a, ComparedWithID(b))
+        heapify(heap)
+        heap_ = heap # type: ignore
     def get_value(async_: bool = False):
         def call():
-            n = 0
-            if dq and dq[0][1] + cooldown_time < time():
-                value, _, n = pop()
-            elif async_:
-                value = yield generate(async_=True)
+            now = time()
+            if not isinf(live_time):
+                watermark = now - live_time
+                while heap_:
+                    if heap_[0][0] > watermark:
+                        break
+                    heappop(heap_)
+            if heap_ and heap_[0][0] + cooldown_time <= now:
+                _, val = heappop(heap_)
+                value = val.value
             else:
-                value = generate()
-            return value + f"; n={n}", partial(push, (value, time(), n+1))
+                if async_:
+                    value = yield generate(async_=True)
+                else:
+                    value = generate()
+                val = ComparedWithID(value)
+            return value, partial(heappush, heap_, (time(), val))
         return run_gen_step(call, async_=async_)
     if not lock:
-        setattr(get_value, "deque", dq)
+        setattr(get_value, "heap", heap_)
         return get_value
     lock_sync = Lock()
     lock_async = AsyncLock()
@@ -163,35 +256,71 @@ def make_pool(
                 with lock_sync:
                     return get_value()
             return locked_get_value
-    setattr(locked_get_value, "deque", dq)
+    setattr(locked_get_value, "heap", heap_)
     return locked_get_value
 
 
+def auth_pool(
+    client: str | P115Client, 
+    app_ids: Iterable[int] = range(100195123, 100196659, 2), 
+    heap: None | list[tuple[float, dict | ComparedWithID[dict]]] = None, 
+    cooldown_time: int | float = 1, 
+    live_time: int | float = 7000, 
+    lock: bool = False, 
+    **request_kwargs, 
+) -> Callable:
+    """authorization 请求头池
+
+    :param client: 115 客户端或 cookies
+    :param app_ids: 一组开放应用的 AppID
+    :param heap: 最小堆，可以包含一组初始值，各是一个元组，包含（上一次获取时刻, 值）
+    :param cooldown_time: 值的冷却时间
+    :param live_time: 值的存活时间，默认是无穷大
+    :param lock: 锁，如果不需要锁，传入 False
+    :param request_kwargs: 其它请求参数
+
+    :return: 返回一个函数，调用后返回一个元组，包含值 和 一个调用（以在完成后把值返还池中）
+    """
+    return make_pool(
+        generate_auth_factory, 
+        client=client, 
+        app_ids=app_ids, 
+        heap=heap, 
+        cooldown_time=cooldown_time, 
+        live_time=live_time, 
+        lock=lock, 
+        **request_kwargs, 
+    )
+
+
 def cookies_pool(
     client: str | P115Client, 
-    app: None | str = None, 
-    initial_values: Iterable[str] = (), 
+    app: str | Iterable[str] = "", 
+    heap: None | list[tuple[float, dict | ComparedWithID[dict]]] = None, 
     cooldown_time: int | float = 1, 
+    live_time: int | float = inf, 
     lock: bool = False, 
     **request_kwargs, 
 ) -> Callable:
-    """cookies 池
+    """cookie 请求头池
 
     :param client: 115 客户端或 cookies
-    :param app: 自动扫码后绑定的 app
-    :param initial_values: 一组初始值
-    :param cooldown_time: cookies 的冷却时间
+    :param app: 自动扫码后绑定的 app（多个则传入一组 app 的可迭代对象）
+    :param heap: 最小堆，可以包含一组初始值，各是一个元组，包含（上一次获取时刻, 值）
+    :param cooldown_time: 值的冷却时间
+    :param live_time: 值的存活时间，默认是无穷大
     :param lock: 锁，如果不需要锁，传入 False
     :param request_kwargs: 其它请求参数
 
-    :return: 返回一个函数，调用后返回一个元组，包含 cookies 和 一个调用以在完成后把 cookies 返还池中
+    :return: 返回一个函数，调用后返回一个元组，包含值 和 一个调用（以在完成后把值返还池中）
     """
     return make_pool(
         generate_cookies_factory, 
         client=client, 
         app=app, 
-        initial_values=initial_values, 
+        heap=heap, 
         cooldown_time=cooldown_time, 
+        live_time=live_time, 
         lock=lock, 
         **request_kwargs, 
     )
@@ -199,84 +328,70 @@ def cookies_pool(
 
 def client_pool(
     client: str | P115Client, 
-    app: None | str = None, 
-    initial_values: Iterable[P115Client] = (), 
+    app: str | Iterable[str] = "", 
+    heap: None | list[tuple[float, P115Client | ComparedWithID[P115Client]]] = None, 
     cooldown_time: int | float = 1, 
+    live_time: int | float = inf, 
     lock: bool = False, 
     **request_kwargs, 
 ) -> Callable:
     """client 池
 
     :param client: 115 客户端或 cookies
-    :param app: 自动扫码后绑定的 app
-    :param initial_values: 一组初始值
-    :param cooldown_time: cookies 的冷却时间
+    :param app: 自动扫码后绑定的 app（多个则传入一组 app 的可迭代对象）
+    :param heap: 最小堆，可以包含一组初始值，各是一个元组，包含（上一次获取时刻, 值）
+    :param cooldown_time: 值的冷却时间
+    :param live_time: 值的存活时间，默认是无穷大
     :param lock: 锁，如果不需要锁，传入 False
     :param request_kwargs: 其它请求参数
 
-    :return: 返回一个函数，调用后返回一个元组，包含 client 和 一个调用以在完成后把 client 返还池中
+    :return: 返回一个函数，调用后返回一个元组，包含值 和 一个调用（以在完成后把值返还池中）
     """
     return make_pool(
         generate_client_factory, 
         client=client, 
         app=app, 
-        initial_values=initial_values, 
+        heap=heap, 
         cooldown_time=cooldown_time, 
+        live_time=live_time, 
         lock=lock, 
         **request_kwargs, 
     )
 
 
-def call_wrap_with_cookies_pool(
-    get_cookies: Callable, 
-    /, 
-    func: Callable = P115Client("").fs_files, 
-    check: bool | Callable = True, 
-    base_url_seq: None | Sequence = None, 
-) -> Callable:
-    """包装函数，使得用 cookies 池执行请求
+def call_wrap_with_pool(get_cert_headers: Callable, /, func: Callable) -> Callable:
+    """包装函数，用认证信息请求头的分发池执行请求
 
-    :param get_cookies: 获取 cookies 的函数
+    :param get_cert_headers: 获取认证信息的请求头的函数
     :param func: 执行请求的函数
     """
     def wrapper(*args, headers=None, async_: bool = False, **kwds):
-        def call():
+        def gen_step():
             nonlocal headers
-            if async_:
-                cookies, revert = yield get_cookies(async_=True)
-            else:
-                cookies, revert = get_cookies()
-            if "base_url" not in kwds and base_url_seq:
-                kwds["base_url"] = base_url_seq[int(cookies.rpartition("=")[-1]) % len(base_url_seq)]
             while True:
+                if async_:
+                    cert_headers, revert = yield get_cert_headers(async_=True)
+                else:
+                    cert_headers, revert = get_cert_headers()
                 if headers:
-                    headers = dict(headers, Cookie=cookies)
+                    headers = dict(headers, **cert_headers)
                 else:
-                    headers = {"Cookie": cookies}
+                    headers = cert_headers
                 try:
                     if async_:
                         resp = yield func(*args, headers=headers, async_=True, **kwds)
                     else:
                         resp = func(*args, headers=headers, **kwds)
-                    if check:
-                        if check is True:
-                            check_response(resp)
-                        else:
-                            check(resp)
-                    revert()
+                    if not isinstance(resp, dict) or resp.get("errno") != 40101004:
+                        revert()
                     return resp
                 except BaseException as e:
                     if isinstance(e, P115OSError) and e.args[1].get("errno") == 40101004:
                         raise
-                    elif isinstance(e, AuthenticationError) or get_status(e) == 405:
-                        if async_:
-                            cookies, revert = yield get_cookies(async_=True)
-                        else:
-                            cookies, revert = get_cookies()
-                        continue
-                    revert()
-                    raise
-        return run_gen_step(call, async_=async_)
+                    if not isinstance(e, (AuthenticationError, LoginError)) and get_status(e) != 405:
+                        revert()
+                        raise
+        return run_gen_step(gen_step, async_=async_)
     return update_wrapper(wrapper, func)
 
 # TODO: 需要完整的类型签名

{p115client-0.0.5.8.7.dist-info → p115client-0.0.5.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: p115client
-Version: 0.0.5.8.7
+Version: 0.0.5.9.1
 Summary: Python 115 webdisk client.
 Home-page: https://github.com/ChenyangGao/p115client
 License: MIT

{p115client-0.0.5.8.7.dist-info → p115client-0.0.5.9.1.dist-info}/RECORD

@@ -1,23 +1,24 @@
 LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
 p115client/__init__.py,sha256=1mx7njuAlqcuEWONTjSiiGnXyyNyqOcJyNX1FMHqQ-4,214
 p115client/_upload.py,sha256=DOckFLU_P7Fl0BNu_0-2od6pPsCnzroYY6zZE5_EMnM,30735
-p115client/client.py,sha256=GhLFoGzmZunVqMajS6xZZqs5k-I_2sR9LQlP102MFjE,718070
+p115client/client.py,sha256=XsOy9BVOqu2jof7rGIMUldVZSiuQNAku379kIiZPr-E,721350
 p115client/const.py,sha256=maIZfJAiUuEnXIKc8TMAyW_UboDUJPwYpPS8LjPFp_U,4321
 p115client/exception.py,sha256=Ugjr__aSlYRDYwoOz7273ngV-gFX2z-ohsJmCba8nnQ,2657
 p115client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-p115client/tool/__init__.py,sha256=2YrKoAcFYOuqu2nUBoPVhxMOseAvcLE_LcnbZV11UKw,324
+p115client/tool/__init__.py,sha256=x1x4yt3Ylim5CbFO4M-Fu62Gd99pUFpb3-5ssL6l-_Y,346
 p115client/tool/download.py,sha256=DneVsbryn4d47RkS62ghF5Xz8vkDq6U0n2hj1W5g4iY,61176
 p115client/tool/edit.py,sha256=3hQ5J3hHQx4yNsGcWSechBYAvZRSQUxfXLXuqXiDKmk,17789
 p115client/tool/export_dir.py,sha256=iMnKtnESi8HKvW9WhIvOdEoMXSBpAnhFlGeyKXHpQbE,24545
 p115client/tool/fs_files.py,sha256=hkezLKrtTAGPDkPxwq6jMrm8s2-unHZQBR7cDvh41qs,16027
+p115client/tool/history.py,sha256=2S26BH7uBNfVHlbYFNy-aNOLMcM-HrlR7TLHAZacUJI,7458
 p115client/tool/iterdir.py,sha256=T6bsD8A896nHgVxKYu2dkIo-5Az2svL4iLm2uHQWyHg,187517
-p115client/tool/life.py,sha256=SJ1dAvRYCWTUz1gPrCWv-_G1Rq5yPfxDgY7KT-2UP4A,17528
-p115client/tool/pool.py,sha256=vM5ItMxELtT7_bvbmdhwWj81rQ0zyaj3uPMny4KDw_E,9757
+p115client/tool/life.py,sha256=9ncoB2dNibhgOjPb9mHr873fCZmb65ZeteVLH4Tsujc,17330
+p115client/tool/pool.py,sha256=_3eFHTHW5Bhs17AwF8awitE4n1UuvFGIkZUZ-saJ7zQ,14233
 p115client/tool/request.py,sha256=SWsezW9EYZGS3R-TbZxMG-8bN3YWJ0-GzgvKlvRBSCM,7042
 p115client/tool/upload.py,sha256=qK1OQYxP-Faq2eMDhc5sBXJiSr8m8EZ_gb0O_iA2TrI,15915
 p115client/tool/xys.py,sha256=n89n9OLBXx6t20L61wJgfrP6V4jW3sHgyaQNBLdUwUQ,3578
 p115client/type.py,sha256=e4g9URQBE23XN2dGomldj8wC6NlDWBBSVC5Bmd8giBc,5993
-p115client-0.0.5.8.7.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-p115client-0.0.5.8.7.dist-info/METADATA,sha256=v74Y9_1ZIk2j2CvMT-9q4RIUDH1FqsRnYCSbqt2ZifU,8233
-p115client-0.0.5.8.7.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-p115client-0.0.5.8.7.dist-info/RECORD,,
+p115client-0.0.5.9.1.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+p115client-0.0.5.9.1.dist-info/METADATA,sha256=_NxUFNOa5O4B2Ek-NsKRlEFhR-sWQ5OUZT8G2Xe1nFY,8233
+p115client-0.0.5.9.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+p115client-0.0.5.9.1.dist-info/RECORD,,