✨ upgrade to newer githubkit

Author: yanyongyu

README.md

@@ -132,3 +132,11 @@ async with bot.as_installation(installation_id=1):
 ```python
 github = bot.github
 ```
+
+## 开发
+
+生成事件列表：
+
+```bash
+python -m codegen && ruff check --fix -e . && isort . && black .
+```

codegen/__init__.py

@@ -1,12 +1,14 @@
+import shutil
 import inspect
 from pathlib import Path
 from itertools import chain
+from typing import Union, cast
 from dataclasses import dataclass
-from typing import Dict, List, Union, get_args, get_origin
+from typing_extensions import get_args, get_origin
 
+from githubkit import GitHubModel
 from jinja2 import Environment, PackageLoader
-from githubkit.webhooks.models import GitHubWebhookModel
-from githubkit.webhooks.types import webhook_action_types
+from githubkit.versions.latest.webhooks import webhook_action_types
 
 MESSAGE_EVENTS = {
     "CommitCommentCreated",
@@ -26,8 +28,9 @@
 
 @dataclass
 class Data:
+    action: str | None
     class_name: str
-    payload_type: str
+    payload_types: list[str]
 
 
 def pascal_case(*names: str) -> str:
@@ -36,43 +39,72 @@ def pascal_case(*names: str) -> str:
 
 
 def build_event():
-    imports: List[str] = []
-    events: List[Data] = []
-    event_types: Dict[str, Union[str, Dict[str, str]]] = {}
+    event_types: dict[str, list[Data]] = {}
     for event, types in webhook_action_types.items():
+        # event has no sub action
         if not isinstance(types, dict):
-            imports.append(f"{types.__name__} as {types.__name__}Payload")
-            events.append(Data(types.__name__, f"{types.__name__}Payload"))
-            event_types[event] = types.__name__
+            types = cast(type[GitHubModel], types)
+            event_types[event] = [
+                Data(
+                    None,
+                    types.__name__.removeprefix("Webhook"),
+                    [types.__name__],
+                )
+            ]
             continue
 
-        action_types: Dict[str, str] = {}
+        action_types: list[Data] = []
         event_types[event] = action_types
-        for action, type in types.items():
-            if inspect.isclass(type) and issubclass(type, GitHubWebhookModel):
-                imports.append(f"{type.__name__} as {type.__name__}Payload")
-                events.append(Data(type.__name__, f"{type.__name__}Payload"))
-                action_types[action] = type.__name__
+        for action, model in types.items():
+            # action type is a simple model
+            if inspect.isclass(model) and issubclass(model, GitHubModel):
+                action_types.append(
+                    Data(
+                        action, model.__name__.removeprefix("Webhook"), [model.__name__]
+                    )
+                )
+            # action type is a union of models
             else:
-                assert get_origin(type) is Union
-                imports.extend(model.__name__ for model in get_args(type))
-                events.append(
+                assert get_origin(model) is Union
+                action_types.append(
                     Data(
+                        action,
                         pascal_case(event, action),
-                        "Union["
-                        f"{', '.join(model.__name__ for model in get_args(type))}"
-                        "]",
+                        [model.__name__ for model in get_args(model)],
                     )
                 )
-                action_types[action] = pascal_case(event, action)
+
+    output_dir = Path("./nonebot/adapters/github/event/")
+
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
 
     env = Environment(loader=PackageLoader("codegen"))
+
+    # generate base model
+    template = env.get_template("_base.py.jinja")
+    base_text = template.render()
+    (output_dir / "_base.py").write_text(base_text)
+
+    # generate types
+    template = env.get_template("_types.py.jinja")
+    types_text = template.render(types=event_types)
+    (output_dir / "_types.py").write_text(types_text)
+
+    # generate event models
     template = env.get_template("event.py.jinja")
-    event_text = template.render(
-        imports=imports,
-        events=events,
-        types=event_types,
-        message_events=MESSAGE_EVENTS,
-        has_message_events=HAS_MESSAGE_EVENTS,
-    )
-    Path("./nonebot/adapters/github/event.py").write_text(event_text)
+    for event, actions in event_types.items():
+        event_text = template.render(
+            event=event,
+            actions=actions,
+            message_events=MESSAGE_EVENTS,
+            has_message_events=HAS_MESSAGE_EVENTS,
+        )
+        (output_dir / f"{event}.py").write_text(event_text)
+
+    # generate init file
+    template = env.get_template("__init__.py.jinja")
+    init_text = template.render(types=event_types)
+    (output_dir / "__init__.py").write_text(init_text)

codegen/templates/__init__.py.jinja

@@ -0,0 +1,26 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._base import Event as Event
+    from ._types import events as events
+    {% for event, actions in types.items() %}
+    {% for action in actions %}
+    from .{{ event }} import {{ action.class_name }} as {{ action.class_name }}
+    {% endfor %}
+    {% endfor %}
+else:
+    __lazy_vars__ = {
+        {% for event, actions in types.items() %}
+        ".{{ event }}": (
+            {% for action in actions %}
+            "{{ action.class_name }}",
+            {% endfor %}
+        ),
+        {% endfor %}
+        "._base": (
+            "Event",
+        ),
+        "._types": (
+            "events",
+        )
+    }

codegen/templates/_base.py.jinja

@@ -0,0 +1,63 @@
+from typing import Any, Dict
+from typing_extensions import override
+
+from nonebot.utils import escape_tag
+
+from nonebot.adapters import Event as BaseEvent
+
+from ..message import Message
+from ..utils import get_attr_or_item
+
+
+class Event(BaseEvent):
+    id: str
+    name: str
+    payload: Dict[str, Any]
+
+    to_me: bool = False
+
+    @override
+    def get_type(self) -> str:
+        return "notice"
+
+    @override
+    def get_event_name(self) -> str:
+        return self.name + (
+            f".{action}" if (action := get_attr_or_item(self.payload, "action")) else ""
+        )
+
+    @override
+    def get_event_description(self) -> str:
+        return escape_tag(
+            f"{self.__class__.__name__} {self.id}"
+            + (
+                f" from sender {sender_name}"
+                if (sender := get_attr_or_item(self.payload, "sender"))
+                and (sender_name := get_attr_or_item(sender, "login"))
+                else ""
+            )
+            + (
+                f" in repository {repo_name}"
+                if (repo := get_attr_or_item(self.payload, "repository"))
+                and (repo_name := get_attr_or_item(repo, "full_name"))
+                else ""
+            )
+        )
+
+    @override
+    def get_message(self) -> Message:
+        raise ValueError("Event has no message!")
+
+    @override
+    def get_user_id(self) -> str:
+        if sender := get_attr_or_item(self.payload, "sender"):
+            return sender.login
+        raise ValueError("Event has no context!")
+
+    @override
+    def get_session_id(self) -> str:
+        return self.get_user_id()
+
+    @override
+    def is_tome(self) -> bool:
+        return self.to_me

codegen/templates/_types.py.jinja

@@ -0,0 +1,13 @@
+events = {
+    {% for event, actions in types.items() %}
+    {% if (actions | first).action %}
+    "{{ event }}": {
+        {% for action in actions %}
+        "{{ action.action }}": "{{ action.class_name }}",
+        {% endfor %}
+    },
+    {% else %}
+    "{{ event }}": "{{ (actions | first).class_name }}",
+    {% endif %}
+    {% endfor %}
+}

codegen/templates/event.py.jinja

@@ -1,90 +1,38 @@
-from typing import Any, Dict, Union
+from typing import Union
 from functools import cached_property
+from typing_extensions import override
 
-{% for import_ in imports %}
-from githubkit.webhooks.models import {{ import_ }}
+{% for action in actions %}
+{% for model in action.payload_types %}
+from githubkit.versions.latest.models import {{ model }}
+{% endfor %}
 {% endfor %}
-from nonebot.typing import overrides
-from nonebot.utils import escape_tag
-
-from nonebot.adapters import Event as BaseEvent
-
-from .message import Message
-from .utils import get_attr_or_item
-
-
-class Event(BaseEvent):
-    id: str
-    name: str
-    payload: Dict[str, Any]
-
-    to_me: bool = False
-
-    @overrides(BaseEvent)
-    def get_type(self) -> str:
-        return "notice"
-
-    @overrides(BaseEvent)
-    def get_event_name(self) -> str:
-        return self.name + (
-            f".{action}" if (action := get_attr_or_item(self.payload, "action")) else ""
-        )
-
-    @overrides(BaseEvent)
-    def get_event_description(self) -> str:
-        return escape_tag(
-            f"{self.__class__.__name__} {self.id}"
-            + (
-                f" from sender {sender_name}"
-                if (sender := get_attr_or_item(self.payload, "sender"))
-                and (sender_name := get_attr_or_item(sender, "login"))
-                else ""
-            )
-            + (
-                f" in repository {repo_name}"
-                if (repo := get_attr_or_item(self.payload, "repository"))
-                and (repo_name := get_attr_or_item(repo, "full_name"))
-                else ""
-            )
-        )
-
-    @overrides(BaseEvent)
-    def get_message(self) -> Message:
-        raise ValueError("Event has no message!")
-
-    @overrides(BaseEvent)
-    def get_user_id(self) -> str:
-        if sender := get_attr_or_item(self.payload, "sender"):
-            return sender.login
-        raise ValueError("Event has no context!")
-
-    @overrides(BaseEvent)
-    def get_session_id(self) -> str:
-        return self.get_user_id()
 
-    @overrides(BaseEvent)
-    def is_tome(self) -> bool:
-        return self.to_me
+from ..message import Message
 
+from ._base import Event
 
-{% for event in events %}
+{% for action in actions %}
 
-class {{ event.class_name }}(Event):
-    payload: {{ event.payload_type }}
+class {{ action.class_name }}(Event):
+    {% if action.payload_types | length > 1 %}
+    payload: Union[{{ action.payload_types | join(", ") }}]
+    {% else %}
+    payload: {{ action.payload_types | first }}
+    {% endif %}
 
-    {% if event.class_name in message_events %}
-    @overrides(Event)
+    {% if action.class_name in message_events %}
+    @override
     def get_type(self) -> str:
         return "message"
     {% endif %}
 
-    {% if event.class_name in has_message_events %}
+    {% if action.class_name in has_message_events %}
     @cached_property
     def _message(self):
         return Message(self.payload.comment.body)
 
-
-    @overrides(Event)
+    @override
     def get_message(self):
         return self._message
 
@@ -93,17 +41,3 @@ class {{ event.class_name }}(Event):
 
     {% endif %}
 {% endfor %}
-
-events = {
-    {% for event, types in types.items() %}
-    {% if types is mapping %}
-    "{{ event }}": {
-        {% for action, type in types.items() %}
-        "{{ action }}": {{ type }},
-        {% endfor %}
-    },
-    {% else %}
-    "{{ event }}": {{ types }},
-    {% endif %}
-    {% endfor %}
-}

nonebot/adapters/github/__init__.py

@@ -1,5 +1,22 @@
+from typing import TYPE_CHECKING
+
+from . import lazy_module
+
+lazy_module.apply()
+
+if TYPE_CHECKING:
+    from .event import *  # noqa: F403
+else:
+    from . import event
+
+    def __getattr__(name: str):
+        try:
+            return getattr(event, name)
+        except AttributeError:
+            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 from .bot import Bot as Bot
-from .event import *  # noqa: F403
 from .bot import OAuthBot as OAuthBot
 from .adapter import Adapter as Adapter
 from .bot import GitHubBot as GitHubBot