chore: Add PyPI package support for uvx/pip installation (#1764)

* Initial plan

* Add package structure and resource path utilities

- Created langbot/ package with __init__.py and __main__.py entry point
- Added paths utility to find frontend and resource files from package installation
- Updated config loading to use resource paths
- Updated frontend serving to use resource paths
- Added MANIFEST.in for package data inclusion
- Updated pyproject.toml with build system and entry points

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

* Add PyPI publishing workflow and update license

- Created GitHub Actions workflow to build frontend and publish to PyPI
- Added license field to pyproject.toml to fix deprecation warning
- Updated .gitignore to exclude build artifacts
- Tested package building successfully

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

* Add PyPI installation documentation

- Created PYPI_INSTALLATION.md with detailed installation and usage instructions
- Updated README.md to feature uvx/pip installation as recommended method
- Updated README_EN.md with same changes for English documentation

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

* Address code review feedback

- Made package-data configuration more specific to langbot package only
- Improved path detection with caching to avoid repeated file I/O
- Removed sys.path searching which was incorrect for package data
- Removed interactive input() call for non-interactive environment compatibility
- Simplified error messages for version check

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

* Fix code review issues

- Use specific exception types instead of bare except
- Fix misleading comments about directory levels
- Remove redundant existence check before makedirs with exist_ok=True
- Use context manager for file opening to ensure proper cleanup

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

* Simplify package configuration and document behavioral differences

- Removed redundant package-data configuration, relying on MANIFEST.in
- Added documentation about behavioral differences between package and source installation
- Clarified that include-package-data=true uses MANIFEST.in for data files

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

* chore: update pyproject.toml

* chore: try pack templates in langbot/

* chore: update

* chore: update

* chore: update

* chore: update

* chore: update

* chore: adjust dir structure

* chore: fix imports

* fix: read default-pipeline-config.json

* fix: read default-pipeline-config.json

* fix: tests

* ci: publish pypi

* chore: bump version 4.6.0-beta.1 for testing

* chore: add templates/**

* fix: send adapters and requesters icons

* chore: bump version 4.6.0b2 for testing

* chore: add platform field for docker-compose.yaml

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>
Co-authored-by: Junyan Qin <rockchinq@gmail.com>

src/langbot/pkg/pipeline/ratelimit/algo.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+import abc
+import typing
+
+from ...core import app
+import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
+
+
+preregistered_algos: list[typing.Type[ReteLimitAlgo]] = []
+
+
+def algo_class(name: str):
+    def decorator(cls: typing.Type[ReteLimitAlgo]) -> typing.Type[ReteLimitAlgo]:
+        cls.name = name
+        preregistered_algos.append(cls)
+        return cls
+
+    return decorator
+
+
+class ReteLimitAlgo(metaclass=abc.ABCMeta):
+    """限流算法抽象类"""
+
+    name: str = None
+
+    ap: app.Application
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+    async def initialize(self):
+        pass
+
+    @abc.abstractmethod
+    async def require_access(
+        self,
+        query: pipeline_query.Query,
+        launcher_type: str,
+        launcher_id: typing.Union[int, str],
+    ) -> bool:
+        """进入处理流程
+
+        这个方法对等待是友好的，意味着算法可以实现在这里等待一段时间以控制速率。
+
+        Args:
+            launcher_type (str): 请求者类型 群聊为 group 私聊为 person
+            launcher_id (int): 请求者ID
+
+        Returns:
+            bool: 是否允许进入处理流程，若返回false，则直接丢弃该请求
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def release_access(
+        self,
+        query: pipeline_query.Query,
+        launcher_type: str,
+        launcher_id: typing.Union[int, str],
+    ):
+        """退出处理流程
+
+        Args:
+            launcher_type (str): 请求者类型 群聊为 group 私聊为 person
+            launcher_id (int): 请求者ID
+        """
+
+        raise NotImplementedError

src/langbot/pkg/pipeline/ratelimit/algos/fixedwin.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+import asyncio
+import time
+import typing
+from .. import algo
+import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
+
+
+# 固定窗口算法
+class SessionContainer:
+    wait_lock: asyncio.Lock
+
+    records: dict[int, int]
+    """访问记录，key为每窗口长度的起始时间戳，value为访问次数"""
+
+    def __init__(self):
+        self.wait_lock = asyncio.Lock()
+        self.records = {}
+
+
+@algo.algo_class('fixwin')
+class FixedWindowAlgo(algo.ReteLimitAlgo):
+    containers_lock: asyncio.Lock
+    """访问记录容器锁"""
+
+    containers: dict[str, SessionContainer]
+    """访问记录容器，key为launcher_type launcher_id"""
+
+    async def initialize(self):
+        self.containers_lock = asyncio.Lock()
+        self.containers = {}
+
+    async def require_access(
+        self,
+        query: pipeline_query.Query,
+        launcher_type: str,
+        launcher_id: typing.Union[int, str],
+    ) -> bool:
+        # 加锁，找容器
+        container: SessionContainer = None
+
+        session_name = f'{launcher_type}_{launcher_id}'
+
+        async with self.containers_lock:
+            container = self.containers.get(session_name)
+
+            if container is None:
+                container = SessionContainer()
+                self.containers[session_name] = container
+
+        # 等待锁
+        async with container.wait_lock:
+            # 获取窗口大小和限制
+            window_size = query.pipeline_config['safety']['rate-limit']['window-length']
+            limitation = query.pipeline_config['safety']['rate-limit']['limitation']
+
+            # TODO revert it
+            # if session_name in self.ap.pipeline_cfg.data['rate-limit']['fixwin']:
+            #     window_size = self.ap.pipeline_cfg.data['rate-limit']['fixwin'][session_name]['window-size']
+            #     limitation = self.ap.pipeline_cfg.data['rate-limit']['fixwin'][session_name]['limit']
+
+            # 获取当前时间戳
+            now = int(time.time())
+
+            # 获取当前窗口的起始时间戳
+            now = now - now % window_size
+
+            # 获取当前窗口的访问次数
+            count = container.records.get(now, 0)
+
+            # 如果访问次数超过了限制
+            if count >= limitation:
+                if query.pipeline_config['safety']['rate-limit']['strategy'] == 'drop':
+                    return False
+                elif query.pipeline_config['safety']['rate-limit']['strategy'] == 'wait':
+                    # 等待下一窗口
+                    await asyncio.sleep(window_size - time.time() % window_size)
+
+                    now = int(time.time())
+                    now = now - now % window_size
+
+            if now not in container.records:
+                container.records = {}
+                container.records[now] = 1
+            else:
+                # 访问次数加一
+                container.records[now] = count + 1
+
+            # 返回True
+            return True
+
+    async def release_access(
+        self,
+        query: pipeline_query.Query,
+        launcher_type: str,
+        launcher_id: typing.Union[int, str],
+    ):
+        pass

src/langbot/pkg/pipeline/ratelimit/ratelimit.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import typing
+
+from .. import entities, stage
+from . import algo
+from ...utils import importutil
+
+import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
+
+from . import algos
+
+importutil.import_modules_in_pkg(algos)
+
+
+@stage.stage_class('RequireRateLimitOccupancy')
+@stage.stage_class('ReleaseRateLimitOccupancy')
+class RateLimit(stage.PipelineStage):
+    """限速器控制阶段
+
+    不改写query，只检查是否需要限速。
+    """
+
+    algo: algo.ReteLimitAlgo
+
+    async def initialize(self, pipeline_config: dict):
+        algo_name = 'fixwin'
+
+        algo_class = None
+
+        for algo_cls in algo.preregistered_algos:
+            if algo_cls.name == algo_name:
+                algo_class = algo_cls
+                break
+        else:
+            raise ValueError(f'未知的限速算法: {algo_name}')
+
+        self.algo = algo_class(self.ap)
+        await self.algo.initialize()
+
+    async def process(
+        self,
+        query: pipeline_query.Query,
+        stage_inst_name: str,
+    ) -> typing.Union[
+        entities.StageProcessResult,
+        typing.AsyncGenerator[entities.StageProcessResult, None],
+    ]:
+        """处理"""
+        if stage_inst_name == 'RequireRateLimitOccupancy':
+            if await self.algo.require_access(
+                query,
+                query.launcher_type.value,
+                query.launcher_id,
+            ):
+                return entities.StageProcessResult(
+                    result_type=entities.ResultType.CONTINUE,
+                    new_query=query,
+                )
+            else:
+                return entities.StageProcessResult(
+                    result_type=entities.ResultType.INTERRUPT,
+                    new_query=query,
+                    console_notice=f'根据限速规则忽略 {query.launcher_type.value}:{query.launcher_id} 消息',
+                    user_notice='请求数超过限速器设定值，已丢弃本消息。',
+                )
+        elif stage_inst_name == 'ReleaseRateLimitOccupancy':
+            await self.algo.release_access(
+                query,
+                query.launcher_type.value,
+                query.launcher_id,
+            )
+            return entities.StageProcessResult(
+                result_type=entities.ResultType.CONTINUE,
+                new_query=query,
+            )