nonebot-plugin-parser 2.0.3__tar.gz → 2.0.5__tar.gz

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nonebot-plugin-parser
-Version: 2.0.3
+Version: 2.0.5
 Summary: NoneBot2 链接分享解析器自动解析, BV号/链接/小程序/卡片 | B站/抖音/快手/微博/小红书/youtube/tiktok/twitter/acfun
 Keywords: nonebot,nonebot2,video,bilibili,youtube,tiktok,twitter,kuaishou,acfun,weibo,xiaohongshu,nga,douyin
 Author: fllesser
@@ -153,6 +153,7 @@ Windows 参考(原项目推荐): https://www.jianshu.com/p/5015a477de3c
 | parser_disabled_platforms |  否   |            []            |                               全局禁止的解析，示例 parser_disabled_platforms=["bilibili", "douyin"] 表示禁止了哔哩哔哩和抖, 请根据自己需求填写["bilibili", "douyin", "kuaishou", "twitter", "youtube", "acfun", "tiktok", "weibo", "xiaohongshu"]                               |
 |    parser_render_type     |  否   |         "common"         |                                                                                             渲染器类型，可选 "default"(无图片渲染), "common"(PIL 通用图片渲染), "htmlkit"(htmlkit)                                                                                              |
 |     parser_append_url     |  否   |          False           |                                                                                                                           是否在解析结果中附加原始URL                                                                                                                           |
+|    parser_custom_font     |  否   |           None           |                                                                            自定义字体，如未指定则使用内置字体，需将字体文件放置于localstore 生成的插件 data 目录下，parser_custom_font 为字体文件名                                                                             |
 
 ## 🎉 使用
 ### 指令表

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/README.md

@@ -123,6 +123,7 @@ Windows 参考(原项目推荐): https://www.jianshu.com/p/5015a477de3c
 | parser_disabled_platforms |  否   |            []            |                               全局禁止的解析，示例 parser_disabled_platforms=["bilibili", "douyin"] 表示禁止了哔哩哔哩和抖, 请根据自己需求填写["bilibili", "douyin", "kuaishou", "twitter", "youtube", "acfun", "tiktok", "weibo", "xiaohongshu"]                               |
 |    parser_render_type     |  否   |         "common"         |                                                                                             渲染器类型，可选 "default"(无图片渲染), "common"(PIL 通用图片渲染), "htmlkit"(htmlkit)                                                                                              |
 |     parser_append_url     |  否   |          False           |                                                                                                                           是否在解析结果中附加原始URL                                                                                                                           |
+|    parser_custom_font     |  否   |           None           |                                                                            自定义字体，如未指定则使用内置字体，需将字体文件放置于localstore 生成的插件 data 目录下，parser_custom_font 为字体文件名                                                                             |
 
 ## 🎉 使用
 ### 指令表

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parser"
-version = "2.0.3"
+version = "2.0.5"
 description = "NoneBot2 链接分享解析器自动解析, BV号/链接/小程序/卡片 | B站/抖音/快手/微博/小红书/youtube/tiktok/twitter/acfun"
 authors = [{ "name" = "fllesser", "email" = "fllessive@gmail.com" }]
 readme = "README.md"
@@ -185,7 +185,7 @@ build-backend = "uv_build"
 
 
 [tool.bumpversion]
-current_version = "2.0.3"
+current_version = "2.0.5"
 commit = true
 message = "🔖 release: bump vesion from {current_version} to {new_version}"
 tag = true

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/config.py

@@ -51,6 +51,8 @@ class Config(BaseModel):
     """B站视频编码"""
     parser_render_type: RenderType = RenderType.common
     """Renderer 类型"""
+    parser_custom_font: str | None = None
+    """自定义字体"""
 
     @property
     def nickname(self) -> str:
@@ -127,6 +129,11 @@ class Config(BaseModel):
         """是否在解析结果中附加原始URL"""
         return self.parser_append_url
 
+    @property
+    def custom_font(self) -> Path | None:
+        """自定义字体"""
+        return (self.data_dir / self.parser_custom_font) if self.parser_custom_font else None
+
 
 pconfig: Config = get_plugin_config(Config)
 """配置"""

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/parsers/base.py

@@ -2,7 +2,6 @@
 
 from abc import ABC, abstractmethod
 from asyncio import Task
-from collections.abc import Sequence
 from pathlib import Path
 import re
 from typing import ClassVar
@@ -116,7 +115,7 @@ class BaseParser(ABC):
             video_task = url_or_task
         return VideoContent(video_task, cover_task, duration)
 
-    def create_image_contents(self, image_urls: Sequence[str]):
+    def create_image_contents(self, image_urls: list[str]):
         """创建图片内容列表"""
         from ..download import DOWNLOADER
         from .data import ImageContent
@@ -124,7 +123,7 @@ class BaseParser(ABC):
         img_tasks = [DOWNLOADER.download_img(url, ext_headers=self.headers) for url in image_urls]
         return [ImageContent(task) for task in img_tasks]
 
-    def create_dynamic_contents(self, dynamic_urls: Sequence[str]):
+    def create_dynamic_contents(self, dynamic_urls: list[str]):
         """创建动态内容列表"""
         from ..download import DOWNLOADER
         from .data import DynamicContent

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/parsers/bilibili/__init__.py

@@ -66,25 +66,25 @@ class BilibiliParser(BaseParser):
         if "b23.tv" in url or "bili2233.cn" in url:
             url = await self.get_redirect_url(url, self.headers)
 
-        avid, bvid = None, None
-        # 链接中是否包含BV，av号
-        if video_id:
-            if video_id.isdigit():
-                avid = int(video_id)
-            else:
-                bvid = video_id
-        else:
+        if not video_id:
             if _matched := re.search(r"(BV[\dA-Za-z]{10})[^?]*?(?:\?[^#]*?p=(\d{1,3}))?", url):
-                bvid = _matched.group(1)
+                video_id = _matched.group(1)
                 page_num = _matched.group(2)
             elif _matched := re.search(r"av(\d{6,})[^?]*?(?:\?[^#]*?p=(\d{1,3}))?", url):
-                avid = int(_matched.group(1))
+                video_id = _matched.group(1)
                 page_num = _matched.group(2)
             else:
                 return await self.parse_others(url)
 
+        avid, bvid = None, None
         page_num = int(page_num) if page_num and page_num.isdigit() else 1
 
+        # 链接中是否包含BV，av号
+        if video_id.isdigit():
+            avid = int(video_id)
+        else:
+            bvid = video_id
+
         # 解析视频信息
         return await self.parse_video(bvid=bvid, avid=avid, page_num=page_num)
 
@@ -110,6 +110,12 @@ class BilibiliParser(BaseParser):
         # 转换为 msgspec struct
         video_info = msgspec.convert(await video.get_info(), VideoInfo)
 
+        # 获取简介
+        text = f"简介: {video_info.desc}" if video_info.desc else None
+
+        # up
+        author = self.create_author(video_info.owner.name, video_info.owner.face)
+
         # 处理分 p
         page_idx, title, duration, timestamp, cover_url = video_info.extract_info_with_page(page_num)
 
@@ -140,14 +146,15 @@ class BilibiliParser(BaseParser):
                 return await DOWNLOADER.streamd(v_url, file_name=output_path.name, ext_headers=self.headers)
 
         video_task = asyncio.create_task(download_video())
+        video_content = self.create_video_content(video_task, cover_url, duration)
 
         return self.result(
             url=url,
             title=title,
             timestamp=timestamp,
-            text=f"简介：{video_info.desc}",
-            author=self.create_author(video_info.owner.name, video_info.owner.face),
-            contents=[self.create_video_content(video_task, cover_url, duration)],
+            text=text,
+            author=author,
+            contents=[video_content],
             extra={"info": ai_summary},
         )
 

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/parsers/data.py

@@ -5,7 +5,14 @@ from pathlib import Path
 from typing import Any
 
 
-@dataclass
+def repr_path_task(path_task: Path | Task[Path]) -> str:
+    if isinstance(path_task, Path):
+        return f"path={path_task}"
+    else:
+        return f"task={path_task.get_name()}, done={path_task.done()}"
+
+
+@dataclass(repr=False)
 class MediaContent:
     path_task: Path | Task[Path]
 
@@ -15,15 +22,19 @@ class MediaContent:
         self.path_task = await self.path_task
         return self.path_task
 
+    def __repr__(self) -> str:
+        prefix = self.__class__.__name__
+        return f"{prefix}({repr_path_task(self.path_task)})"
 
-@dataclass
+
+@dataclass(repr=False)
 class AudioContent(MediaContent):
     """音频内容"""
 
     duration: float = 0.0
 
 
-@dataclass
+@dataclass(repr=False)
 class VideoContent(MediaContent):
     """视频内容"""
 
@@ -47,21 +58,21 @@ class VideoContent(MediaContent):
         return f"时长: {minutes}:{seconds:02d}"
 
 
-@dataclass
+@dataclass(repr=False)
 class ImageContent(MediaContent):
     """图片内容"""
 
     pass
 
 
-@dataclass
+@dataclass(repr=False)
 class DynamicContent(MediaContent):
     """动态内容 视频格式 后续转 gif"""
 
     gif_path: Path | None = None
 
 
-@dataclass
+@dataclass(repr=False)
 class GraphicsContent(MediaContent):
     """图文内容"""
 
@@ -78,7 +89,7 @@ class Platform:
     """ 平台显示名称 """
 
 
-@dataclass
+@dataclass(repr=False)
 class Author:
     """作者信息"""
 
@@ -97,25 +108,33 @@ class Author:
         self.avatar = await self.avatar
         return self.avatar
 
+    def __repr__(self) -> str:
+        repr = f"Author(name={self.name}"
+        if self.avatar:
+            repr += f", avatar_{repr_path_task(self.avatar)}"
+        if self.description:
+            repr += f", description={self.description}"
+        return repr + ")"
 
-@dataclass
+
+@dataclass(repr=False)
 class ParseResult:
     """完整的解析结果"""
 
     platform: Platform
     """平台信息"""
-    title: str = ""
+    author: Author | None = None
+    """作者信息"""
+    title: str | None = None
     """标题"""
-    text: str = ""
+    text: str | None = None
     """文本内容"""
-    contents: list[MediaContent] = field(default_factory=list)
-    """内容列表，主体以外的内容"""
     timestamp: int | None = None
     """发布时间戳, 秒"""
     url: str | None = None
     """来源链接"""
-    author: Author | None = None
-    """作者信息"""
+    contents: list[MediaContent] = field(default_factory=list)
+    """媒体内容"""
     extra: dict[str, Any] = field(default_factory=dict)
     """额外信息"""
     repost: "ParseResult | None" = None
@@ -123,6 +142,7 @@ class ParseResult:
 
     @property
     def header(self) -> str:
+        """头信息 仅用于 default render"""
         header = self.platform.display_name
         if self.author:
             header += f" @{self.author.name}"
@@ -131,16 +151,16 @@ class ParseResult:
         return header
 
     @property
-    def display_url(self) -> str:
-        return f"链接: {self.url}" if self.url else ""
+    def display_url(self) -> str | None:
+        return f"链接: {self.url}" if self.url else None
 
     @property
-    def repost_display_url(self) -> str:
-        return f"原帖: {self.repost.url}" if self.repost and self.repost.url else ""
+    def repost_display_url(self) -> str | None:
+        return f"原帖: {self.repost.url}" if self.repost and self.repost.url else None
 
     @property
-    def extra_info(self) -> str:
-        return self.extra.get("info", "")
+    def extra_info(self) -> str | None:
+        return self.extra.get("info")
 
     @property
     def video_contents(self) -> list[VideoContent]:
@@ -164,16 +184,29 @@ class ParseResult:
 
     @property
     async def cover_path(self) -> Path | None:
+        """获取封面路径"""
         for cont in self.contents:
             if isinstance(cont, VideoContent):
                 return await cont.get_cover_path()
         return None
 
-    def formart_datetime(self, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
-        return datetime.fromtimestamp(self.timestamp).strftime(fmt) if self.timestamp else ""
-
-    def __str__(self) -> str:
-        return f"title: {self.title}\nplatform: {self.platform}\nauthor: {self.author}\ncontents: {self.contents}"
+    @property
+    def formartted_datetime(self, fmt: str = "%Y-%m-%d %H:%M:%S") -> str | None:
+        """格式化时间戳"""
+        return datetime.fromtimestamp(self.timestamp).strftime(fmt) if self.timestamp is not None else None
+
+    def __repr__(self) -> str:
+        return (
+            f"\nplatform: {self.platform}\n"
+            f"title: {self.title}\n"
+            f"timestamp: {self.timestamp}\n"
+            f"author: {self.author}\n"
+            f"text: {self.text}\n"
+            f"contents: {self.contents}\n"
+            f"url: {self.url}\n"
+            f"extra: {self.extra}\n"
+            f"repost: {self.repost}\n"
+        )
 
 
 from dataclasses import dataclass, field
@@ -181,8 +214,8 @@ from typing import Any, TypedDict
 
 
 class ParseResultKwargs(TypedDict, total=False):
-    title: str
-    text: str
+    title: str | None
+    text: str | None
     contents: list[MediaContent]
     timestamp: int | None
     url: str | None

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/parsers/nga.py

@@ -10,8 +10,7 @@ from bs4 import BeautifulSoup, Tag
 import httpx
 
 from ..exception import ParseException
-from .base import BaseParser
-from .data import Author, ParseResult, Platform
+from .base import BaseParser, Platform
 
 
 class NGAParser(BaseParser):
@@ -45,14 +44,14 @@ class NGAParser(BaseParser):
         return f"https://nga.178.com/read.php?tid={tid}"
 
     @override
-    async def parse(self, matched: re.Match[str]) -> ParseResult:
+    async def parse(self, matched: re.Match[str]):
         """解析 URL 获取内容信息并下载资源
 
         Args:
             matched: 正则表达式匹配对象，由平台对应的模式匹配得到
 
         Returns:
-            ParseResult: 解析结果（已下载资源,包含 Path)
+            ParseResult: 解析结果
 
         Raises:
             ParseException: 解析失败时抛出
@@ -103,7 +102,7 @@ class NGAParser(BaseParser):
         soup = BeautifulSoup(html, "html.parser")
 
         # 提取 title - 从 postsubject0
-        title = ""
+        title = None
         title_tag = soup.find(id="postsubject0")
         if title_tag and isinstance(title_tag, Tag):
             title = title_tag.get_text(strip=True)
@@ -130,7 +129,7 @@ class NGAParser(BaseParser):
                     except (json.JSONDecodeError, KeyError):
                         # JSON 解析失败或数据结构不符合预期,保持 author 为 None
                         pass
-
+        author = self.create_author(author) if author else None
         # 提取时间 - 从第一个帖子的 postdate0
         timestamp = None
         time_tag = soup.find(id="postdate0")
@@ -139,7 +138,7 @@ class NGAParser(BaseParser):
             timestamp = int(time.mktime(time.strptime(timestr, "%Y-%m-%d %H:%M")))
 
         # 提取文本 - postcontent0
-        text = ""
+        text = None
         content_tag = soup.find(id="postcontent0")
         if content_tag and isinstance(content_tag, Tag):
             text = content_tag.get_text("\n", strip=True)
@@ -150,7 +149,7 @@ class NGAParser(BaseParser):
             title=title,
             text=text,
             url=url,
-            author=Author(name=author) if author else None,
+            author=author,
             timestamp=timestamp,
         )
 

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/parsers/youtube.py

@@ -50,7 +50,7 @@ class YouTubeParser(BaseParser):
             video = YTDLP_DOWNLOADER.download_video(url, self.cookies_file)
             contents.append(self.create_video_content(video, video_info.thumbnail, video_info.duration))
         else:
-            contents.append(self.create_image_contents(video_info.thumbnail))
+            contents.extend(self.create_image_contents([video_info.thumbnail]))
 
         return self.result(
             title=video_info.title,
@@ -73,7 +73,7 @@ class YouTubeParser(BaseParser):
         author = await self._fetch_author_info(video_info.channel_id)
 
         contents = []
-        contents.append(self.create_image_contents(video_info.thumbnail))
+        contents.extend(self.create_image_contents([video_info.thumbnail]))
 
         if video_info.duration <= pconfig.duration_maximum:
             audio_task = YTDLP_DOWNLOADER.download_audio(url, self.cookies_file)

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/renders/__init__.py

@@ -38,6 +38,5 @@ from nonebot import get_driver
 
 
 @get_driver().on_startup
-async def _():
-    # CommonRenderer.load_fonts()
-    CommonRenderer.load_custom_fonts()
+async def load_font():
+    _COMMON_RENDERER.load_font(pconfig.custom_font)

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/renders/base.py

@@ -4,6 +4,7 @@ from itertools import chain
 from pathlib import Path
 from typing import Any, ClassVar
 
+from ..config import pconfig
 from ..exception import DownloadException, DownloadLimitException, ZeroSizeException
 from ..helper import ForwardNodeInner, UniHelper, UniMessage
 from ..parsers import ParseResult
@@ -74,3 +75,7 @@ class BaseRenderer(ABC):
             message = f"{failed_count} 项媒体下载失败"
             yield UniMessage(message)
             raise DownloadException(message)
+
+    @property
+    def append_url(self) -> bool:
+        return pconfig.append_url

{nonebot_plugin_parser-2.0.3 → nonebot_plugin_parser-2.0.5}/src/nonebot_plugin_parser/renders/common.py

@@ -3,17 +3,19 @@ from pathlib import Path
 from typing import Any, ClassVar
 from typing_extensions import override
 
+from nonebot import logger
 from PIL import Image, ImageDraw, ImageFont
 
-from ..config import pconfig
 from .base import BaseRenderer, ParseResult, UniHelper, UniMessage
 
 
 class CommonRenderer(BaseRenderer):
     """统一的渲染器，将解析结果转换为消息"""
 
+    __slots__ = ("font_path", "fonts")
+
     # 卡片配置常量
-    PADDING = 20
+    PADDING = 25
     AVATAR_SIZE = 80
     AVATAR_TEXT_GAP = 15  # 头像和文字之间的间距
     MAX_COVER_WIDTH = 1000
@@ -42,8 +44,6 @@ class CommonRenderer(BaseRenderer):
     REPOST_BG_COLOR = (247, 247, 247)  # 转发背景色
     REPOST_BORDER_COLOR = (230, 230, 230)  # 转发边框色
     REPOST_PADDING = 12  # 转发内容内边距
-    REPOST_AVATAR_SIZE = 32  # 转发头像尺寸
-    REPOST_AVATAR_GAP = 8  # 转发头像和文字间距
 
     # 图片处理配置
     MIN_COVER_WIDTH = 300  # 最小封面宽度
@@ -72,20 +72,27 @@ class CommonRenderer(BaseRenderer):
     FONT_SIZES: ClassVar[dict[str, int]] = {"name": 28, "title": 30, "text": 24, "extra": 24}
     LINE_HEIGHTS: ClassVar[dict[str, int]] = {"name": 32, "title": 36, "text": 28, "extra": 28}
 
-    # 转发内容字体配置
-    REPOST_FONT_SIZES: ClassVar[dict[str, int]] = {"repost_name": 14, "repost_text": 14, "repost_time": 12}
-    REPOST_LINE_HEIGHTS: ClassVar[dict[str, int]] = {"repost_name": 16, "repost_text": 20, "repost_time": 14}
-    # 预加载的字体（在类定义后立即加载）
-    FONTS: ClassVar[dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont]]
+    DEFAULT_FONT_PATH: ClassVar[Path] = Path(__file__).parent / "fonts" / "HYSongYunLangHeiW-1.ttf"
+
+    def __init__(self, font_path: Path | None = None):
+        self.font_path: Path = self.DEFAULT_FONT_PATH
+
+    def load_font(self, font_path: Path | None = None):
+        if font_path is not None and font_path.exists():
+            self.font_path = font_path
+        self.fonts: dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont] = {
+            name: ImageFont.truetype(self.font_path, size) for name, size in self.FONT_SIZES.items()
+        }
+        logger.success(f"加载字体「{self.font_path.name}」成功")
 
     @override
     async def render_messages(self, result: ParseResult):
         # 生成图片卡片
         if image_raw := await self.draw_common_image(result):
             msg = UniMessage(UniHelper.img_seg(raw=image_raw))
-            if pconfig.append_url:
+            if self.append_url:
                 urls = (result.display_url, result.repost_display_url)
-                msg += "\n".join(urls)
+                msg += "\n".join(url for url in urls if url)
             yield msg
 
         # 媒体内容
@@ -101,40 +108,62 @@ class CommonRenderer(BaseRenderer):
         Returns:
             PNG 图片的字节数据，如果没有足够的内容则返回 None
         """
-        # 如果既没有标题, 文本也没有封面，不生成图片
-        # if not result.title and not result.text:
-        #     return None
+        # 调用内部方法生成图片
+        image = await self._create_card_image(result)
+        if not image:
+            return None
 
-        # 使用预加载的字体
-        fonts = self.FONTS
+        # 将图片转换为字节
+        output = BytesIO()
+        image.save(output, format="PNG")
+        return output.getvalue()
 
-        # 加载并处理封面
-        cover_img = self._load_and_resize_cover(await result.cover_path)
+    async def _create_card_image(
+        self, result: ParseResult, bg_color: tuple[int, int, int] | None = None, apply_min_cover_size: bool = True
+    ) -> Image.Image | None:
+        """创建卡片图片（内部方法，用于递归调用）
 
-        # 计算卡片宽度
-        if cover_img:
-            card_width = max(cover_img.width + 2 * self.PADDING, self.MIN_CARD_WIDTH)
-        else:
-            card_width = max(self.DEFAULT_CARD_WIDTH, self.MIN_CARD_WIDTH)
+        Args:
+            result: 解析结果
+            bg_color: 背景颜色，默认使用 BG_COLOR
+            apply_min_cover_size: 是否对封面应用最小尺寸限制，转发内容不需要
+
+        Returns:
+            PIL Image 对象，如果没有足够的内容则返回 None
+        """
+        # 使用预加载的字体
+
+        # 先确定固定的卡片宽度和内容区域宽度
+        card_width = max(self.DEFAULT_CARD_WIDTH, self.MIN_CARD_WIDTH)
         content_width = card_width - 2 * self.PADDING
 
+        # 加载并处理封面，传入内容区域宽度以确保封面不超过内容区域
+        cover_img = self._load_and_resize_cover(
+            await result.cover_path, content_width=content_width, apply_min_size=apply_min_cover_size
+        )
+
         # 计算各部分内容的高度
-        heights = await self._calculate_sections(result, cover_img, content_width, fonts)
+        heights = await self._calculate_sections(result, cover_img, content_width)
 
         # 计算总高度
         card_height = sum(h for _, h, _ in heights) + self.PADDING * 2 + self.SECTION_SPACING * (len(heights) - 1)
+        # 创建画布并绘制（使用指定的背景颜色，或默认背景颜色）
+        background_color = bg_color if bg_color is not None else self.BG_COLOR
+        image = Image.new("RGB", (card_width, card_height), background_color)
+        self._draw_sections(image, heights, card_width)
 
-        # 创建画布并绘制
-        image = Image.new("RGB", (card_width, card_height), self.BG_COLOR)
-        self._draw_sections(image, heights, card_width, fonts)
+        return image
 
-        # 将图片转换为字节
-        output = BytesIO()
-        image.save(output, format="PNG")
-        return output.getvalue()
+    def _load_and_resize_cover(
+        self, cover_path: Path | None, content_width: int, apply_min_size: bool = True
+    ) -> Image.Image | None:
+        """加载并调整封面尺寸
 
-    def _load_and_resize_cover(self, cover_path: Path | None) -> Image.Image | None:
-        """加载并调整封面尺寸"""
+        Args:
+            cover_path: 封面路径
+            content_width: 内容区域宽度，封面会缩放到此宽度以确保左右padding一致
+            apply_min_size: 是否应用最小尺寸限制（转发内容不需要）
+        """
         if not cover_path or not cover_path.exists():
             return None
 
@@ -145,24 +174,35 @@ class CommonRenderer(BaseRenderer):
             if cover_img.mode not in ("RGB", "RGBA"):
                 cover_img = cover_img.convert("RGB")
 
-            # 如果封面太大，需要缩放
-            if cover_img.width > self.MAX_COVER_WIDTH or cover_img.height > self.MAX_COVER_HEIGHT:
-                width_ratio = self.MAX_COVER_WIDTH / cover_img.width
-                height_ratio = self.MAX_COVER_HEIGHT / cover_img.height
-                scale_ratio = min(width_ratio, height_ratio)
+            # 封面宽度应该等于内容区域宽度，以确保左右padding一致
+            target_width = content_width
 
-                new_width = int(cover_img.width * scale_ratio)
+            # 计算缩放比例（保持宽高比）
+            if cover_img.width != target_width:
+                scale_ratio = target_width / cover_img.width
+                new_width = target_width
                 new_height = int(cover_img.height * scale_ratio)
-                cover_img = cover_img.resize((new_width, new_height), Image.Resampling.LANCZOS)
 
-            # 如果封面太小，需要放大到最小尺寸
-            if cover_img.width < self.MIN_COVER_WIDTH or cover_img.height < self.MIN_COVER_HEIGHT:
-                width_ratio = self.MIN_COVER_WIDTH / cover_img.width
-                height_ratio = self.MIN_COVER_HEIGHT / cover_img.height
-                scale_ratio = max(width_ratio, height_ratio)  # 使用max确保达到最小尺寸
+                # 检查高度是否超过最大限制
+                if new_height > self.MAX_COVER_HEIGHT:
+                    # 如果高度超限，按高度重新计算
+                    scale_ratio = self.MAX_COVER_HEIGHT / new_height
+                    new_height = self.MAX_COVER_HEIGHT
+                    new_width = int(new_width * scale_ratio)
+
+                # 如果是主内容且高度太小，需要放大（但不超过最大高度）
+                if apply_min_size and new_height < self.MIN_COVER_HEIGHT:
+                    min_height = min(self.MIN_COVER_HEIGHT, self.MAX_COVER_HEIGHT)
+                    if new_height < min_height:
+                        scale_ratio = min_height / new_height
+                        new_height = min_height
+                        new_width = int(new_width * scale_ratio)
+                        # 再次确保宽度不超过内容区域
+                        if new_width > content_width:
+                            scale_ratio = content_width / new_width
+                            new_width = content_width
+                            new_height = int(new_height * scale_ratio)
 
-                new_width = int(cover_img.width * scale_ratio)
-                new_height = int(cover_img.height * scale_ratio)
                 cover_img = cover_img.resize((new_width, new_height), Image.Resampling.LANCZOS)
 
             return cover_img
@@ -205,20 +245,20 @@ class CommonRenderer(BaseRenderer):
             return None
 
     async def _calculate_sections(
-        self, result: ParseResult, cover_img: Image.Image | None, content_width: int, fonts: dict
+        self, result: ParseResult, cover_img: Image.Image | None, content_width: int
     ) -> list[tuple[str, int, Any]]:
         """计算各部分内容的高度和数据"""
         heights = []
 
         # 1. Header 部分
         if result.author:
-            header_data = await self._calculate_header_section(result, content_width, fonts)
+            header_data = await self._calculate_header_section(result, content_width)
             if header_data:
                 heights.append(("header", header_data["height"], header_data))
 
         # 2. 标题部分
         if result.title:
-            title_lines = self._wrap_text(result.title, content_width, fonts["title"])
+            title_lines = self._wrap_text(result.title, content_width, self.fonts["title"])
             title_height = len(title_lines) * self.LINE_HEIGHTS["title"]
             heights.append(("title", title_height, title_lines))
 
@@ -233,25 +273,25 @@ class CommonRenderer(BaseRenderer):
 
         # 4. 文本内容
         if result.text:
-            text_lines = self._wrap_text(result.text, content_width, fonts["text"])
+            text_lines = self._wrap_text(result.text, content_width, self.fonts["text"])
             text_height = len(text_lines) * self.LINE_HEIGHTS["text"]
             heights.append(("text", text_height, text_lines))
 
         # 5. 额外信息
         if result.extra_info:
-            extra_lines = self._wrap_text(result.extra_info, content_width, fonts["extra"])
+            extra_lines = self._wrap_text(result.extra_info, content_width, self.fonts["extra"])
             extra_height = len(extra_lines) * self.LINE_HEIGHTS["extra"]
             heights.append(("extra", extra_height, extra_lines))
 
         # 6. 转发内容
         if result.repost:
-            repost_data = await self._calculate_repost_section(result.repost, content_width, fonts)
+            repost_data = await self._calculate_repost_section(result.repost, content_width)
             if repost_data:
                 heights.append(("repost", repost_data["height"], repost_data))
 
         return heights
 
-    async def _calculate_header_section(self, result: ParseResult, content_width: int, fonts: dict) -> dict | None:
+    async def _calculate_header_section(self, result: ParseResult, content_width: int) -> dict | None:
         """计算 header 部分的高度和内容"""
         if not result.author:
             return None
@@ -263,11 +303,11 @@ class CommonRenderer(BaseRenderer):
         text_area_width = content_width - (self.AVATAR_SIZE + self.AVATAR_TEXT_GAP)
 
         # 发布者名称
-        name_lines = self._wrap_text(result.author.name, text_area_width, fonts["name"])
+        name_lines = self._wrap_text(result.author.name, text_area_width, self.fonts["name"])
 
         # 时间
-        time_text = result.formart_datetime() if result.timestamp else ""
-        time_lines = self._wrap_text(time_text, text_area_width, fonts["extra"]) if time_text else []
+        time_text = result.formartted_datetime
+        time_lines = self._wrap_text(time_text, text_area_width, self.fonts["extra"]) if time_text else []
 
         # 计算 header 高度（取头像和文字中较大者）
         text_height = len(name_lines) * self.LINE_HEIGHTS["name"]
@@ -283,28 +323,24 @@ class CommonRenderer(BaseRenderer):
             "text_height": text_height,
         }
 
-    async def _calculate_repost_section(self, repost: ParseResult, content_width: int, fonts: dict) -> dict | None:
-        """计算转发内容的高度和内容"""
+    async def _calculate_repost_section(self, repost: ParseResult, content_width: int) -> dict | None:
+        """计算转发内容的高度和内容（递归调用绘制方法）"""
         if not repost:
             return None
 
-        # 使用原内容绘制逻辑，但缩小尺寸
-        repost_scale = self.REPOST_SCALE  # 转发内容缩放比例
-        repost_width = int(content_width * repost_scale)
+        # 递归调用内部方法，生成转发内容的完整卡片（使用转发背景颜色，不强制放大封面）
+        repost_image = await self._create_card_image(repost, bg_color=self.REPOST_BG_COLOR, apply_min_cover_size=False)
+        if not repost_image:
+            return None
 
-        # 计算转发内容的完整卡片
-        repost_cover = self._load_and_resize_cover(await repost.cover_path)
-        repost_heights = await self._calculate_sections(repost, repost_cover, repost_width, fonts)
-        repost_height = (
-            sum(h for _, h, _ in repost_heights) + self.PADDING * 2 + self.SECTION_SPACING * (len(repost_heights) - 1)
-        )
+        # 缩放图片
+        scaled_width = int(repost_image.width * self.REPOST_SCALE)
+        scaled_height = int(repost_image.height * self.REPOST_SCALE)
+        repost_image_scaled = repost_image.resize((scaled_width, scaled_height), Image.Resampling.LANCZOS)
 
         return {
-            "height": repost_height + self.REPOST_PADDING * 2,  # 加上转发容器的内边距
-            "scale": repost_scale,
-            "width": repost_width,
-            "heights": repost_heights,
-            "repost": repost,
+            "height": scaled_height + self.REPOST_PADDING * 2,  # 加上转发容器的内边距
+            "scaled_image": repost_image_scaled,
         }
 
     async def _calculate_image_grid_section(self, result: ParseResult, content_width: int) -> dict | None:
@@ -348,7 +384,10 @@ class CommonRenderer(BaseRenderer):
                             img = img.resize(new_size, Image.Resampling.LANCZOS)
                     else:
                         # 多张图片，使用网格布局
-                        max_size = min(self.MAX_IMAGE_GRID_SIZE, content_width // self.IMAGE_GRID_COLS)
+                        # 计算图片尺寸，确保左右间距相同：间距 + (图片 + 间距) * 列数 = 总宽度
+                        num_gaps = self.IMAGE_GRID_COLS + 1  # 3列有4个间距
+                        max_size = (content_width - self.IMAGE_GRID_SPACING * num_gaps) // self.IMAGE_GRID_COLS
+                        max_size = min(max_size, self.MAX_IMAGE_GRID_SIZE)
                         if img.width > max_size or img.height > max_size:
                             ratio = min(max_size / img.width, max_size / img.height)
                             new_size = (int(img.width * ratio), int(img.height * ratio))
@@ -373,7 +412,12 @@ class CommonRenderer(BaseRenderer):
 
         # 计算高度
         max_img_height = max(img.height for img in processed_images)
-        grid_height = rows * max_img_height + (rows - 1) * self.IMAGE_GRID_SPACING  # 图片间距
+        if len(processed_images) == 1:
+            # 单张图片
+            grid_height = max_img_height
+        else:
+            # 多张图片：上间距 + (图片 + 间距) * 行数
+            grid_height = self.IMAGE_GRID_SPACING + rows * (max_img_height + self.IMAGE_GRID_SPACING)
 
         return {
             "height": grid_height,
@@ -402,26 +446,24 @@ class CommonRenderer(BaseRenderer):
             bottom = top + width
             return img.crop((0, top, width, bottom))
 
-    def _draw_sections(
-        self, image: Image.Image, heights: list[tuple[str, int, Any]], card_width: int, fonts: dict
-    ) -> None:
+    def _draw_sections(self, image: Image.Image, heights: list[tuple[str, int, Any]], card_width: int) -> None:
         """绘制所有内容到画布上"""
         draw = ImageDraw.Draw(image)
         y_pos = self.PADDING
 
         for section_type, height, content in heights:
             if section_type == "header":
-                y_pos = self._draw_header(image, draw, content, y_pos, fonts)
+                y_pos = self._draw_header(image, draw, content, y_pos)
             elif section_type == "title":
-                y_pos = self._draw_title(draw, content, y_pos, fonts["title"])
+                y_pos = self._draw_title(draw, content, y_pos, self.fonts["title"])
             elif section_type == "cover":
                 y_pos = self._draw_cover(image, content, y_pos, card_width)
             elif section_type == "text":
-                y_pos = self._draw_text(draw, content, y_pos, fonts["text"])
+                y_pos = self._draw_text(draw, content, y_pos, self.fonts["text"])
             elif section_type == "extra":
-                y_pos = self._draw_extra(draw, content, y_pos, fonts["extra"])
+                y_pos = self._draw_extra(draw, content, y_pos, self.fonts["extra"])
             elif section_type == "repost":
-                y_pos = self._draw_repost(image, draw, content, y_pos, card_width, fonts)
+                y_pos = self._draw_repost(image, draw, content, y_pos, card_width)
             elif section_type == "image_grid":
                 y_pos = self._draw_image_grid(image, content, y_pos, card_width)
 
@@ -472,92 +514,7 @@ class CommonRenderer(BaseRenderer):
         placeholder.putalpha(mask)
         return placeholder
 
-    def _load_and_process_repost_avatar(self, avatar: Path | None) -> Image.Image | None:
-        """加载并处理转发头像（小尺寸圆形）"""
-        if not avatar or not avatar.exists():
-            return None
-
-        try:
-            avatar_img = Image.open(avatar)
-
-            # 转换为 RGBA 模式
-            if avatar_img.mode != "RGBA":
-                avatar_img = avatar_img.convert("RGBA")
-
-            # 使用超采样技术提高质量
-            scale = self.AVATAR_UPSCALE_FACTOR
-            temp_size = self.REPOST_AVATAR_SIZE * scale
-            avatar_img = avatar_img.resize((temp_size, temp_size), Image.Resampling.LANCZOS)
-
-            # 创建高分辨率圆形遮罩
-            mask = Image.new("L", (temp_size, temp_size), 0)
-            mask_draw = ImageDraw.Draw(mask)
-            mask_draw.ellipse((0, 0, temp_size - 1, temp_size - 1), fill=255)
-
-            # 应用遮罩
-            output_avatar = Image.new("RGBA", (temp_size, temp_size), (0, 0, 0, 0))
-            output_avatar.paste(avatar_img, (0, 0))
-            output_avatar.putalpha(mask)
-
-            # 缩小到目标尺寸
-            output_avatar = output_avatar.resize(
-                (self.REPOST_AVATAR_SIZE, self.REPOST_AVATAR_SIZE), Image.Resampling.LANCZOS
-            )
-
-            return output_avatar
-        except Exception:
-            return None
-
-    def _create_repost_avatar_placeholder(self) -> Image.Image:
-        """创建转发头像占位符"""
-        placeholder = Image.new("RGBA", (self.REPOST_AVATAR_SIZE, self.REPOST_AVATAR_SIZE), (0, 0, 0, 0))
-        draw = ImageDraw.Draw(placeholder)
-
-        # 绘制圆形背景
-        draw.ellipse(
-            (0, 0, self.REPOST_AVATAR_SIZE - 1, self.REPOST_AVATAR_SIZE - 1), fill=self.AVATAR_PLACEHOLDER_BG_COLOR
-        )
-
-        # 绘制简单的用户图标
-        center_x = self.REPOST_AVATAR_SIZE // 2
-        head_radius = int(self.REPOST_AVATAR_SIZE * self.AVATAR_HEAD_RADIUS_RATIO)
-        head_y = int(self.REPOST_AVATAR_SIZE * self.AVATAR_HEAD_RATIO)
-        draw.ellipse(
-            (
-                center_x - head_radius,
-                head_y - head_radius,
-                center_x + head_radius,
-                head_y + head_radius,
-            ),
-            fill=self.AVATAR_PLACEHOLDER_FG_COLOR,
-        )
-
-        # 肩部
-        shoulder_y = int(self.REPOST_AVATAR_SIZE * self.AVATAR_SHOULDER_Y_RATIO)
-        shoulder_width = int(self.REPOST_AVATAR_SIZE * self.AVATAR_SHOULDER_WIDTH_RATIO)
-        shoulder_height = int(self.REPOST_AVATAR_SIZE * self.AVATAR_SHOULDER_HEIGHT_RATIO)
-        draw.ellipse(
-            (
-                center_x - shoulder_width // 2,
-                shoulder_y,
-                center_x + shoulder_width // 2,
-                shoulder_y + shoulder_height,
-            ),
-            fill=self.AVATAR_PLACEHOLDER_FG_COLOR,
-        )
-
-        # 创建圆形遮罩
-        mask = Image.new("L", (self.REPOST_AVATAR_SIZE, self.REPOST_AVATAR_SIZE), 0)
-        mask_draw = ImageDraw.Draw(mask)
-        mask_draw.ellipse((0, 0, self.REPOST_AVATAR_SIZE - 1, self.REPOST_AVATAR_SIZE - 1), fill=255)
-
-        # 应用遮罩
-        placeholder.putalpha(mask)
-        return placeholder
-
-    def _draw_header(
-        self, image: Image.Image, draw: ImageDraw.ImageDraw, content: dict, y_pos: int, fonts: dict
-    ) -> int:
+    def _draw_header(self, image: Image.Image, draw: ImageDraw.ImageDraw, content: dict, y_pos: int) -> int:
         """绘制 header 部分"""
         x_pos = self.PADDING
 
@@ -575,14 +532,14 @@ class CommonRenderer(BaseRenderer):
 
         # 发布者名称（蓝色）
         for line in content["name_lines"]:
-            draw.text((text_x, text_y), line, fill=self.HEADER_COLOR, font=fonts["name"])
+            draw.text((text_x, text_y), line, fill=self.HEADER_COLOR, font=self.fonts["name"])
             text_y += self.LINE_HEIGHTS["name"]
 
         # 时间（灰色）
         if content["time_lines"]:
             text_y += self.NAME_TIME_GAP
             for line in content["time_lines"]:
-                draw.text((text_x, text_y), line, fill=self.EXTRA_COLOR, font=fonts["extra"])
+                draw.text((text_x, text_y), line, fill=self.EXTRA_COLOR, font=self.fonts["extra"])
                 text_y += self.LINE_HEIGHTS["extra"]
 
         return y_pos + content["height"] + self.SECTION_SPACING
@@ -596,7 +553,8 @@ class CommonRenderer(BaseRenderer):
 
     def _draw_cover(self, image: Image.Image, cover_img: Image.Image, y_pos: int, card_width: int) -> int:
         """绘制封面"""
-        x_pos = (card_width - cover_img.width) // 2
+        # 封面从左边padding开始，和文字、头像对齐
+        x_pos = self.PADDING
         image.paste(cover_img, (x_pos, y_pos))
 
         # 添加视频播放标志
@@ -651,13 +609,17 @@ class CommonRenderer(BaseRenderer):
         return y_pos
 
     def _draw_repost(
-        self, image: Image.Image, draw: ImageDraw.ImageDraw, content: dict, y_pos: int, card_width: int, fonts: dict
+        self, image: Image.Image, draw: ImageDraw.ImageDraw, content: dict, y_pos: int, card_width: int
     ) -> int:
         """绘制转发内容"""
-        # 计算转发区域位置
+        # 获取缩放后的转发图片
+        repost_image = content["scaled_image"]
+
+        # 转发框占满整个内容区域，左右和边缘对齐
+        content_width = card_width - 2 * self.PADDING
         repost_x = self.PADDING
         repost_y = y_pos
-        repost_width = card_width - 2 * self.PADDING
+        repost_width = content_width  # 转发框宽度等于内容区域宽度
         repost_height = content["height"]
 
         # 绘制转发背景（圆角矩形）
@@ -677,15 +639,12 @@ class CommonRenderer(BaseRenderer):
             width=1,
         )
 
-        # 创建转发内容的完整卡片
-        repost_card = self._create_repost_card(content, fonts)
-
-        # 计算转发卡片在转发容器中的位置（居中）
-        card_x = repost_x + self.REPOST_PADDING
+        # 转发图片在转发容器中居中
+        card_x = repost_x + (repost_width - repost_image.width) // 2
         card_y = repost_y + self.REPOST_PADDING
 
-        # 将转发卡片贴到主画布上
-        image.paste(repost_card, (card_x, card_y))
+        # 将缩放后的转发图片贴到主画布上
+        image.paste(repost_image, (card_x, card_y))
 
         return y_pos + repost_height + self.SECTION_SPACING
 
@@ -709,8 +668,11 @@ class CommonRenderer(BaseRenderer):
             # 单张图片，使用完整的可用宽度，与视频封面保持一致
             max_img_size = available_width
         else:
-            # 多张图片，统一使用3列布局（九宫格），使用较小尺寸
-            max_img_size = min(self.MAX_IMAGE_GRID_SIZE, (available_width - 2 * img_spacing) // self.IMAGE_GRID_COLS)
+            # 多张图片，统一使用3列布局（九宫格）
+            # 计算图片尺寸，确保所有间距相同
+            num_gaps = cols + 1  # 3列有4个间距
+            max_img_size = (available_width - img_spacing * num_gaps) // cols
+            max_img_size = min(max_img_size, self.MAX_IMAGE_GRID_SIZE)
 
         current_y = y_pos
 
@@ -722,10 +684,11 @@ class CommonRenderer(BaseRenderer):
             # 计算这一行的最大高度
             max_height = max(img.height for img in row_images)
 
-            # 绘制这一行的图片（左对齐）
+            # 绘制这一行的图片
             for i, img in enumerate(row_images):
-                img_x = self.PADDING + i * (max_img_size + img_spacing)
-                img_y = current_y
+                # 每张图片左侧都有间距：间距 + (间距 + 图片) * i
+                img_x = self.PADDING + img_spacing + i * (max_img_size + img_spacing)
+                img_y = current_y + img_spacing  # 每行上方都有间距
 
                 # 居中放置图片
                 y_offset = (max_height - img.height) // 2
@@ -735,9 +698,9 @@ class CommonRenderer(BaseRenderer):
                 if has_more and row == rows - 1 and i == len(row_images) - 1 and len(images) == self.MAX_IMAGES_DISPLAY:
                     self._draw_more_indicator(image, img_x, img_y, max_img_size, max_height, remaining_count)
 
-            current_y += max_height + img_spacing
+            current_y += img_spacing + max_height
 
-        return current_y + self.SECTION_SPACING
+        return current_y + img_spacing + self.SECTION_SPACING
 
     def _draw_more_indicator(
         self, image: Image.Image, img_x: int, img_y: int, img_width: int, img_height: int, count: int
@@ -745,23 +708,19 @@ class CommonRenderer(BaseRenderer):
         """在图片上绘制+N指示器"""
         draw = ImageDraw.Draw(image)
 
-        # 创建半透明黑色遮罩
+        # 创建半透明黑色遮罩（透明度 1/4）
         overlay = Image.new("RGBA", (img_width, img_height), (0, 0, 0, 0))
         overlay_draw = ImageDraw.Draw(overlay)
-        overlay_draw.rectangle((0, 0, img_width - 1, img_height - 1), fill=(0, 0, 0, 150))
+        overlay_draw.rectangle((0, 0, img_width - 1, img_height - 1), fill=(0, 0, 0, 100))
 
         # 将遮罩贴到图片上
         image.paste(overlay, (img_x, img_y), overlay)
 
         # 绘制+N文字
         text = f"+{count}"
-        # 使用较大的字体
-        font_size = min(img_width, img_height) // 6
-        try:
-            font_path = Path(__file__).parent / "fonts" / "HYSongYunLangHeiW-1.ttf"
-            font = ImageFont.truetype(font_path, font_size)
-        except Exception:
-            font = ImageFont.load_default()
+        # 使用更大的字体
+        font_size = min(img_width, img_height) // 4
+        font = ImageFont.truetype(self.font_path, font_size)
 
         # 计算文字位置（居中）
         bbox = font.getbbox(text)
@@ -773,107 +732,6 @@ class CommonRenderer(BaseRenderer):
         # 绘制白色文字
         draw.text((text_x, text_y), text, fill=(255, 255, 255, 255), font=font)
 
-    def _create_repost_card(self, content: dict, fonts: dict) -> Image.Image:
-        """创建转发内容的完整卡片"""
-        scale = content["scale"]
-        card_width = content["width"]
-        heights = content["heights"]
-
-        # 计算卡片高度
-        card_height = sum(h for _, h, _ in heights) + self.PADDING * 2 + self.SECTION_SPACING * (len(heights) - 1)
-
-        # 创建转发卡片画布
-        repost_card = Image.new("RGB", (card_width, card_height), self.REPOST_BG_COLOR)
-
-        # 使用缩放后的字体
-        scaled_fonts = {}
-        for name, font in fonts.items():
-            if hasattr(font, "size"):
-                # 使用默认字体路径
-                font_path = Path(__file__).parent / "fonts" / "HYSongYunLangHeiW-1.ttf"
-                scaled_fonts[name] = ImageFont.truetype(font_path, int(font.size * scale))
-            else:
-                scaled_fonts[name] = font
-
-        # 绘制转发内容的所有部分
-        self._draw_sections(repost_card, heights, card_width, scaled_fonts)
-
-        return repost_card
-
-    def _draw_repost_header(
-        self, image: Image.Image, draw: ImageDraw.ImageDraw, content: dict, x_pos: int, y_pos: int, fonts: dict
-    ) -> int:
-        """绘制转发头部"""
-        # 绘制头像
-        avatar = content["avatar"] if content["avatar"] else self._create_repost_avatar_placeholder()
-        image.paste(avatar, (x_pos, y_pos), avatar)
-
-        # 绘制用户名和时间
-        text_x = x_pos + self.REPOST_AVATAR_SIZE + self.REPOST_AVATAR_GAP
-        text_y = y_pos
-
-        # 用户名
-        for line in content["name_lines"]:
-            draw.text((text_x, text_y), line, fill=self.TEXT_COLOR, font=fonts["repost_name"])
-            text_y += self.REPOST_LINE_HEIGHTS["repost_name"]
-
-        # 时间
-        if content["time_lines"]:
-            text_y += 4  # 用户名和时间间距
-            for line in content["time_lines"]:
-                draw.text((text_x, text_y), line, fill=self.EXTRA_COLOR, font=fonts["repost_time"])
-                text_y += self.REPOST_LINE_HEIGHTS["repost_time"]
-
-        return y_pos + max(self.REPOST_AVATAR_SIZE, text_y - y_pos)
-
-    def _draw_repost_text(
-        self, draw: ImageDraw.ImageDraw, lines: list[str], x_pos: int, y_pos: int, fonts: dict
-    ) -> int:
-        """绘制转发文本"""
-        current_y = y_pos
-        for line in lines:
-            draw.text((x_pos, current_y), line, fill=self.TEXT_COLOR, font=fonts["repost_text"])
-            current_y += self.REPOST_LINE_HEIGHTS["repost_text"]
-        return current_y
-
-    def _draw_repost_media(
-        self, image: Image.Image, media_items: list[Image.Image], x_pos: int, y_pos: int, content_width: int
-    ) -> int:
-        """绘制转发媒体（图片网格）"""
-        if not media_items:
-            return y_pos
-
-        # 计算网格布局
-        cols = min(3, len(media_items))
-        rows = (len(media_items) + cols - 1) // cols
-
-        # 计算每个图片的尺寸
-        max_img_size = min(300, content_width // 3)
-        img_spacing = 6
-
-        current_y = y_pos
-
-        for row in range(rows):
-            row_start = row * cols
-            row_end = min(row_start + cols, len(media_items))
-            row_items = media_items[row_start:row_end]
-
-            # 计算这一行的最大高度
-            max_height = max(img.height for img in row_items)
-
-            # 绘制这一行的图片
-            for i, img in enumerate(row_items):
-                img_x = x_pos + i * (max_img_size + img_spacing)
-                img_y = current_y
-
-                # 居中放置图片
-                y_offset = (max_height - img.height) // 2
-                image.paste(img, (img_x, img_y + y_offset))
-
-            current_y += max_height + img_spacing
-
-        return current_y
-
     def _draw_rounded_rectangle(
         self, image: Image.Image, bbox: tuple[int, int, int, int], fill_color: tuple[int, int, int], radius: int = 8
     ):
@@ -960,14 +818,3 @@ class CommonRenderer(BaseRenderer):
                 lines.append(current_line)
 
         return lines if lines else [""]
-
-    @classmethod
-    def load_custom_fonts(cls):
-        """加载字体"""
-        font_path = Path(__file__).parent / "fonts" / "HYSongYunLangHeiW-1.ttf"
-        # 加载主字体
-        main_fonts = {name: ImageFont.truetype(font_path, size) for name, size in cls.FONT_SIZES.items()}
-        # 加载转发字体
-        repost_fonts = {name: ImageFont.truetype(font_path, size) for name, size in cls.REPOST_FONT_SIZES.items()}
-        # 合并字体字典
-        cls.FONTS = {**main_fonts, **repost_fonts}