htx-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{htx_cli-0.1.2/src/htx_cli.egg-info → htx_cli-0.1.4}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: htx-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: htx-cli command-line client for the Disk backend API
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: qiniu<8,>=7.13
 Requires-Dist: rich<14,>=13.9
 Requires-Dist: requests<3,>=2.32
 
@@ -15,6 +16,7 @@ Requires-Dist: requests<3,>=2.32
 - Listing remote Disk directories
 - Uploading a local file into a remote Disk directory
 - Uploading a local directory recursively while recreating its folder structure remotely
+- Resumable multipart uploads with real remote-part progress
 
 ## Install
 
@@ -90,6 +92,20 @@ Upload a local directory recursively. The local directory name is created or reu
 htx upload ./albums /Photos
 ```
 
+Only upload selected extensions:
+
+```bash
+htx upload ./albums /Photos --include-ext jpg --include-ext png
+```
+
+Exclude specific extensions:
+
+```bash
+htx upload ./albums /Photos --exclude-ext tmp --exclude-ext log
+```
+
+You can combine both flags. `--exclude-ext` takes precedence when both match the same file.
+
 Create a directory under the remote root:
 
 ```bash
@@ -160,3 +176,9 @@ The CLI stores the backend JWT token and the last fetched user payload in:
 ```
 
 Use `--config` to point to a different state file.
+
+Multipart upload resume records are stored under:
+
+```text
+~/.config/htx-cli/upload-records/
+```

htx_cli-0.1.2/PKG-INFO → htx_cli-0.1.4/README.md

@@ -1,12 +1,3 @@
-Metadata-Version: 2.4
-Name: htx-cli
-Version: 0.1.2
-Summary: htx-cli command-line client for the Disk backend API
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: rich<14,>=13.9
-Requires-Dist: requests<3,>=2.32
-
 # htx-cli
 
 `htx-cli` is a command-line client for the Disk backend API. It supports:
@@ -15,6 +6,7 @@ Requires-Dist: requests<3,>=2.32
 - Listing remote Disk directories
 - Uploading a local file into a remote Disk directory
 - Uploading a local directory recursively while recreating its folder structure remotely
+- Resumable multipart uploads with real remote-part progress
 
 ## Install
 
@@ -90,6 +82,20 @@ Upload a local directory recursively. The local directory name is created or reu
 htx upload ./albums /Photos
 ```
 
+Only upload selected extensions:
+
+```bash
+htx upload ./albums /Photos --include-ext jpg --include-ext png
+```
+
+Exclude specific extensions:
+
+```bash
+htx upload ./albums /Photos --exclude-ext tmp --exclude-ext log
+```
+
+You can combine both flags. `--exclude-ext` takes precedence when both match the same file.
+
 Create a directory under the remote root:
 
 ```bash
@@ -160,3 +166,9 @@ The CLI stores the backend JWT token and the last fetched user payload in:
 ```
 
 Use `--config` to point to a different state file.
+
+Multipart upload resume records are stored under:
+
+```text
+~/.config/htx-cli/upload-records/
+```

{htx_cli-0.1.2 → htx_cli-0.1.4}/pyproject.toml

@@ -4,11 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "htx-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "htx-cli command-line client for the Disk backend API"
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [
+  "qiniu>=7.13,<8",
   "rich>=13.9,<14",
   "requests>=2.32,<3",
 ]

{htx_cli-0.1.2 → htx_cli-0.1.4}/src/disk_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{htx_cli-0.1.2 → htx_cli-0.1.4}/src/disk_cli/api.py

@@ -7,6 +7,8 @@ from typing import Any, Callable, Dict, Optional
 from urllib.parse import urljoin
 
 import requests
+from qiniu import Auth
+from qiniu.services.storage.uploader import ResumeUploaderV2, UploadProgressRecorder
 
 from .config import DiskSettings
 
@@ -33,41 +35,11 @@ class UploadToken:
 
 
 ProgressCallback = Callable[[int, Optional[int]], None]
+UploadPhaseCallback = Callable[[str], None]
 MAX_RETRIES = 5
 RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}
 
 
-class UploadMonitor:
-    def __init__(self, local_path: Path, callback: Optional[ProgressCallback] = None) -> None:
-        self.local_path = local_path
-        self.callback = callback
-        self.handle = local_path.open("rb")
-        self.total = local_path.stat().st_size
-        self.transferred = 0
-        if self.callback:
-            self.callback(0, self.total)
-
-    def read(self, size: int = -1) -> bytes:
-        chunk = self.handle.read(size)
-        if chunk:
-            self.transferred += len(chunk)
-            if self.callback:
-                self.callback(self.transferred, self.total)
-        return chunk
-
-    def close(self) -> None:
-        self.handle.close()
-
-    def __getattr__(self, item: str) -> Any:
-        return getattr(self.handle, item)
-
-    def __enter__(self) -> "UploadMonitor":
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        self.close()
-
-
 class DiskClient:
     def __init__(self, settings: DiskSettings, *, timeout: float = 30.0) -> None:
         self.settings = settings
@@ -88,13 +60,17 @@ class DiskClient:
                 f"Server returned a non-JSON response (HTTP {response.status_code})."
             ) from exc
 
+        return self._unwrap_payload(payload, status_code=response.status_code)
+
+    @staticmethod
+    def _unwrap_payload(payload: Any, *, status_code: Optional[int] = None) -> Any:
         if not isinstance(payload, dict) or "code" not in payload:
             return payload
 
         if payload.get("code") != 0:
             raise DiskAPIError(
                 payload.get("msg") or "The Disk API request failed.",
-                status_code=response.status_code,
+                status_code=status_code,
                 identifier=payload.get("identifier"),
                 debug_msg=payload.get("debug_msg"),
             )
@@ -336,18 +312,71 @@ class DiskClient:
         local_path: Path,
         *,
         progress_callback: Optional[ProgressCallback] = None,
+        phase_callback: Optional[UploadPhaseCallback] = None,
     ) -> Dict[str, Any]:
         last_error: Optional[Exception] = None
+        file_size = local_path.stat().st_size
+        bucket_name = Auth.get_bucket_name(upload.upload_token)
+        if not bucket_name:
+            raise DiskAPIError("Upload token does not contain a valid bucket name.")
+
         for attempt in range(1, MAX_RETRIES + 1):
             try:
-                with UploadMonitor(local_path, progress_callback) as handle:
-                    body = self._request_once(
-                        "POST",
-                        self.settings.qiniu_upload_url,
-                        include_auth=False,
-                        data={"key": upload.key, "token": upload.upload_token},
-                        files={"file": (local_path.name, handle)},
+                self.settings.upload_record_dir.mkdir(parents=True, exist_ok=True)
+                recorder = UploadProgressRecorder(str(self.settings.upload_record_dir))
+                uploader = ResumeUploaderV2(
+                    bucket_name,
+                    part_size=4 * 1024 * 1024,
+                    progress_handler=progress_callback,
+                    upload_progress_recorder=recorder,
+                )
+
+                context, resp = uploader.initial_parts(
+                    up_token=upload.upload_token,
+                    key=upload.key,
+                    file_path=str(local_path),
+                    file_name=local_path.name,
+                )
+                if resp is not None and not resp.ok():
+                    raise DiskAPIError(
+                        f"Failed to initialize multipart upload: {resp.error}",
+                        status_code=resp.status_code,
+                        debug_msg=resp.text_body,
+                    )
+
+                with local_path.open("rb") as file_handle:
+                    _, resp = uploader.upload_parts(
+                        up_token=upload.upload_token,
+                        data=file_handle,
+                        data_size=file_size,
+                        context=context,
+                        key=upload.key,
+                        file_name=local_path.name,
+                    )
+                if resp is not None and not resp.ok():
+                    raise DiskAPIError(
+                        f"Failed while uploading file parts: {resp.error}",
+                        status_code=resp.status_code,
+                        debug_msg=resp.text_body,
+                    )
+
+                if phase_callback:
+                    phase_callback("finalizing")
+
+                body, resp = uploader.complete_parts(
+                    up_token=upload.upload_token,
+                    data_size=file_size,
+                    context=context,
+                    key=upload.key,
+                    file_name=local_path.name,
+                )
+                if resp is not None and not resp.ok():
+                    raise DiskAPIError(
+                        f"Failed to finalize multipart upload: {resp.error}",
+                        status_code=resp.status_code,
+                        debug_msg=resp.text_body,
                     )
+                body = self._unwrap_payload(body, status_code=resp.status_code if resp is not None else None)
                 if not isinstance(body, dict):
                     raise DiskAPIError("Upload endpoint returned an unexpected payload.")
                 return body

{htx_cli-0.1.2 → htx_cli-0.1.4}/src/disk_cli/cli.py

@@ -4,6 +4,7 @@ import argparse
 import datetime as dt
 import json
 import os
+import subprocess
 import sys
 import webbrowser
 from dataclasses import dataclass
@@ -94,6 +95,20 @@ class CommandContext:
         return root_res
 
 
+@dataclass(frozen=True)
+class UploadFilters:
+    include_exts: Optional[set[str]] = None
+    exclude_exts: Optional[set[str]] = None
+
+    def matches(self, local_path: Path) -> bool:
+        extension = normalize_extension(local_path.suffix)
+        if self.include_exts is not None and extension not in self.include_exts:
+            return False
+        if self.exclude_exts is not None and extension in self.exclude_exts:
+            return False
+        return True
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="htx",
@@ -121,6 +136,11 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Do not try to open the authorization URL in a browser.",
     )
+    login.add_argument(
+        "--browser",
+        action="store_true",
+        help="Force the browser-based web OAuth flow instead of using `qt app oauth`.",
+    )
 
     whoami = subparsers.add_parser("whoami", help="Show the authenticated Disk user.")
     whoami.add_argument("--json", action="store_true", help="Print the raw API payload.")
@@ -143,6 +163,20 @@ def build_parser() -> argparse.ArgumentParser:
         default="/",
         help="Target remote directory path, @<res_str_id>, or id:<res_str_id>.",
     )
+    upload.add_argument(
+        "--include-ext",
+        action="append",
+        default=[],
+        metavar="EXT",
+        help="Only upload files with this extension. Repeatable; accepts `jpg` or `.jpg`.",
+    )
+    upload.add_argument(
+        "--exclude-ext",
+        action="append",
+        default=[],
+        metavar="EXT",
+        help="Skip files with this extension. Repeatable; accepts `log` or `.log`.",
+    )
 
     mkdir = subparsers.add_parser("mkdir", help="Create a remote directory.")
     mkdir.add_argument("name", help="Directory name to create.")
@@ -217,6 +251,26 @@ def format_resource_ref(res_str_id: str) -> str:
     return f"@{res_str_id}"
 
 
+def normalize_extension(value: str) -> str:
+    normalized = value.strip().lower()
+    if not normalized:
+        raise CLIUsageError("Extension values cannot be empty.")
+    if normalized == ".":
+        raise CLIUsageError("Extension values must include at least one character.")
+    if not normalized.startswith("."):
+        normalized = f".{normalized}"
+    return normalized
+
+
+def build_upload_filters(include_exts: List[str], exclude_exts: List[str]) -> UploadFilters:
+    normalized_include = {normalize_extension(ext) for ext in include_exts}
+    normalized_exclude = {normalize_extension(ext) for ext in exclude_exts}
+    return UploadFilters(
+        include_exts=normalized_include or None,
+        exclude_exts=normalized_exclude or None,
+    )
+
+
 def format_timestamp(timestamp: Any) -> str:
     if timestamp in (None, ""):
         return "-"
@@ -385,30 +439,72 @@ def upload_file_to_remote(ctx: CommandContext, local_path: Path, parent_id: str)
         def on_progress(transferred: int, callback_total: Optional[int]) -> None:
             progress.update(task_id, completed=transferred, total=callback_total or total)
 
-        uploaded = ctx.client.upload_file(upload_token, local_path, progress_callback=on_progress)
+        def on_phase(phase: str) -> None:
+            if phase == "finalizing":
+                progress.update(task_id, completed=total, total=total, description=f"Finalizing {local_path.name}")
+
+        uploaded = ctx.client.upload_file(
+            upload_token,
+            local_path,
+            progress_callback=on_progress,
+            phase_callback=on_phase,
+        )
     print_success(
         f"uploaded {local_path.name} -> {uploaded['rname']} ({format_resource_ref(uploaded['res_str_id'])})"
     )
     return uploaded
 
 
-def upload_directory_to_remote(ctx: CommandContext, local_dir: Path, parent_id: str) -> None:
+def ensure_remote_directory_path(
+    ctx: CommandContext,
+    remote_folder_map: Dict[Path, str],
+    root_remote_id: str,
+    relative_parent: Path,
+) -> str:
+    if relative_parent in remote_folder_map:
+        return remote_folder_map[relative_parent]
+
+    parts = relative_parent.parts
+    current_relative = Path(".")
+    current_remote_id = root_remote_id
+    for part in parts:
+        current_relative = current_relative / part
+        existing = remote_folder_map.get(current_relative)
+        if existing is not None:
+            current_remote_id = existing
+            continue
+        current_remote_id = ensure_remote_folder(ctx, current_remote_id, part)
+        remote_folder_map[current_relative] = current_remote_id
+    return current_remote_id
+
+
+def upload_directory_to_remote(
+    ctx: CommandContext,
+    local_dir: Path,
+    parent_id: str,
+    upload_filters: UploadFilters,
+) -> Tuple[int, int]:
     root_remote_id = ensure_remote_folder(ctx, parent_id, local_dir.name)
     remote_folder_map: Dict[Path, str] = {Path("."): root_remote_id}
+    uploaded_count = 0
+    skipped_count = 0
 
     for current_root, dirnames, filenames in os.walk(local_dir):
         dirnames.sort()
         filenames.sort()
         current_root_path = Path(current_root)
         relative_root = current_root_path.relative_to(local_dir)
-        remote_parent_id = remote_folder_map[relative_root]
-
-        for dirname in dirnames:
-            child_relative = relative_root / dirname
-            remote_folder_map[child_relative] = ensure_remote_folder(ctx, remote_parent_id, dirname)
 
         for filename in filenames:
-            upload_file_to_remote(ctx, current_root_path / filename, remote_parent_id)
+            local_file = current_root_path / filename
+            if not upload_filters.matches(local_file):
+                skipped_count += 1
+                continue
+            remote_parent_id = ensure_remote_directory_path(ctx, remote_folder_map, root_remote_id, relative_root)
+            upload_file_to_remote(ctx, local_file, remote_parent_id)
+            uploaded_count += 1
+
+    return uploaded_count, skipped_count
 
 
 def resolve_download_destination(resource: Dict[str, Any], local_path: Optional[Path]) -> Path:
@@ -544,6 +640,13 @@ def print_user_summary(user: Dict[str, Any]) -> None:
 
 
 def handle_login(ctx: CommandContext, args: argparse.Namespace) -> int:
+    if not args.code and not args.browser:
+        qt_command = ctx.settings.resolve_qt_command()
+        if qt_command:
+            qt_code = request_qt_oauth_code(ctx, qt_command)
+            if qt_code:
+                args.code = qt_code
+
     auth_url = ctx.settings.oauth_authorize_url()
     if args.print_url:
         console.print(auth_url)
@@ -578,6 +681,41 @@ def handle_login(ctx: CommandContext, args: argparse.Namespace) -> int:
     return 0
 
 
+def request_qt_oauth_code(ctx: CommandContext, qt_command: str) -> Optional[str]:
+    try:
+        result = subprocess.run(
+            [
+                qt_command,
+                "app",
+                "oauth",
+                "--app-id",
+                ctx.settings.sso_app_id,
+                "--client-name",
+                "htx-cli",
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError:
+        return None
+    except subprocess.CalledProcessError as exc:
+        stderr = exc.stderr.strip() if exc.stderr else ""
+        stdout = exc.stdout.strip() if exc.stdout else ""
+        message = stderr or stdout
+        if message:
+            print_note(f"`qt app oauth` unavailable, falling back to browser login: {message}")
+        return None
+
+    code = result.stdout.strip()
+    if not code:
+        print_note("`qt app oauth` returned an empty authorization code, falling back to browser login.")
+        return None
+
+    print_note("received OAuth code from `qt app oauth`; exchanging directly with Disk backend")
+    return code
+
+
 def handle_whoami(ctx: CommandContext, _: argparse.Namespace) -> int:
     with console.status("[bold cyan]Fetching user profile[/bold cyan]", spinner="dots"):
         user = ctx.sync_user()
@@ -609,6 +747,7 @@ def handle_upload(ctx: CommandContext, args: argparse.Namespace) -> int:
     local_path = args.local_path.expanduser().resolve()
     if not local_path.exists():
         raise CLIUsageError(f"Local path does not exist: {local_path}")
+    upload_filters = build_upload_filters(args.include_ext, args.exclude_ext)
 
     with console.status("[bold cyan]Resolving target directory[/bold cyan]", spinner="dots"):
         target_resource = resolve_remote_reference(ctx, args.remote_path)
@@ -616,10 +755,14 @@ def handle_upload(ctx: CommandContext, args: argparse.Namespace) -> int:
     target_id = target_resource["info"]["res_str_id"]
 
     if local_path.is_file():
+        if not upload_filters.matches(local_path):
+            print_note(f"skipped {local_path.name} because it does not match the upload extension filters")
+            return 0
         upload_file_to_remote(ctx, local_path, target_id)
         return 0
 
-    upload_directory_to_remote(ctx, local_path, target_id)
+    uploaded_count, skipped_count = upload_directory_to_remote(ctx, local_path, target_id, upload_filters)
+    print_note(f"directory upload summary: {uploaded_count} uploaded, {skipped_count} skipped")
     return 0
 
 

{htx_cli-0.1.2 → htx_cli-0.1.4}/src/disk_cli/config.py

@@ -4,15 +4,17 @@ import json
 import os
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
+from shutil import which
 from typing import Any, Dict, Optional
 from urllib.parse import urlencode
 
-DEFAULT_APP_ID = "R41nXZEwpfl6tw6KYyoEZ4FYST4BXPlF"
+DEFAULT_APP_ID = "R41nXZEw"
 DEFAULT_BACKEND_URL = "https://disk.6-79.cn"
-DEFAULT_QINIU_UPLOAD_URL = "https://up.qiniup.com"
-DEFAULT_SSO_URL = "https://sso.6-79.cn/oauth/"
+DEFAULT_SSO_URL = "https://qt.6-79.cn/oauth/"
 DEFAULT_STATE_PATH = Path.home() / ".config" / "htx-cli" / "state.json"
+DEFAULT_UPLOAD_RECORD_DIR = Path.home() / ".config" / "htx-cli" / "upload-records"
 LEGACY_STATE_PATH = Path.home() / ".config" / "disk-cli" / "state.json"
+DEFAULT_QT_COMMAND = "qt"
 
 
 @dataclass
@@ -20,10 +22,15 @@ class DiskSettings:
     backend_url: str = field(default_factory=lambda: os.getenv("DISK_BACKEND_URL", DEFAULT_BACKEND_URL))
     sso_url: str = field(default_factory=lambda: os.getenv("DISK_SSO_URL", DEFAULT_SSO_URL))
     sso_app_id: str = field(default_factory=lambda: os.getenv("DISK_SSO_APP_ID", DEFAULT_APP_ID))
-    qiniu_upload_url: str = field(default_factory=lambda: os.getenv("DISK_QINIU_UPLOAD_URL", DEFAULT_QINIU_UPLOAD_URL))
+    qt_command: str = field(default_factory=lambda: os.getenv("DISK_QT_COMMAND", DEFAULT_QT_COMMAND))
     token: Optional[str] = None
     user: Optional[Dict[str, Any]] = None
     state_path: Path = DEFAULT_STATE_PATH
+    upload_record_dir: Path = field(
+        default_factory=lambda: Path(
+            os.getenv("DISK_UPLOAD_RECORD_DIR", str(DEFAULT_UPLOAD_RECORD_DIR))
+        ).expanduser()
+    )
 
     @classmethod
     def load(cls, state_path: Optional[Path] = None) -> "DiskSettings":
@@ -38,19 +45,23 @@ class DiskSettings:
             backend_url=data.get("backend_url", os.getenv("DISK_BACKEND_URL", DEFAULT_BACKEND_URL)),
             sso_url=data.get("sso_url", os.getenv("DISK_SSO_URL", DEFAULT_SSO_URL)),
             sso_app_id=data.get("sso_app_id", os.getenv("DISK_SSO_APP_ID", DEFAULT_APP_ID)),
-            qiniu_upload_url=data.get(
-                "qiniu_upload_url",
-                os.getenv("DISK_QINIU_UPLOAD_URL", DEFAULT_QINIU_UPLOAD_URL),
-            ),
+            qt_command=data.get("qt_command", os.getenv("DISK_QT_COMMAND", DEFAULT_QT_COMMAND)),
             token=data.get("token"),
             user=data.get("user"),
             state_path=resolved_path,
+            upload_record_dir=Path(
+                data.get(
+                    "upload_record_dir",
+                    os.getenv("DISK_UPLOAD_RECORD_DIR", str(DEFAULT_UPLOAD_RECORD_DIR)),
+                )
+            ).expanduser(),
         )
 
     def save(self) -> None:
         self.state_path.parent.mkdir(parents=True, exist_ok=True)
         payload = asdict(self)
         payload["state_path"] = str(self.state_path)
+        payload["upload_record_dir"] = str(self.upload_record_dir)
         self.state_path.write_text(
             json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
             encoding="utf-8",
@@ -65,3 +76,6 @@ class DiskSettings:
         if state:
             params["state"] = state
         return f"{self.sso_url}?{urlencode(params)}"
+
+    def resolve_qt_command(self) -> Optional[str]:
+        return which(self.qt_command) or (self.qt_command if Path(self.qt_command).exists() else None)

htx_cli-0.1.2/README.md → htx_cli-0.1.4/src/htx_cli.egg-info/PKG-INFO

@@ -1,3 +1,13 @@
+Metadata-Version: 2.4
+Name: htx-cli
+Version: 0.1.4
+Summary: htx-cli command-line client for the Disk backend API
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: qiniu<8,>=7.13
+Requires-Dist: rich<14,>=13.9
+Requires-Dist: requests<3,>=2.32
+
 # htx-cli
 
 `htx-cli` is a command-line client for the Disk backend API. It supports:
@@ -6,6 +16,7 @@
 - Listing remote Disk directories
 - Uploading a local file into a remote Disk directory
 - Uploading a local directory recursively while recreating its folder structure remotely
+- Resumable multipart uploads with real remote-part progress
 
 ## Install
 
@@ -81,6 +92,20 @@ Upload a local directory recursively. The local directory name is created or reu
 htx upload ./albums /Photos
 ```
 
+Only upload selected extensions:
+
+```bash
+htx upload ./albums /Photos --include-ext jpg --include-ext png
+```
+
+Exclude specific extensions:
+
+```bash
+htx upload ./albums /Photos --exclude-ext tmp --exclude-ext log
+```
+
+You can combine both flags. `--exclude-ext` takes precedence when both match the same file.
+
 Create a directory under the remote root:
 
 ```bash
@@ -151,3 +176,9 @@ The CLI stores the backend JWT token and the last fetched user payload in:
 ```
 
 Use `--config` to point to a different state file.
+
+Multipart upload resume records are stored under:
+
+```text
+~/.config/htx-cli/upload-records/
+```

{htx_cli-0.1.2 → htx_cli-0.1.4}/src/htx_cli.egg-info/requires.txt

@@ -1,2 +1,3 @@
+qiniu<8,>=7.13
 rich<14,>=13.9
 requests<3,>=2.32