nonebot-plugin-git-poller 0.1.5__py3-none-any.whl

nonebot_plugin_git_poller/repository.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from urllib.parse import urlparse, urlunparse
+
+from .models import RepositoryIdentity
+
+
+_SCP_LIKE_PATTERN = re.compile(r"^(?P<user>[^@/:]+)@(?P<host>[^:]+):(?P<path>.+)$")
+
+
+def normalize_repo_url(url: str) -> str:
+    value = url.strip()
+    if not value:
+        raise ValueError("仓库 URL 不能为空。")
+
+    scp_like = _SCP_LIKE_PATTERN.fullmatch(value)
+    if scp_like:
+        host = scp_like.group("host").lower()
+        path = _clean_path(scp_like.group("path"))
+        return f"{scp_like.group('user')}@{host}:{path}"
+
+    if _is_local_path(value):
+        return value.rstrip("/")
+
+    parsed = urlparse(value)
+    if parsed.scheme and parsed.netloc:
+        scheme = parsed.scheme.lower()
+        netloc = _normalize_netloc(parsed)
+        path = _clean_path(parsed.path)
+        return urlunparse((scheme, netloc, path, "", "", ""))
+
+    return _clean_path(value)
+
+
+def repo_key_from_url(url: str, branch: str | None = None) -> str:
+    normalized = normalize_repo_url(url)
+    normalized_branch = normalize_branch(branch) if branch is not None else None
+    return _repo_key_from_normalized_url(normalized, normalized_branch)
+
+
+def build_identity(url: str, branch: str | None = None) -> RepositoryIdentity:
+    normalized = normalize_repo_url(url)
+    return build_identity_from_normalized_url(normalized, branch)
+
+
+def build_identity_from_normalized_url(
+    normalized_url: str,
+    branch: str | None = None,
+) -> RepositoryIdentity:
+    normalized_branch = normalize_branch(branch) if branch is not None else None
+    return RepositoryIdentity(
+        key=_repo_key_from_normalized_url(normalized_url, normalized_branch),
+        url=normalized_url,
+        display_name=display_name_from_url(normalized_url),
+        web_url=web_url_from_git_url(normalized_url),
+    )
+
+
+def _repo_key_from_normalized_url(
+    normalized: str,
+    normalized_branch: str | None,
+) -> str:
+    key_source = normalized if normalized_branch is None else f"{normalized}#{normalized_branch}"
+    digest = hashlib.sha1(key_source.encode("utf-8")).hexdigest()[:12]
+    parts = [display_name_from_url(normalized)]
+    if normalized_branch is not None:
+        parts.append(_safe_key_part(normalized_branch))
+    parts.append(digest)
+    return "-".join(parts)
+
+
+def normalize_branch(branch: str) -> str:
+    value = branch.strip()
+    if not value:
+        raise ValueError("分支名不能为空。")
+    return value
+
+
+def display_name_from_url(url: str) -> str:
+    parsed = urlparse(url)
+    if parsed.scheme and parsed.netloc:
+        name = parsed.path.rstrip("/").rsplit("/", 1)[-1]
+    elif ":" in url and _SCP_LIKE_PATTERN.fullmatch(url):
+        name = url.rsplit("/", 1)[-1]
+    else:
+        name = url.rstrip("/").rsplit("/", 1)[-1]
+    if name.endswith(".git"):
+        name = name[:-4]
+    return name or "repository"
+
+
+def web_url_from_git_url(url: str) -> str | None:
+    parsed = urlparse(url)
+    if parsed.scheme in {"http", "https"} and parsed.netloc:
+        path = parsed.path[:-4] if parsed.path.endswith(".git") else parsed.path
+        return urlunparse((parsed.scheme, parsed.netloc, path.rstrip("/"), "", "", ""))
+
+    scp_like = _SCP_LIKE_PATTERN.fullmatch(url)
+    if scp_like:
+        path = scp_like.group("path")
+        if path.endswith(".git"):
+            path = path[:-4]
+        return f"https://{scp_like.group('host').lower()}/{path.strip('/')}"
+
+    return None
+
+
+def build_commit_url(repo_url: str, sha: str) -> str | None:
+    web_url = web_url_from_git_url(repo_url)
+    if not web_url:
+        return None
+    return f"{web_url}/-/commit/{sha}" if _uses_gitlab_routes(web_url) else f"{web_url}/commit/{sha}"
+
+
+def build_compare_url(repo_url: str, from_sha: str | None, to_sha: str) -> str | None:
+    if not from_sha:
+        return None
+    web_url = web_url_from_git_url(repo_url)
+    if not web_url:
+        return None
+    separator = "..."
+    path = f"/-/compare/{from_sha}{separator}{to_sha}" if _uses_gitlab_routes(web_url) else f"/compare/{from_sha}{separator}{to_sha}"
+    return f"{web_url}{path}"
+
+
+def _uses_gitlab_routes(web_url: str) -> bool:
+    host = urlparse(web_url).netloc.lower()
+    return "gitlab" in host or "gitgud.io" in host
+
+
+def _clean_path(path: str) -> str:
+    cleaned = path.strip().rstrip("/")
+    if cleaned.endswith(".git"):
+        cleaned = cleaned[:-4]
+    return f"{cleaned}.git"
+
+
+def _is_local_path(value: str) -> bool:
+    return (
+        value.startswith(("/", "./", "../", "~"))
+        or re.match(r"^[A-Za-z]:[\\/]", value) is not None
+    )
+
+
+def _normalize_netloc(parsed) -> str:
+    host = (parsed.hostname or "").lower()
+    if parsed.port:
+        host = f"{host}:{parsed.port}"
+    if parsed.username:
+        userinfo = parsed.username
+        if parsed.password:
+            userinfo = f"{userinfo}:{parsed.password}"
+        return f"{userinfo}@{host}"
+    return host
+
+
+def _safe_key_part(value: str) -> str:
+    safe = re.sub(r"[^A-Za-z0-9._-]+", "-", value).strip(".-")
+    return safe[:48] or "branch"

nonebot_plugin_git_poller/schedule.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+import re
+from typing import Any
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+
+_DAILY_PATTERN = re.compile(r"^每日(\d{1,2}):(\d{2})$")
+_INTERVAL_DAYS_PATTERN = re.compile(r"^每([1-9]\d*)天(\d{1,2}):(\d{2})$")
+_WEEKLY_PATTERN = re.compile(r"^周([一二三四五六日天])(\d{1,2}):(\d{2})$")
+_INTERVAL_ANCHOR_ORDINAL = date(1970, 1, 1).toordinal()
+_MAX_INTERVAL_DAYS = 30
+_WEEKDAY_MAP = {
+    "一": "mon",
+    "二": "tue",
+    "三": "wed",
+    "四": "thu",
+    "五": "fri",
+    "六": "sat",
+    "日": "sun",
+    "天": "sun",
+}
+_WEEKDAY_NAME_MAP = {
+    "一": "一",
+    "二": "二",
+    "三": "三",
+    "四": "四",
+    "五": "五",
+    "六": "六",
+    "日": "日",
+    "天": "日",
+}
+
+
+@dataclass(frozen=True)
+class ScheduleSpec:
+    raw: str
+    trigger: str
+    trigger_kwargs: dict[str, Any]
+    description: str
+
+
+def parse_schedule(value: str, timezone_name: str = "Asia/Shanghai") -> ScheduleSpec | None:
+    raw = value.strip()
+    if not raw:
+        return None
+
+    timezone = _parse_timezone(timezone_name)
+    daily = _DAILY_PATTERN.fullmatch(raw)
+    if daily:
+        hour, minute = _parse_time(daily.group(1), daily.group(2))
+        return ScheduleSpec(
+            raw=raw,
+            trigger="cron",
+            trigger_kwargs={"hour": hour, "minute": minute, "timezone": timezone},
+            description=f"每日 {_format_time(hour, minute)} ({timezone_name})",
+        )
+
+    interval_days = _INTERVAL_DAYS_PATTERN.fullmatch(raw)
+    if interval_days:
+        days = int(interval_days.group(1))
+        if days > _MAX_INTERVAL_DAYS:
+            raise ValueError(f"间隔天数必须在 1 到 {_MAX_INTERVAL_DAYS} 天之间。")
+        hour, minute = _parse_time(interval_days.group(2), interval_days.group(3))
+        return ScheduleSpec(
+            raw=raw,
+            trigger="interval",
+            trigger_kwargs={
+                "days": days,
+                "start_date": _next_interval_start_date(days, hour, minute, timezone),
+                "timezone": timezone,
+            },
+            description=f"每 {days} 天 {_format_time(hour, minute)} ({timezone_name})",
+        )
+
+    weekly = _WEEKLY_PATTERN.fullmatch(raw)
+    if weekly:
+        weekday_text = weekly.group(1)
+        day_of_week = _WEEKDAY_MAP[weekday_text]
+        hour, minute = _parse_time(weekly.group(2), weekly.group(3))
+        return ScheduleSpec(
+            raw=raw,
+            trigger="cron",
+            trigger_kwargs={
+                "day_of_week": day_of_week,
+                "hour": hour,
+                "minute": minute,
+                "timezone": timezone,
+            },
+            description=(
+                f"周{_WEEKDAY_NAME_MAP[weekday_text]} "
+                f"{_format_time(hour, minute)} ({timezone_name})"
+            ),
+        )
+
+    raise ValueError(
+        "定时格式应为 每日hh:mm、每x天hh:mm 或 周xhh:mm，"
+        f"天数 x 使用 1 到 {_MAX_INTERVAL_DAYS} 的整数，"
+        "周 x 使用一二三四五六日/天。"
+    )
+
+
+def _parse_time(hour_text: str, minute_text: str) -> tuple[int, int]:
+    hour = int(hour_text)
+    minute = int(minute_text)
+    if hour > 23 or minute > 59:
+        raise ValueError("定时时间必须在 00:00 到 23:59 之间。")
+    return hour, minute
+
+
+def _parse_timezone(value: str) -> ZoneInfo:
+    try:
+        return ZoneInfo(value)
+    except ZoneInfoNotFoundError as exc:
+        raise ValueError(f"无效时区：{value!r}") from exc
+
+
+def _format_time(hour: int, minute: int) -> str:
+    return f"{hour:02d}:{minute:02d}"
+
+
+def _next_interval_start_date(
+    days: int,
+    hour: int,
+    minute: int,
+    timezone: ZoneInfo,
+) -> datetime:
+    now = datetime.now(timezone)
+    candidate = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+    if candidate <= now:
+        candidate += timedelta(days=1)
+    offset = (candidate.date().toordinal() - _INTERVAL_ANCHOR_ORDINAL) % days
+    if offset:
+        candidate += timedelta(days=days - offset)
+    return candidate

nonebot_plugin_git_poller/state.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from nonebot import logger
+from nonebot_plugin_localstore import get_plugin_data_dir
+
+from .models import Subscription
+
+
+class StateStore:
+    def __init__(self) -> None:
+        self.data_dir = get_plugin_data_dir()
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        self.state_path = self.data_dir / "state.json"
+
+    def read_state(self) -> dict[str, Any]:
+        if not self.state_path.exists():
+            logger.debug(f"git poller state file does not exist yet: {self.state_path}")
+            return {"groups": {}}
+        logger.debug(f"git poller reading state file: {self.state_path}")
+        data = json.loads(self.state_path.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return {"groups": {}}
+        if not isinstance(data.get("groups"), dict):
+            data["groups"] = {}
+        return data
+
+    def write_state(self, state: dict[str, Any]) -> None:
+        if not isinstance(state.get("groups"), dict):
+            state["groups"] = {}
+        self._write_json(self.state_path, state)
+
+    def get_subscription(self, group_id: int, repo_key: str) -> Subscription | None:
+        raw = self._repo_entry(group_id, repo_key)
+        if raw is None:
+            return None
+        return Subscription.from_json(raw)
+
+    def list_group_subscriptions(self, group_id: int) -> dict[str, Subscription]:
+        state = self.read_state()
+        repos = self._repos_from_state(state, group_id)
+        result: dict[str, Subscription] = {}
+        for repo_key, raw in repos.items():
+            if isinstance(raw, dict):
+                try:
+                    result[str(repo_key)] = Subscription.from_json(raw)
+                except (KeyError, TypeError, ValueError):
+                    logger.warning(
+                        f"git poller skipped invalid subscription for group {group_id}: {repo_key}"
+                    )
+        return result
+
+    def list_all_subscriptions(self) -> dict[int, dict[str, Subscription]]:
+        state = self.read_state()
+        groups = state.get("groups")
+        if not isinstance(groups, dict):
+            return {}
+        result: dict[int, dict[str, Subscription]] = {}
+        for group_id_text in groups:
+            try:
+                group_id = int(group_id_text)
+            except (TypeError, ValueError):
+                continue
+            subscriptions = self.list_group_subscriptions(group_id)
+            if subscriptions:
+                result[group_id] = subscriptions
+        return result
+
+    def upsert_subscription(
+        self,
+        group_id: int,
+        repo_key: str,
+        subscription: Subscription,
+    ) -> None:
+        state = self.read_state()
+        repos = self._ensure_repos(state, group_id)
+        repos[repo_key] = subscription.to_json()
+        logger.info(
+            f"git poller subscription saved: group={group_id}, "
+            f"repo={repo_key}, branch={subscription.branch}, enabled={subscription.enabled}"
+        )
+        self.write_state(state)
+
+    def remove_subscription(self, group_id: int, repo_key: str) -> bool:
+        state = self.read_state()
+        repos = self._repos_from_state(state, group_id)
+        if repo_key not in repos:
+            return False
+        del repos[repo_key]
+        logger.info(f"git poller subscription removed: group={group_id}, repo={repo_key}")
+        self.write_state(state)
+        return True
+
+    def update_last_success(
+        self,
+        group_id: int,
+        repo_key: str,
+        sha: str,
+        updated_at: str,
+    ) -> None:
+        subscription = self.get_subscription(group_id, repo_key)
+        if subscription is None:
+            raise KeyError(f"subscription not found: group={group_id}, repo={repo_key}")
+        subscription.last_success_sha = sha
+        subscription.updated_at = updated_at
+        self.upsert_subscription(group_id, repo_key, subscription)
+        logger.info(
+            f"git poller last_success_sha updated: group={group_id}, "
+            f"repo={repo_key}, sha={sha[:8]}"
+        )
+
+    def update_last_archive_path(
+        self,
+        group_id: int,
+        repo_key: str,
+        archive_path: str | None,
+        updated_at: str,
+    ) -> None:
+        subscription = self.get_subscription(group_id, repo_key)
+        if subscription is None:
+            raise KeyError(f"subscription not found: group={group_id}, repo={repo_key}")
+        subscription.last_archive_path = archive_path
+        subscription.updated_at = updated_at
+        self.upsert_subscription(group_id, repo_key, subscription)
+        logger.info(
+            f"git poller last archive path updated: group={group_id}, "
+            f"repo={repo_key}, has_archive={archive_path is not None}"
+        )
+
+    def update_schedule(
+        self,
+        group_id: int,
+        repo_key: str,
+        schedule: str,
+        updated_at: str,
+    ) -> Subscription:
+        subscription = self.get_subscription(group_id, repo_key)
+        if subscription is None:
+            raise KeyError(f"subscription not found: group={group_id}, repo={repo_key}")
+        subscription.schedule = schedule
+        subscription.updated_at = updated_at
+        self.upsert_subscription(group_id, repo_key, subscription)
+        logger.info(
+            f"git poller schedule updated: group={group_id}, repo={repo_key}, schedule={schedule}"
+        )
+        return subscription
+
+    def update_archive_password(
+        self,
+        group_id: int,
+        repo_key: str,
+        password: str | None,
+        updated_at: str,
+    ) -> Subscription:
+        subscription = self.get_subscription(group_id, repo_key)
+        if subscription is None:
+            raise KeyError(f"subscription not found: group={group_id}, repo={repo_key}")
+        subscription.archive_password = password
+        subscription.updated_at = updated_at
+        self.upsert_subscription(group_id, repo_key, subscription)
+        logger.info(
+            f"git poller archive password updated: group={group_id}, "
+            f"repo={repo_key}, has_password={password is not None}"
+        )
+        return subscription
+
+    def subscriptions_for_schedule(
+        self,
+        schedule: str,
+    ) -> list[tuple[int, str, Subscription]]:
+        target = schedule.strip()
+        result: list[tuple[int, str, Subscription]] = []
+        for group_id, subscriptions in self.list_all_subscriptions().items():
+            for repo_key, subscription in subscriptions.items():
+                if subscription.enabled and subscription.schedule.strip() == target:
+                    result.append((group_id, repo_key, subscription))
+        return result
+
+    def is_repo_key_subscribed(self, repo_key: str) -> bool:
+        for subscriptions in self.list_all_subscriptions().values():
+            if repo_key in subscriptions:
+                return True
+        return False
+
+    def _repo_entry(self, group_id: int, repo_key: str) -> dict[str, Any] | None:
+        repos = self._repos_from_state(self.read_state(), group_id)
+        raw = repos.get(repo_key)
+        return raw if isinstance(raw, dict) else None
+
+    @staticmethod
+    def _repos_from_state(state: dict[str, Any], group_id: int) -> dict[str, Any]:
+        groups = state.get("groups")
+        if not isinstance(groups, dict):
+            return {}
+        group_state = groups.get(str(int(group_id)))
+        if not isinstance(group_state, dict):
+            return {}
+        repos = group_state.get("repos")
+        return repos if isinstance(repos, dict) else {}
+
+    @staticmethod
+    def _ensure_repos(state: dict[str, Any], group_id: int) -> dict[str, Any]:
+        groups = state.get("groups")
+        if not isinstance(groups, dict):
+            groups = {}
+            state["groups"] = groups
+        group_text = str(int(group_id))
+        group_state = groups.get(group_text)
+        if not isinstance(group_state, dict):
+            group_state = {}
+            groups[group_text] = group_state
+        repos = group_state.get("repos")
+        if not isinstance(repos, dict):
+            repos = {}
+            group_state["repos"] = repos
+        return repos
+
+    @staticmethod
+    def _write_json(path: Path, data: dict[str, Any]) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = path.with_suffix(f"{path.suffix}.tmp")
+        tmp_path.write_text(
+            json.dumps(data, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+        tmp_path.replace(path)

nonebot_plugin_git_poller-0.1.5.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.3
+Name: nonebot-plugin-git-poller
+Version: 0.1.5
+Summary: 按群订阅 Git 仓库更新的 NoneBot2 插件，支持多仓库、多分支定时拉取
+Author: kusadact
+License: MIT
+Requires-Dist: nonebot2>=2.0.0
+Requires-Dist: nonebot-adapter-onebot>=2.1.3
+Requires-Dist: nonebot-plugin-apscheduler>=0.5.0
+Requires-Dist: nonebot-plugin-localstore>=0.6.0
+Requires-Dist: dulwich>=1.2.6
+Requires-Dist: py7zr>=1.1.0
+Requires-Dist: urllib3>=2.0.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <a href="https://v2.nonebot.dev/store">
+    <img src="https://raw.githubusercontent.com/fllesser/nonebot-plugin-template/refs/heads/resource/.docs/NoneBotPlugin.svg" width="310" alt="logo">
+  </a>
+
+## nonebot-plugin-git-poller
+
+[![LICENSE](https://img.shields.io/github/license/kusadact/nonebot-plugin-git-poller.svg)](./LICENSE)
+[![pypi](https://img.shields.io/pypi/v/nonebot-plugin-git-poller.svg)](https://pypi.org/project/nonebot-plugin-git-poller/)
+[![python](https://img.shields.io/badge/python-3.10|3.11|3.12|3.13-blue.svg)](https://www.python.org)
+[![uv](https://img.shields.io/badge/package%20manager-uv-black?style=flat-square&logo=uv)](https://github.com/astral-sh/uv)
+[![codecov](https://codecov.io/gh/kusadact/nonebot-plugin-git-poller/graph/badge.svg)](https://codecov.io/gh/kusadact/nonebot-plugin-git-poller)
+
+</div>
+
+按群订阅 Git 仓库更新的 NoneBot2 插件，支持多仓库、多分支定时拉取，自动推送 commit 更新摘要并上传源码压缩包。
+
+## 安装
+
+在 NoneBot 项目目录中安装插件：
+
+```bash
+uv add nonebot-plugin-git-poller
+```
+
+在 `pyproject.toml` 中加载插件：
+
+```toml
+[tool.nonebot]
+plugins = ["nonebot_plugin_git_poller"]
+```
+
+## 配置
+
+| 配置项 | 必填 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| `git_poller_default_schedule` | 否 | `每日04:00` | 新关注仓库的默认定时规则；留空关闭默认定时注册。 |
+| `git_poller_timezone` | 否 | `Asia/Shanghai` | 定时任务时区。 |
+| `git_poller_proxy` | 否 | 空 | HTTP/HTTPS Git 拉取代理。 |
+| `git_poller_timeout` | 否 | `60.0` | HTTP/HTTPS Git 拉取超时，单位秒。 |
+| `git_poller_archive_password` | 否 | 空 | 全局默认压缩包密码；为空时默认不设置密码。 |
+| `git_poller_file_base_url` | 条件 | 空 | 上传压缩包时使用的 NoneBot HTTP 服务根地址；Bot 和 OneBot/NapCat 不在同一个文件系统时必须配置，例如 http://nonebot:8088。 |
+
+## 指令
+
+```text
+/关注仓库 仓库url [--分支名]
+/取关仓库 仓库url [--分支名]
+/设置仓库 仓库url [--分支名]
+/拉取仓库 仓库url [--分支名]
+/仓库摘要 仓库url [--分支名]
+/仓库列表
+```
+
+带 URL 的命令都支持可选分支后缀，例如 `/关注仓库 https://example.test/repo.git --dev`。`/关注仓库` 不写分支时追踪远端默认分支；其他命令不写分支时优先使用本群本仓库的唯一订阅，若同仓库关注了多个分支则需要写 `--分支名`。
+
+`/关注仓库` 在当前群关注仓库。同一个群可以关注同一仓库的不同分支。
+
+`/取关仓库` 移除当前群的对应仓库分支订阅，不影响其他群。
+
+`/设置仓库` 进入设置流程。Bot 会回复：
+
+```text
+输入设置数字选项
+1. 修改当前仓库推送抓取时间
+2. 修改当前仓库上传压缩包密码（选择后输入无则清除当前仓库密码回到全局默认）
+```
+
+回复 `1` 后，下一条消息必须是合法定时格式。回复 `2` 后，下一条消息会保存为当前仓库压缩包密码，此时输入 `无` 会清除当前仓库密码并回到全局默认。输入非法会取消。
+
+`/仓库列表` 显示当前群关注的仓库、分支、定时、启用状态、`last_success_sha` 和压缩包密码来源。
+
+`/拉取仓库` 立即拉取当前群已关注的仓库，上传最新的源码压缩包。
+
+`/仓库摘要` 仅拉取远端并展示本群记录与远端 HEAD 的差异。
+
+## 定时格式
+
+支持：
+
+```text
+每日hh:mm
+每x天hh:mm
+周xhh:mm
+```
+
+`每x天` 的 `x` 使用 1 到 30 的整数；`周x` 只支持汉字 `一二三四五六日/天`

nonebot_plugin_git_poller-0.1.5.dist-info/RECORD

@@ -0,0 +1,15 @@
+nonebot_plugin_git_poller/__init__.py,sha256=8g-r4aoCHIPSrDNxlm3VzBXDYRyeWrqSMEnyKsnV-v0,16084
+nonebot_plugin_git_poller/archive.py,sha256=SgpvaQLrQ5_hp3oMd2EFIPQIT0nFUTsMUumRpzzb9uU,4805
+nonebot_plugin_git_poller/command_args.py,sha256=kpnrbeYgTRN_CHiaBmatAhiuaR-fe0c9clcH4_3zER0,751
+nonebot_plugin_git_poller/config.py,sha256=XxysFYtRcizMvhzrHw1HHSNnRXIL054xOzG0zNe-sX0,481
+nonebot_plugin_git_poller/file_server.py,sha256=JGDviyQHS4DubKAneLq3sEtC458XAoum6nGhHkJwi0E,4147
+nonebot_plugin_git_poller/git.py,sha256=auUD3vFkYhdWP8vBiLB8LD42dA7x1b1DlBEYfc8xAVk,14478
+nonebot_plugin_git_poller/message.py,sha256=N4T5qWXhjp_wRRFi5McQztyp3iufzhRzhcjBLusj4ZU,4496
+nonebot_plugin_git_poller/mirror.py,sha256=S6My7VzrFIz5ga41AO7TxCfJOR4PnfUneyp2v93HHMo,17600
+nonebot_plugin_git_poller/models.py,sha256=MZRmAtL8rgYSEMvmc-iNERR08ojqTaGDUgku7_bPo9E,4614
+nonebot_plugin_git_poller/repository.py,sha256=Jz4aezH9sG3Pe0L_mVI82m4AVvuLUqcs0qG-uz7CRU0,5071
+nonebot_plugin_git_poller/schedule.py,sha256=AyiwWixnIKSH1FcC2RouizHANLc4amKRXdhb8yvlsEQ,4145
+nonebot_plugin_git_poller/state.py,sha256=MOgtLicOjv42YxAEqLirCzR6yiyTWXXQR41quEFsoXU,8591
+nonebot_plugin_git_poller-0.1.5.dist-info/WHEEL,sha256=s_zqWxHFEH8b58BCtf46hFCqPaISurdB9R1XJ8za6XI,80
+nonebot_plugin_git_poller-0.1.5.dist-info/METADATA,sha256=wjoNAgjPWzKcpM6WkYr7OoajWz7hj-99Vk4aIPiAsBI,4169
+nonebot_plugin_git_poller-0.1.5.dist-info/RECORD,,

nonebot_plugin_git_poller-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.6
+Root-Is-Purelib: true
+Tag: py3-none-any