nonebot-plugin-osubot 6.22.3__py3-none-any.whl → 6.26.4__py3-none-any.whl

nonebot_plugin_osubot/file.py

@@ -1,10 +1,15 @@
+import base64
+import hashlib
 import re
+import urllib
 import random
 import asyncio
+import uuid
 from pathlib import Path
 from typing import Union, Optional
 from io import BytesIO, TextIOWrapper
 
+from nonebot.adapters.onebot.v11 import Bot
 from nonebot.log import logger
 
 from .schema import Badge
@@ -18,45 +23,67 @@ user_cache_path = Path() / "data" / "osu" / "user"
 badge_cache_path = Path() / "data" / "osu" / "badge"
 team_cache_path = Path() / "data" / "osu" / "team"
 api_ls = [
-    "https://api.chimu.moe/v1/download/",
     "https://osu.direct/api/d/",
     "https://txy1.sayobot.cn/beatmaps/download/novideo/",
     "https://catboy.best/d/",
 ]
 semaphore = asyncio.Semaphore(5)
 
-if not map_path.exists():
-    map_path.mkdir(parents=True, exist_ok=True)
-if not user_cache_path.exists():
-    user_cache_path.mkdir(parents=True, exist_ok=True)
-if not badge_cache_path.exists():
-    badge_cache_path.mkdir(parents=True, exist_ok=True)
-if not team_cache_path.exists():
-    team_cache_path.mkdir(parents=True, exist_ok=True)
+map_path.mkdir(parents=True, exist_ok=True)
+user_cache_path.mkdir(parents=True, exist_ok=True)
+badge_cache_path.mkdir(parents=True, exist_ok=True)
+team_cache_path.mkdir(parents=True, exist_ok=True)
+
+
+def extract_filename_from_headers(headers: dict[str, str]) -> Optional[str]:
+    """
+    从 Content-Disposition 响应头中提取文件名，并处理 URL 编码。
+
+    Args:
+        headers: 响应头字典。
+
+    Returns:
+        提取到的文件名字符串，如果失败则返回 None。
+    """
+    disposition = headers.get("content-disposition", "")
+    if not disposition:
+        return None
+
+    match_utf8 = re.search(r"filename\*=(?:utf-8''|)(.+?)(?:;|$)", disposition, re.IGNORECASE)
+
+    if match_utf8:
+        # 提取匹配到的文件名部分
+        encoded_filename = match_utf8.group(1).strip('"').strip()
+
+        try:
+            return urllib.parse.unquote(encoded_filename)
+        except Exception as e:
+            # 如果解码失败，记录错误并尝试使用原始编码
+            print(f"警告: 解码 filename* 失败: {e}. 使用原始编码.")
+            return encoded_filename
+
+    match_normal = re.search(r"filename=\"?(.+?)\"?(\s|;|$)", disposition, re.IGNORECASE)
+    if match_normal:
+        # 普通 filename 字段也可能包含 URL 编码，进行解码
+        filename = match_normal.group(1).strip('"').strip()
+        try:
+            return urllib.parse.unquote(filename)
+        except Exception:
+            return filename
+
+    return None
 
 
 async def download_map(setid: int) -> Optional[Path]:
-    urls = [i + str(setid) for i in api_ls]
+    urls = [f"{base_url}{setid}" for base_url in api_ls]
     logger.info(f"开始下载地图: <{setid}>")
     req = await get_first_response(urls)
-    filename = f"{setid}.osz"
+    filename = extract_filename_from_headers(req.headers)
     filepath = map_path.parent / filename
-    with open(filepath, "wb") as f:
-        f.write(req.read())
+    with open(filepath.absolute(), "wb") as f:
+        f.write(req.content)
     logger.info(f"地图: <{setid}> 下载完毕")
-    return filepath
-
-
-async def download_tmp_osu(map_id):
-    url = f"https://osu.ppy.sh/osu/{map_id}"
-    logger.info(f"开始下载谱面: <{map_id}>")
-    req = await safe_async_get(url)
-    filename = f"{map_id}.osu"
-    filepath = map_path / filename
-    chunk = req.read()
-    with open(filepath, "wb") as f:
-        f.write(chunk)
-    return filepath
+    return filepath.absolute()
 
 
 @auto_retry
@@ -71,8 +98,9 @@ async def download_osu(set_id, map_id):
         if req := await get_first_response(url):
             filename = f"{map_id}.osu"
             filepath = map_path / str(set_id) / filename
+            filepath.parent.mkdir(parents=True, exist_ok=True)
             with open(filepath, "wb") as f:
-                f.write(req)
+                f.write(req.content)
             return filepath
         else:
             raise Exception("下载出错，请稍后再试")
@@ -94,8 +122,7 @@ async def get_projectimg(url: str) -> BytesIO:
 
 async def get_pfm_img(url: str, cache_path: Path) -> BytesIO:
     cache_dir = cache_path.parent
-    if not cache_dir.exists():
-        cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_dir.mkdir(parents=True, exist_ok=True)
     if cache_path.exists():
         with cache_path.open("rb") as f:
             return BytesIO(f.read())
@@ -132,7 +159,133 @@ async def make_badge_cache_file(badge: Badge):
 # 保存个人信息界面背景
 async def save_info_pic(user: str, byt: bytes):
     path = user_cache_path / user
-    if not path.exists():
-        path.mkdir()
+    path.mkdir(parents=True, exist_ok=True)
     with open(path / "info.png", "wb") as f:
         f.write(BytesIO(byt).getvalue())
+
+
+def calculate_file_chunks(file_path: str, chunk_size: int = 1024 * 64) -> tuple[list[bytes], str, int]:
+    """
+    计算文件分片和 SHA256
+
+    Args:
+        file_path: 文件路径
+        chunk_size: 分片大小（默认64KB）
+
+    Returns:
+        (chunks, sha256_hash, total_size)
+    """
+    chunks = []
+    hasher = hashlib.sha256()
+    total_size = 0
+
+    with open(file_path, "rb") as f:
+        while True:
+            chunk = f.read(chunk_size)
+            if not chunk:
+                break
+            chunks.append(chunk)
+            hasher.update(chunk)
+            total_size += len(chunk)
+
+    sha256_hash = hasher.hexdigest()
+
+    return chunks, sha256_hash, total_size
+
+
+MAX_CONCURRENT_UPLOADS = 20
+
+
+async def _upload_chunk(
+    bot: "Bot",
+    stream_id: str,
+    chunk_data: bytes,
+    chunk_index: int,
+    total_chunks: int,
+    total_size: int,
+    sha256_hash: str,
+    filename: str,
+    semaphore: asyncio.Semaphore,
+) -> None:
+    """内部函数，用于异步上传单个文件分片"""
+    async with semaphore:
+        # 将分片数据编码为 base64
+        chunk_base64 = base64.b64encode(chunk_data).decode("utf-8")
+
+        # 构建参数
+        params = {
+            "stream_id": stream_id,
+            "chunk_data": chunk_base64,
+            "chunk_index": chunk_index,
+            "total_chunks": total_chunks,
+            "file_size": total_size,
+            "expected_sha256": sha256_hash,
+            "filename": filename,
+            "file_retention": 30 * 1000,
+        }
+
+        # 发送分片
+        response = await bot.call_api("upload_file_stream", **params)
+
+        logger.info(
+            f"分片 {chunk_index + 1}/{total_chunks} 上传成功 "
+            f"(接收: {response.get('received_chunks', 0)}/{response.get('total_chunks', 0)})"
+        )
+
+
+async def upload_file_stream_batch(bot: Bot, file_path: Path, chunk_size: int = 1024 * 64) -> str:
+    """
+    一次性批量上传文件流
+
+    Args:
+        bot: Bot 实例
+        file_path: 要上传的文件路径
+        chunk_size: 分片大小
+
+    Returns:
+        上传完成后的文件路径
+    """
+    if not file_path.exists():
+        raise FileNotFoundError(f"文件不存在: {file_path}")
+
+    # 分析文件
+    chunks, sha256_hash, total_size = calculate_file_chunks(str(file_path), chunk_size)
+    stream_id = str(uuid.uuid4())
+
+    logger.info(f"\n开始上传文件: {file_path.name}")
+    logger.info(f"流ID: {stream_id}")
+
+    # 一次性发送所有分片
+    total_chunks = len(chunks)
+    # 创建信号量，限制最大并发数
+    semaphore = asyncio.Semaphore(MAX_CONCURRENT_UPLOADS)
+
+    # 创建所有分片上传任务
+    upload_tasks = []
+    for chunk_index, chunk_data in enumerate(chunks):
+        task = _upload_chunk(
+            bot, stream_id, chunk_data, chunk_index, total_chunks, total_size, sha256_hash, file_path.name, semaphore
+        )
+        upload_tasks.append(task)
+
+    try:
+        await asyncio.gather(*upload_tasks)
+    except Exception as e:
+        logger.error(f"\n文件分片上传过程中发生错误: {e}")
+        # 这里可以选择执行清理逻辑，如通知服务器取消上传
+        raise e
+
+    # 发送完成信号
+    logger.info("\n所有分片发送完成，请求文件合并...")
+    complete_params = {"stream_id": stream_id, "is_complete": True}
+
+    response = await bot.call_api("upload_file_stream", **complete_params)
+
+    if response.get("status") == "file_complete":
+        logger.info("✅ 文件上传成功!")
+        logger.info(f"  - 文件路径: {response.get('file_path')}")
+        logger.info(f"  - 文件大小: {response.get('file_size')} 字节")
+        logger.info(f"  - SHA256: {response.get('sha256')}")
+        return response.get("file_path")
+    else:
+        raise Exception(f"文件状态异常: {response}")

nonebot_plugin_osubot/mania/__init__.py

@@ -25,7 +25,7 @@ from reamber.algorithms.playField.parts import (
 )
 
 from ..file import download_map
-from ..schema import SayoBeatmap
+from ..schema.beatmapsets import BeatmapSets
 
 osu_path = Path() / "data" / "osu"
 if not osu_path.exists():
@@ -39,7 +39,7 @@ class Options:
     od: Optional[float]
     set: Optional[int]
     map: Optional[int] = None
-    sayo_info: Optional[SayoBeatmap] = None
+    beatmapsets: Optional[BeatmapSets] = None
     nsv: bool = False
     nln: bool = False
     fln: bool = False
@@ -89,15 +89,14 @@ async def convert_mania_map(options: Options) -> Optional[Path]:
     with ZipFile(osz_file.absolute()) as my_zip:
         my_zip.extractall(path)
     os.remove(osz_file)
-    if options.sayo_info:
-        for i in options.sayo_info.data.bid_data:
-            if i.bid == options.map:
-                audio_file_name = i.audio
-                audio_name = audio_file_name[:-4]
-                audio_type = audio_file_name[-4:]
+    if options.beatmapsets:
+        for file in path.rglob("*.osu"):
+            osu = OsuMap.read_file(str(file.absolute()))
+            if osu.beatmap_id == options.map:
+                audio_file_name = osu.audio_file_name
+                audio_name = osu.audio_file_name[:-4]
+                audio_type = osu.audio_file_name[-4:]
                 break
-        else:
-            raise Exception("小夜api有问题啊")
     if options.rate:
         if options.rate > 10:
             options.rate = 10

nonebot_plugin_osubot/matcher/__init__.py

@@ -5,6 +5,7 @@ from .getbg import getbg
 from .match import match
 from .medal import medal
 from .score import score
+from .osudl import osudl
 from .pr import pr, recent
 from .rating import rating
 from .history import history
@@ -57,4 +58,5 @@ __all__ = [
     "match",
     "rating",
     "group_pp_rank",
+    "osudl",
 ]

nonebot_plugin_osubot/matcher/bp_analyze.py

@@ -34,12 +34,16 @@ async def _(event: Event, state: T_State):
     uid = state["user"]
     lazer_mode = "lazer模式下" if state["is_lazer"] else "stable模式下"
     try:
-        score_ls = await get_user_scores(uid, NGM[state["mode"]], "best", legacy_only=not state["is_lazer"])
+        score_ls = await get_user_scores(
+            uid, NGM[state["mode"]], "best", state["source"], legacy_only=not state["is_lazer"]
+        )
     except NetworkError as e:
         await UniMessage.text(
             f"在查找用户：{state['username']} {NGM[state['mode']]}模式 {lazer_mode}时 {str(e)}"
         ).finish(reply_to=True)
     for score in score_ls:
+        if not state["is_lazer"] or state["source"] == "ppysb":
+            score.mods = [mod for mod in score.mods if mod.acronym != "CL"]
         for mod in score.mods:
             if mod.acronym == "DT" or mod.acronym == "NC":
                 score.beatmap.total_length /= 1.5
@@ -89,14 +93,15 @@ async def _(event: Event, state: T_State):
         pp_data.append({"name": mod, "value": round(pp, 2)})
     mapper_pp = defaultdict(int)
     for num, i in enumerate(score_ls):
-        mapper_pp[i.beatmap.user_id] += i.pp * 0.95**num
-    mapper_pp = sorted(mapper_pp.items(), key=lambda x: x[1], reverse=True)
-    mapper_pp = mapper_pp[:9]
-    users = await get_users([i[0] for i in mapper_pp])
-    user_dic = {i.id: i.username for i in users}
-    mapper_pp_data = []
-    for mapper, pp in mapper_pp:
-        mapper_pp_data.append({"name": user_dic.get(mapper, ""), "value": round(pp, 2)})
+        key = i.beatmap.creator if state["source"] == "ppysb" else i.beatmap.user_id
+        mapper_pp[key] += i.pp * 0.95**num
+    mapper_pp = sorted(mapper_pp.items(), key=lambda x: x[1], reverse=True)[:9]
+    if state["source"] == "ppysb":
+        mapper_pp_data = [{"name": mapper, "value": round(pp, 2)} for mapper, pp in mapper_pp]
+    else:
+        users = await get_users([i[0] for i in mapper_pp])
+        user_dic = {i.id: i.username for i in users}
+        mapper_pp_data = [{"name": user_dic.get(mapper, ""), "value": round(pp, 2)} for mapper, pp in mapper_pp]
     if len(mapper_pp_data) > 20:
         mapper_pp_data = mapper_pp_data[:20]
     name = f"{state['username']} {NGM[state['mode']]} 模式 "