feat: add Rust acceleration for core parsing

Author: jxxghp

.dockerignore

@@ -73,6 +73,7 @@ test_*
 build/
 dist/
 *.egg-info/
+rust/**/target/
 
 # Docker
 Dockerfile*
@@ -81,4 +82,4 @@ docker-compose*
 
 # Other
 app.ico
-frozen.spec
+frozen.spec

.gitignore

@@ -6,6 +6,7 @@
 build/
 cython_cache/
 dist/
+rust/**/target/
 nginx/
 test.py
 safety_report.txt

README.md

@@ -56,6 +56,17 @@ MCP工具API文档：详见 [docs/mcp-api.md](docs/mcp-api.md)
 
 开发环境准备与本地源码运行说明：[`docs/development-setup.md`](docs/development-setup.md)
 
+本地开发启用 Rust 加速扩展，需先安装 Rust toolchain 并确保 `cargo` 可用：
+
+```shell
+cargo --version
+python -m pip install "maturin>=1.9,<2"
+python -m maturin develop --release --manifest-path rust/moviepilot_rust/Cargo.toml
+python -c "from app.utils import rust_accel; print(rust_accel.is_available())"
+```
+
+如果输出 `True`，说明当前开发环境已经加载 `moviepilot_rust`。重新修改 Rust 代码后再次执行 `python -m maturin develop --release --manifest-path rust/moviepilot_rust/Cargo.toml` 即可更新本地扩展。
+
 插件开发说明：<https://wiki.movie-pilot.org/zh/plugindev>
 
 ## 相关项目

app/core/meta/metavideo.py

@@ -11,6 +11,7 @@
 from app.utils.string import StringUtils
 from app.utils.tokens import Tokens
 from app.core.meta.streamingplatform import StreamingPlatforms
+from app.utils import rust_accel
 
 
 class MetaVideo(MetaBase):
@@ -102,59 +103,61 @@ def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         title = re.sub(r'[0-9.]+\s*[MGT]i?B(?![A-Z]+)', "", title, flags=re.IGNORECASE)
         # 把年月日去掉
         title = re.sub(r'\d{4}[\s._-]\d{1,2}[\s._-]\d{1,2}', "", title)
-        # 拆分tokens
-        tokens = Tokens(title)
-        # 实例化StreamingPlatforms对象
-        streaming_platforms = StreamingPlatforms()
         media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIOEXT
-        # 解析名称、年份、季、集、资源类型、分辨率等
-        token = tokens.get_next()
-        while token:
-            self._index += 1  # 更新当前处理的token索引
-            # Part
-            self.__init_part(token, tokens)
-            # 标题
-            if self._continue_flag:
-                self.__init_name(token, media_exts)
-            # 年份
-            if self._continue_flag:
-                self.__init_year(token)
-            # 分辨率
-            if self._continue_flag:
-                self.__init_resource_pix(token)
-            # 季
-            if self._continue_flag:
-                self.__init_season(token)
-            # 集
-            if self._continue_flag:
-                self.__init_episode(token)
-            # 资源类型
-            if self._continue_flag:
-                self.__init_resource_type(token)
-            # 流媒体平台
-            if self._continue_flag:
-                self.__init_web_source(token, tokens, streaming_platforms)
-            # 视频编码
-            if self._continue_flag:
-                self.__init_video_encode(token)
-            # 视频位深
-            if self._continue_flag:
-                self.__init_video_bit(token)
-            # 音频编码
-            if self._continue_flag:
-                self.__init_audio_encode(token)
-            # 帧率
-            if self._continue_flag:
-                self.__init_fps(token)
-            # 取下一个，直到没有为卡
+        rust_parse = rust_accel.parse_video_title(title, isfile=isfile, media_exts=media_exts)
+        if not self.__apply_rust_parse(rust_parse):
+            # 拆分tokens
+            tokens = Tokens(title)
+            # 实例化StreamingPlatforms对象
+            streaming_platforms = StreamingPlatforms()
+            # 解析名称、年份、季、集、资源类型、分辨率等
             token = tokens.get_next()
-            self._continue_flag = True
-        # 合成质量
-        if self._effect:
-            self._effect.reverse()
-            self.resource_effect = " ".join(self._effect)
-        if self._source:
-            self.resource_type = self._source.strip()
+            while token:
+                self._index += 1  # 更新当前处理的token索引
+                # Part
+                self.__init_part(token, tokens)
+                # 标题
+                if self._continue_flag:
+                    self.__init_name(token, media_exts)
+                # 年份
+                if self._continue_flag:
+                    self.__init_year(token)
+                # 分辨率
+                if self._continue_flag:
+                    self.__init_resource_pix(token)
+                # 季
+                if self._continue_flag:
+                    self.__init_season(token)
+                # 集
+                if self._continue_flag:
+                    self.__init_episode(token)
+                # 资源类型
+                if self._continue_flag:
+                    self.__init_resource_type(token)
+                # 流媒体平台
+                if self._continue_flag:
+                    self.__init_web_source(token, tokens, streaming_platforms)
+                # 视频编码
+                if self._continue_flag:
+                    self.__init_video_encode(token)
+                # 视频位深
+                if self._continue_flag:
+                    self.__init_video_bit(token)
+                # 音频编码
+                if self._continue_flag:
+                    self.__init_audio_encode(token)
+                # 帧率
+                if self._continue_flag:
+                    self.__init_fps(token)
+                # 取下一个，直到没有为卡
+                token = tokens.get_next()
+                self._continue_flag = True
+            # 合成质量
+            if self._effect:
+                self._effect.reverse()
+                self.resource_effect = " ".join(self._effect)
+            if self._source:
+                self.resource_type = self._source.strip()
         # 提取原盘DIY
         if self.resource_type and "BluRay" in self.resource_type:
             if (self.subtitle and re.findall(r'D[Ii]Y', self.subtitle)) \
@@ -185,6 +188,62 @@ def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         if not self.video_bit:
             self.video_bit = self.extract_video_bit(self.video_encode)
 
+    def __apply_rust_parse(self, rust_parse: Optional[dict]) -> bool:
+        """
+        应用 Rust 主识别结果；成功时跳过 Python token 主循环。
+        """
+        if not rust_parse or not rust_parse.get("complete"):
+            return False
+        self.cn_name = rust_parse.get("cn_name")
+        self.en_name = rust_parse.get("en_name")
+        if rust_parse.get("year"):
+            self.year = str(rust_parse.get("year"))
+        self.part = rust_parse.get("part")
+        self.__merge_rust_parse(rust_parse)
+        media_type = rust_parse.get("type")
+        if media_type == "tv":
+            self.type = MediaType.TV
+        elif media_type == "movie":
+            self.type = MediaType.MOVIE
+        return True
+
+    def __merge_rust_parse(self, rust_parse: Optional[dict]) -> None:
+        """
+        合并 Rust 预解析结果，仅补齐 Python 识别未命中的资源字段。
+        """
+        if not rust_parse:
+            return
+        if not self.year and rust_parse.get("year"):
+            self.year = str(rust_parse.get("year"))
+        if self.begin_season is None and rust_parse.get("begin_season") is not None:
+            self.begin_season = int(rust_parse.get("begin_season"))
+            self.type = MediaType.TV
+        if self.end_season is None and rust_parse.get("end_season") is not None:
+            self.end_season = int(rust_parse.get("end_season"))
+        if not self.total_season and rust_parse.get("total_season"):
+            self.total_season = int(rust_parse.get("total_season"))
+        if self.begin_episode is None and rust_parse.get("begin_episode") is not None:
+            self.begin_episode = int(rust_parse.get("begin_episode"))
+            self.type = MediaType.TV
+        if self.end_episode is None and rust_parse.get("end_episode") is not None:
+            self.end_episode = int(rust_parse.get("end_episode"))
+        if not self.total_episode and rust_parse.get("total_episode"):
+            self.total_episode = int(rust_parse.get("total_episode"))
+        if not self.resource_pix and rust_parse.get("resource_pix"):
+            self.resource_pix = rust_parse.get("resource_pix")
+        if not self.resource_type and rust_parse.get("resource_type"):
+            self.resource_type = rust_parse.get("resource_type")
+        if not self.resource_effect and rust_parse.get("resource_effect"):
+            self.resource_effect = rust_parse.get("resource_effect")
+        if not self.video_encode and rust_parse.get("video_encode"):
+            self.video_encode = rust_parse.get("video_encode")
+        if not self.video_bit and rust_parse.get("video_bit"):
+            self.video_bit = rust_parse.get("video_bit")
+        if not self.audio_encode and rust_parse.get("audio_encode"):
+            self.audio_encode = rust_parse.get("audio_encode")
+        if self.fps is None and rust_parse.get("fps") is not None:
+            self.fps = int(rust_parse.get("fps"))
+
     @staticmethod
     def __get_title_from_description(description: str) -> Optional[str]:
         """

app/core/metainfo.py

@@ -12,6 +12,7 @@
 from app.core.meta.words import WordsMatcher
 from app.log import logger
 from app.schemas.types import MediaType
+from app.utils import rust_accel
 
 
 _ANIME_BRACKET_RE = re.compile(r'【[+0-9XVPI-]+】\s*【', re.IGNORECASE)
@@ -168,6 +169,9 @@ def is_anime(name: str) -> bool:
     :param name: 名称
     :return: 是否动漫
     """
+    rust_result = rust_accel.is_anime(name)
+    if rust_result is not None:
+        return rust_result
     if not name:
         return False
     if _ANIME_BRACKET_RE.search(name):
@@ -185,6 +189,9 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
     """
     从标题中提取媒体信息
     """
+    rust_result = rust_accel.find_metainfo(title)
+    if rust_result is not None:
+        return rust_result
     metainfo = _empty_metainfo()
     if not title:
         return title, metainfo

app/modules/filter/RuleParser.py

@@ -2,6 +2,8 @@
 
 from pyparsing import Forward, Literal, Word, alphas, infixNotation, opAssoc, alphanums, Combine, nums, ParseResults
 
+from app.utils import rust_accel
+
 
 class RuleParser:
 
@@ -48,9 +50,30 @@ def parse(self, expression: str) -> ParseResults:
         返回:
         解析结果
         """
+        rust_result = rust_accel.parse_filter_rule(expression)
+        if rust_result is not None:
+            return _RustParseResults(rust_result)
         return self.expr.parseString(expression)
 
 
+class _RustParseResults(list):
+    """
+    包装 Rust 解析结果，提供本模块调用方使用的 as_list/asList 接口。
+    """
+
+    def as_list(self) -> list:
+        """
+        返回兼容 pyparsing.ParseResults.as_list 的列表结构。
+        """
+        return list(self)
+
+    def asList(self) -> list:  # noqa: N802
+        """
+        返回兼容 pyparsing.ParseResults.asList 的列表结构。
+        """
+        return self.as_list()
+
+
 if __name__ == '__main__':
     # 测试代码
     expression_str = """

app/modules/filter/__init__.py

@@ -11,6 +11,7 @@
 from app.modules.filter.RuleParser import RuleParser
 from app.modules.filter.builtin_rules import BUILTIN_RULE_SET
 from app.schemas.types import ModuleType, OtherModulesType, SystemConfigKey
+from app.utils import rust_accel
 from app.utils.string import StringUtils
 
 
@@ -138,6 +139,9 @@ def filter_torrents(self, rule_groups: List[str],
         # 查询规则表详情
         groups = self.rulehelper.get_rule_group_by_media(media=mediainfo, group_names=rule_groups)
         if groups:
+            rust_filtered = self.__filter_torrents_by_rust(groups, torrent_list, mediainfo)
+            if rust_filtered is not None:
+                return rust_filtered
             for group in groups:
                 # 过滤种子
                 torrent_list = self.__filter_torrents(
@@ -150,6 +154,46 @@ def filter_torrents(self, rule_groups: List[str],
                 )
         return torrent_list
 
+    def __filter_torrents_by_rust(self, groups: list, torrent_list: List[TorrentInfo],
+                                  mediainfo: MediaInfo) -> Optional[List[TorrentInfo]]:
+        """
+        使用 Rust 批量过滤种子；遇到不可支持的规则时返回 None 交由 Python 逻辑处理。
+        """
+        if not torrent_list:
+            return []
+        payloads = [self.__build_rust_torrent_payload(torrent) for torrent in torrent_list]
+        media_payload = mediainfo.to_dict() if mediainfo and hasattr(mediainfo, "to_dict") else (
+            vars(mediainfo).copy() if mediainfo else None
+        )
+        result = rust_accel.filter_torrents(
+            rule_set=self.rule_set,
+            rule_strings=[group.rule_string for group in groups],
+            torrents=payloads,
+            media_info=media_payload,
+        )
+        if result is None:
+            return None
+        filtered_torrents = []
+        for index, pri_order in result:
+            torrent = torrent_list[int(index)]
+            torrent.pri_order = int(pri_order)
+            filtered_torrents.append(torrent)
+        return filtered_torrents
+
+    @staticmethod
+    def __build_rust_torrent_payload(torrent: TorrentInfo) -> dict:
+        """
+        组装 Rust 过滤器需要的纯数据载荷，避免 Rust 直接依赖 Python 业务对象。
+        """
+        payload = torrent.to_dict() if hasattr(torrent, "to_dict") else vars(torrent).copy()
+        payload["pub_minutes"] = torrent.pub_minutes()
+        if payload.get("size"):
+            meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
+            payload["episode_count"] = meta.total_episode or 1
+        else:
+            payload["episode_count"] = 1
+        return payload
+
     def __filter_torrents(self, rule_string: str, rule_name: str,
                           torrent_list: List[TorrentInfo],
                           mediainfo: MediaInfo,

app/modules/indexer/parser/__init__.py

@@ -11,8 +11,10 @@
 from app.core.config import settings
 from app.helper.cloudflare import under_challenge
 from app.log import logger
+from app.utils import rust_accel
 from app.utils.http import RequestUtils
 from app.utils.site import SiteUtils
+from app.utils.string import StringUtils
 
 
 # 站点框架
@@ -154,6 +156,16 @@ def site_schema(self) -> SiteSchema:
         """
         return self.schema
 
+    @staticmethod
+    def num_filesize(text) -> int:
+        """
+        将站点页面中的文件大小文本转换为字节，优先使用 Rust 快路径。
+        """
+        rust_value = rust_accel.parse_filesize(text)
+        if rust_value is not None:
+            return rust_value
+        return StringUtils.num_filesize(text)
+
     def parse(self):
         """
         解析站点信息