p123client 0.0.7.1.1__py3-none-any.whl → 0.0.7.2__py3-none-any.whl

p123client/client.py

@@ -7,6 +7,7 @@ __all__ = ["check_response", "P123OpenClient", "P123Client"]
 
 import errno
 
+from asyncio import Lock as AsyncLock
 from base64 import urlsafe_b64decode
 from collections.abc import (
     AsyncIterable, Awaitable, Buffer, Callable, Coroutine, 
@@ -17,7 +18,7 @@ from functools import partial
 from hashlib import md5
 from http.cookiejar import CookieJar
 from inspect import isawaitable
-from itertools import chain
+from itertools import chain, count
 from os import fsdecode, fstat, isatty, PathLike
 from os.path import basename
 from pathlib import Path, PurePath
@@ -25,6 +26,7 @@ from re import compile as re_compile, MULTILINE
 from string import digits, hexdigits, ascii_uppercase
 from sys import _getframe
 from tempfile import TemporaryFile
+from threading import Lock
 from typing import cast, overload, Any, Final, Literal, Self
 from urllib.parse import parse_qsl, urlsplit
 from uuid import uuid4
@@ -48,7 +50,8 @@ from yarl import URL
 
 from .const import CLIENT_API_METHODS_MAP, CLIENT_METHOD_API_MAP
 from .exception import (
-    P123OSError, P123BrokenUpload, P123LoginError, P123AuthenticationError, P123FileNotFoundError, 
+    P123Warning, P123OSError, P123BrokenUpload, P123LoginError, 
+    P123AuthenticationError, P123FileNotFoundError, 
 )
 
 
@@ -210,48 +213,128 @@ def check_response(resp: dict | Awaitable[dict], /) -> dict | Coroutine[Any, Any
 
 
 class P123OpenClient:
-    """123 网盘客户端
+    """123 网盘客户端，仅使用开放接口
 
     .. admonition:: Reference
 
         https://123yunpan.yuque.com/org-wiki-123yunpan-muaork/cr6ced
-    """
 
+    :param client_id: 应用标识，创建应用时分配的 appId
+    :param client_secret: 应用密钥，创建应用时分配的 secretId
+    :param token: 123 的访问令牌
+    :param refresh_token: 刷新令牌
+    :param check_for_relogin: 当 access_token 失效时，是否重新登录
+    """
     client_id: str = ""
     client_secret: str = ""
     refresh_token: str = ""
     token_path: None | PurePath = None
+    check_for_relogin: bool = False
 
     def __init__(
-        self, /, 
+        self, 
+        /, 
         client_id: str | PathLike = "", 
         client_secret: str = "", 
         token: None | str | PathLike = None, 
         refresh_token: str = "", 
+        check_for_relogin: bool = True, 
     ):
-        if isinstance(client_id, PathLike):
-            token = client_id
-        else:
-            self.client_id = client_id
-        self.client_secret = client_secret
-        self.refresh_token = refresh_token
-        if token is None:
-            if client_id and client_secret or refresh_token:
-                self.login_open()
-        elif isinstance(token, str):
-            self.token = token.removeprefix("Bearer ")
-        else:
-            if isinstance(token, PurePath) and hasattr(token, "open"):
-                self.token_path = token
-            else:
-                self.token_path = Path(fsdecode(token))
-            self._read_token()
-            if not self.token and (client_id and client_secret or refresh_token):
-                self.login_open()
+        self.init(
+            client_id=client_id, 
+            client_secret=client_secret, 
+            token=token, 
+            refresh_token=refresh_token, 
+            check_for_relogin=check_for_relogin, 
+            instance=self, 
+        )
 
     def __del__(self, /):
         self.close()
 
+    @overload
+    @classmethod
+    def init(
+        cls, 
+        /, 
+        client_id: str | PathLike = "", 
+        client_secret: str = "", 
+        token: None | str | PathLike = None, 
+        refresh_token: str = "", 
+        check_for_relogin: bool = True, 
+        instance: None | Self = None, 
+        *, 
+        async_: Literal[False] = False, 
+        **request_kwargs, 
+    ) -> P123OpenClient:
+        ...
+    @overload
+    @classmethod
+    def init(
+        cls, 
+        /, 
+        client_id: str | PathLike = "", 
+        client_secret: str = "", 
+        token: None | str | PathLike = None, 
+        refresh_token: str = "", 
+        check_for_relogin: bool = True, 
+        instance: None | Self = None, 
+        *, 
+        async_: Literal[True], 
+        **request_kwargs, 
+    ) -> Coroutine[Any, Any, P123OpenClient]:
+        ...
+    @classmethod
+    def init(
+        cls, 
+        /, 
+        client_id: str | PathLike = "", 
+        client_secret: str = "", 
+        token: None | str | PathLike = None, 
+        refresh_token: str = "", 
+        check_for_relogin: bool = True, 
+        instance: None | Self = None, 
+        *, 
+        async_: Literal[False, True] = False, 
+        **request_kwargs, 
+    ) -> P123OpenClient | Coroutine[Any, Any, P123OpenClient]:
+        def gen_step():
+            nonlocal token
+            if instance is None:
+                self = cls.__new__(cls)
+            else:
+                self = instance
+            if isinstance(client_id, PathLike):
+                token = client_id
+            else:
+                self.client_id = client_id
+            self.client_secret = client_secret
+            self.refresh_token = refresh_token
+            if token is None:
+                if client_id and client_secret or refresh_token:
+                    yield self.login_open(async_=async_, **request_kwargs)
+            elif isinstance(token, str):
+                self.token = token.removeprefix("Bearer ")
+            else:
+                if isinstance(token, PurePath) and hasattr(token, "open"):
+                    self.token_path = token
+                else:
+                    self.token_path = Path(fsdecode(token))
+                self._read_token()
+                if not self.token and (client_id and client_secret or refresh_token):
+                    yield self.login_open(async_=async_, **request_kwargs)
+            self.check_for_relogin = check_for_relogin
+            return self
+        return run_gen_step(gen_step, async_)
+
+    @locked_cacheproperty
+    def request_lock(self, /) -> Lock:
+        return Lock()
+
+    @locked_cacheproperty
+    def request_alock(self, /) -> AsyncLock:
+        return AsyncLock()
+
     @property
     def cookies(self, /):
         """请求所用的 Cookies 对象（同步和异步共用）
@@ -380,6 +463,12 @@ class P123OpenClient:
         self.__dict__.pop("session", None)
         self.__dict__.pop("async_session", None)
 
+    def can_relogin(self, /) -> bool:
+        return self.check_for_relogin and bool(
+            self.client_id and self.client_secret or 
+            getattr(self, "refresh_token")
+        )
+
     def request(
         self, 
         /, 
@@ -397,22 +486,57 @@ class P123OpenClient:
         request_kwargs.setdefault("parse", default_parse)
         if request is None:
             request_kwargs["session"] = self.async_session if async_ else self.session
-            return get_default_request()(
-                url=url, 
-                method=method, 
-                async_=async_, 
-                **request_kwargs, 
-            )
+            request_kwargs["async_"] = async_
+            request = get_default_request()
+        if self.can_relogin():
+            headers = dict(self.headers)
+            if request_headers := request_kwargs.get("headers"):
+                headers.update(request_headers)
+            headers.setdefault("authorization", "")
+            request_kwargs["headers"] = headers
         else:
-            if headers := request_kwargs.get("headers"):
-                request_kwargs["headers"] = {**self.headers, **headers}
-            else:
-                request_kwargs["headers"] = self.headers
             return request(
                 url=url, 
                 method=method, 
                 **request_kwargs, 
             )
+        def gen_step():
+            if async_:
+                lock: Lock | AsyncLock = self.request_alock
+            else:
+                lock = self.request_lock
+            headers = request_kwargs["headers"]
+            if "authorization" not in headers:
+                headers["authorization"] = "Bearer " + self.token
+            for i in count(0):
+                token = headers["authorization"].removeprefix("Bearer ")
+                resp = yield cast(Callable, request)(
+                    url=url, 
+                    method=method, 
+                    **request_kwargs, 
+                )
+                if not (isinstance(resp, dict) and resp.get("code") == 401):
+                    return resp
+                yield lock.acquire()
+                try:
+                    token_new: str = self.token
+                    if token == token_new:
+                        if self.__dict__.get("token_path"):
+                            token_new = self._read_token() or ""
+                            if token != token_new:
+                                headers["authorization"] = "Bearer " + self.token
+                                continue
+                        if i:
+                            raise
+                        user_id = getattr(self, "user_id", None)
+                        warn(f"relogin to refresh token: {user_id=}", category=P123Warning)
+                        yield self.login(replace=True, async_=async_)
+                        headers["authorization"] = "Bearer " + self.token
+                    else:
+                        headers["authorization"] = "Bearer " + token_new
+                finally:
+                    lock.release()
+        return run_gen_step(gen_step, async_)
 
     @overload
     def login(
@@ -5549,52 +5673,132 @@ class P123Client(P123OpenClient):
         client_id: str = "", 
         client_secret: str = "", 
         refresh_token: str = "", 
+        check_for_relogin: bool = True, 
     ):
-        if (isinstance(passport, PathLike) or
-            not token and 
-            isinstance(passport, str) and 
-            len(passport) >= 128
-        ):
-            token = passport
-        elif (not refresh_token and 
-            isinstance(passport, str) and 
-            len(passport) >= 48 and 
-            not passport.strip(digits+ascii_uppercase)
-        ):
-            refresh_token = passport
-        elif (not client_id and 
-            isinstance(passport, str) and 
-            len(passport) >= 32 and 
-            not passport.strip(digits+"abcdef")
-        ):
-            client_id = passport
-        else:
-            self.passport = passport
-        if (not client_secret and 
-            isinstance(password, str) 
-            and len(password) >= 32 and 
-            not password.strip(digits+"abcdef")
-        ):
-            client_secret = password
-        else:
-            self.password = password
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.refresh_token = refresh_token
-        if token is None:
-            self.login()
-        elif isinstance(token, str):
-            self.token = token.removeprefix("Bearer ")
-        else:
-            if isinstance(token, PurePath) and hasattr(token, "open"):
-                self.token_path = token
+        self.init(
+            passport=passport, 
+            password=password, 
+            token=token, 
+            client_id=client_id, 
+            client_secret=client_secret, 
+            refresh_token=refresh_token, 
+            check_for_relogin=check_for_relogin, 
+            instance=self, 
+        )
+
+    @overload # type: ignore
+    @classmethod
+    def init(
+        cls, 
+        /, 
+        passport: int | str | PathLike = "", 
+        password: str = "", 
+        token: None | str | PathLike = None, 
+        client_id: str = "", 
+        client_secret: str = "", 
+        refresh_token: str = "", 
+        check_for_relogin: bool = True, 
+        instance: None | Self = None, 
+        *, 
+        async_: Literal[False] = False, 
+        **request_kwargs, 
+    ) -> P123Client:
+        ...
+    @overload
+    @classmethod
+    def init(
+        cls, 
+        /, 
+        passport: int | str | PathLike = "", 
+        password: str = "", 
+        token: None | str | PathLike = None, 
+        client_id: str = "", 
+        client_secret: str = "", 
+        refresh_token: str = "", 
+        check_for_relogin: bool = True, 
+        instance: None | Self = None, 
+        *, 
+        async_: Literal[True], 
+        **request_kwargs, 
+    ) -> Coroutine[Any, Any, P123Client]:
+        ...
+    @classmethod
+    def init(
+        cls, 
+        /, 
+        passport: int | str | PathLike = "", 
+        password: str = "", 
+        token: None | str | PathLike = None, 
+        client_id: str = "", 
+        client_secret: str = "", 
+        refresh_token: str = "", 
+        check_for_relogin: bool = True, 
+        instance: None | Self = None, 
+        *, 
+        async_: Literal[False, True] = False, 
+        **request_kwargs, 
+    ) -> P123Client | Coroutine[Any, Any, P123Client]:
+        def gen_step():
+            nonlocal token, refresh_token, client_id, client_secret
+            if instance is None:
+                self = cls.__new__(cls)
+            else:
+                self = instance
+            if (isinstance(passport, PathLike) or
+                not token and 
+                isinstance(passport, str) and 
+                len(passport) >= 128
+            ):
+                token = passport
+            elif (not refresh_token and 
+                isinstance(passport, str) and 
+                len(passport) >= 48 and 
+                not passport.strip(digits+ascii_uppercase)
+            ):
+                refresh_token = passport
+            elif (not client_id and 
+                isinstance(passport, str) and 
+                len(passport) >= 32 and 
+                not passport.strip(digits+"abcdef")
+            ):
+                client_id = passport
+            else:
+                self.passport = passport
+            if (not client_secret and 
+                isinstance(password, str) 
+                and len(password) >= 32 and 
+                not password.strip(digits+"abcdef")
+            ):
+                client_secret = password
+            else:
+                self.password = password
+            self.client_id = client_id
+            self.client_secret = client_secret
+            self.refresh_token = refresh_token
+            if token is None:
+                yield self.login(async_=async_, **request_kwargs)
+            elif isinstance(token, str):
+                self.token = token.removeprefix("Bearer ")
             else:
-                self.token_path = Path(fsdecode(token))
-            self._read_token()
-            if not self.token:
-                self.login()
-        if not self.passport:
-            self.passport = self.token_user_info["username"]
+                if isinstance(token, PurePath) and hasattr(token, "open"):
+                    self.token_path = token
+                else:
+                    self.token_path = Path(fsdecode(token))
+                self._read_token()
+                if not self.token:
+                    yield self.login(async_=async_, **request_kwargs)
+            if not self.passport:
+                self.passport = self.token_user_info["username"]
+            self.check_for_relogin = check_for_relogin
+            return self
+        return run_gen_step(gen_step, async_)
+
+    def can_relogin(self, /) -> bool:
+        return self.check_for_relogin and bool(
+            self.passport and self.password or
+            self.client_id and self.client_secret or 
+            getattr(self, "refresh_token")
+        )
 
     @overload # type: ignore
     def login(
@@ -8476,7 +8680,7 @@ class P123Client(P123OpenClient):
     @overload
     def offline_task_list(
         self, 
-        payload: dict | int = 1, 
+        payload: dict | int | list[int] | tuple[int] = 1, 
         /, 
         base_url: str | Callable[[], str] = DEFAULT_BASE_URL, 
         *, 
@@ -8487,7 +8691,7 @@ class P123Client(P123OpenClient):
     @overload
     def offline_task_list(
         self, 
-        payload: dict | int = 1, 
+        payload: dict | int | list[int] | tuple[int] = 1, 
         /, 
         base_url: str | Callable[[], str] = DEFAULT_BASE_URL, 
         *, 
@@ -8497,7 +8701,7 @@ class P123Client(P123OpenClient):
         ...
     def offline_task_list(
         self, 
-        payload: dict | int = 1, 
+        payload: dict | int | list[int] | tuple[int] = 1, 
         /, 
         base_url: str | Callable[[], str] = DEFAULT_BASE_URL, 
         *, 
@@ -8514,9 +8718,10 @@ class P123Client(P123OpenClient):
             - status_arr: list[ 0 | 1 | 2 | 3 | 4 ] = [0, 1, 2, 3, 4] 💡 状态列表：0:进行中 1:下载失败 2:下载成功 3:重试中
         """
         if isinstance(payload, int):
-            payload = {"current_page": payload, "page_size": 100, "status_arr": [0, 1, 2, 3, 4]}
-        else:
-            payload = {"current_page": 1, "page_size": 100, "status_arr": [0, 1, 2, 3, 4], **payload}
+            payload = {"current_page": payload}
+        elif isinstance(payload, (list, tuple)):
+            payload = { "status_arr": payload}
+        payload = {"current_page": 1, "page_size": 100, "status_arr": [0, 1, 2, 3, 4], **payload}
         return self.request(
             "offline_download/task/list", 
             "POST", 
@@ -10513,4 +10718,3 @@ with temp_globals():
             except KeyError:
                 CLIENT_API_METHODS_MAP[api] = [name]
 
-# TODO: 实现 check_for_relogin 参数，当报错 401，则重新登录（如果用的是 client_id，账号密码 或 refresh_token），调用 client.login()

{p123client-0.0.7.1.1.dist-info → p123client-0.0.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: p123client
-Version: 0.0.7.1.1
+Version: 0.0.7.2
 Summary: Python 123 webdisk client.
 Home-page: https://github.com/ChenyangGao/p123client
 License: MIT

{p123client-0.0.7.1.1.dist-info → p123client-0.0.7.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
 LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
 p123client/__init__.py,sha256=lcTiBpyNHH1HN4f1ueacumxkaahBNOUyvNA172UtSOU,214
-p123client/client.py,sha256=CKSDmL8trU1yfwDL82heSjrX3AoY-gZygWkTk9SsGq8,350147
+p123client/client.py,sha256=GLVJPwLFUhH043q4GXOSD8nqIJHhazYY4gNCUy3Hi_o,357375
 p123client/const.py,sha256=UYfBrgciCz7RJJPqCX6zwWlMoWiaTUwUU8bpFJyh0sM,348
 p123client/exception.py,sha256=Vn2UlJulY63z3cF7bnTjMlZ6og7gCw1pAA-dswFwKpQ,3174
 p123client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 p123client/tool/__init__.py,sha256=hnOwkk1CKk1CLGlhl6hlUl3BWNdqXdy8sWKXAGmOXHE,18812
 p123client/type.py,sha256=T17OzPQrnIG6w_Hzjc8TF_fFMKa-hQMSn1gff8pVcBc,56
-p123client-0.0.7.1.1.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-p123client-0.0.7.1.1.dist-info/METADATA,sha256=VNfTXL5NiNYWPEH4yLM-Fd7s0QgR1K_b869rQM8E3_4,14659
-p123client-0.0.7.1.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-p123client-0.0.7.1.1.dist-info/RECORD,,
+p123client-0.0.7.2.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+p123client-0.0.7.2.dist-info/METADATA,sha256=RwvkD4bZ_ma7fJ7ODAPJg54hOvsC2nYcc765nFObY54,14657
+p123client-0.0.7.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+p123client-0.0.7.2.dist-info/RECORD,,