fix some lint error and add ty to recommandation extensions

Author: RhenCloud

.vscode/extensions.json

@@ -5,6 +5,7 @@
         "yzhang.markdown-all-in-one",
         // "astral-sh.ty",
         "ms-python.python",
-        "redhat.vscode-yaml"
+        "redhat.vscode-yaml",
+        "astral-sh.ty"
     ]
-}
+}

drivers/feishu.py

@@ -27,34 +27,34 @@
 # Rule channel keys:
 #   chat_id – Feishu open chat ID, e.g. "oc_xxxxxxxxxxxxxxxxxx"
 
-from drivers.registry import register
 import asyncio
 import io
 import json
 import logging
 import re
 import threading
 
-from fastapi import FastAPI, Request, Response
 import lark_oapi as lark
+from fastapi import FastAPI, Request, Response
 from lark_oapi.api.contact.v3 import GetUserRequest
 from lark_oapi.api.im.v1 import (
-    CreateMessageRequest,
-    CreateMessageRequestBody,
-    CreateImageRequest,
-    CreateImageRequestBody,
     CreateFileRequest,
     CreateFileRequestBody,
+    CreateImageRequest,
+    CreateImageRequestBody,
+    CreateMessageRequest,
+    CreateMessageRequestBody,
     GetMessageResourceRequest,
     ReplyMessageRequest,
     ReplyMessageRequestBody,
 )
 
 import services.logger as log
-import services.media as media
-from services.message import Attachment, NormalizedMessage
-from services.config_schema import _DriverConfig
 from drivers import BaseDriver
+from drivers.registry import register
+from services import media
+from services.config_schema import _DriverConfig
+from services.message import Attachment, NormalizedMessage
 
 
 class FeishuConfig(_DriverConfig):
@@ -202,18 +202,18 @@ async def _start_http_server(self) -> None:
     async def _handle_http(self, request: Request) -> Response:
         assert self._handler is not None  # Type narrowing - handler is set in start()
         handler = self._handler
-        body = await request.read()
+        body = await request.body()
         # Create RawRequest with correct parameter names for lark-oapi
         raw_req = lark.RawRequest()
-        raw_req.uri = request.path
+        raw_req.uri = request.url.path
         raw_req.headers = dict(request.headers)
         raw_req.body = body
 
         # lark-oapi's do() is synchronous; run in thread pool to avoid blocking
         loop = asyncio.get_running_loop()
         resp = await loop.run_in_executor(None, lambda: handler.do(raw_req))
         return Response(
-            body=resp.content,
+            content=resp.content,
             status_code=resp.status_code or 200,
             media_type=getattr(resp, "content_type", "application/json")
             or "application/json",

drivers/googlechat.py

@@ -25,29 +25,28 @@
 #
 # * Exactly one of service_account_file or service_account_json is required.
 
-from drivers.registry import register
 import asyncio
 import json
 from pathlib import Path
 
 import aiohttp
+import google.auth.transport.requests as _ga_req
+import google.oauth2.service_account as _sa
+import requests
 from aiohttp_socks import ProxyConnector
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse, PlainTextResponse
 from pydantic import model_validator
-import requests
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
-import google.oauth2.service_account as _sa
-import google.auth.transport.requests as _ga_req
-
 import services.logger as log
-import services.media as media
-from services.message import Attachment, NormalizedMessage
-from services.config_schema import _DriverConfig
-from services.config import get_proxy, UNSET
 from drivers import BaseDriver
+from drivers.registry import register
+from services import media
+from services.config import UNSET, get_proxy
+from services.config_schema import _DriverConfig
+from services.message import Attachment, NormalizedMessage
 
 
 class GoogleChatConfig(_DriverConfig):
@@ -199,7 +198,7 @@ async def _handle_event(self, request: Request) -> JSONResponse | PlainTextRespo
                 return PlainTextResponse("Invalid token", status_code=403)
 
         try:
-            body = await request.read()
+            body = await request.body()
             event = json.loads(body)
         except Exception:
             return PlainTextResponse("Bad JSON", status_code=400)

drivers/kook.py

@@ -14,22 +14,21 @@
 # Rule channel keys:
 #   channel_id – KOOK text channel ID
 
-from drivers.registry import register
 import io
 import re
 
 import khl
+from aiohttp import ClientSession
+from aiohttp_socks import ProxyConnector
 
 import services.logger as log
-import services.media as media
-from services.message import Attachment, NormalizedMessage
+from drivers import BaseDriver
+from drivers.registry import register
+from services import media
+from services.config import UNSET, get_proxy
 from services.config_schema import _DriverConfig
-from services.config import get_proxy, UNSET
 from services.db import msg_db
-from drivers import BaseDriver
-
-from aiohttp import ClientSession
-from aiohttp_socks import ProxyConnector
+from services.message import Attachment, NormalizedMessage
 
 
 class KookConfig(_DriverConfig):
@@ -61,19 +60,8 @@ async def start(self):
             logger.debug(f"Kook [{self.instance_id}] using proxy {self._proxy}")
 
             requester = self._bot.client.gate.requester
-            original_request = requester.request
-            proxy_url = self._proxy
-
-            async def proxied_request(method: str, route: str, **params):
-                # inject connector on 1st request
-                if requester._cs is not None and requester._cs.connector is None:
-                    connector = ProxyConnector.from_url(proxy_url, rdns=True)
-                    sess = ClientSession(connector=connector)
-                    requester._cs = sess
-
-                return await original_request(method, route, **params)
-
-            requester.request = proxied_request
+            connector = ProxyConnector.from_url(self._proxy, rdns=True)
+            requester._cs = ClientSession(connector=connector)
 
         # Register our handler alongside khl's internal command-manager handler.
         # khl's Client dispatches to all registered handlers for a given type.

drivers/matrix.py

@@ -18,9 +18,15 @@
 # Rule channel keys:
 #   room_id – Matrix room ID, e.g. "!abc123:matrix.org"
 
-from drivers.registry import register
+from pathlib import Path
+from typing import cast
+
+from aiohttp import ClientSession, TCPConnector
+from aiohttp_socks import ProxyConnector
+from mautrix.api import HTTPAPI
 from mautrix.client import Client
 from mautrix.client.syncer import EventHandler
+from mautrix.crypto import OlmMachine
 from mautrix.types import (
     AudioInfo,
     ContentURI,
@@ -38,21 +44,15 @@
     UserID,
     VideoInfo,
 )
-from mautrix.api import HTTPAPI
-from mautrix.crypto import OlmMachine
-from typing import cast
-from aiohttp import ClientSession, TCPConnector
-from aiohttp_socks import ProxyConnector
-from pathlib import Path
-
 from pydantic import model_validator
 
 import services.logger as log
-import services.media as media
-from services.message import Attachment, NormalizedMessage
-from services.config_schema import _DriverConfig
-from services.config import get_proxy, UNSET
 from drivers import BaseDriver
+from drivers.registry import register
+from services import media
+from services.config import UNSET, get_proxy
+from services.config_schema import _DriverConfig
+from services.message import Attachment, NormalizedMessage
 
 
 class MatrixConfig(_DriverConfig):
@@ -152,9 +152,10 @@ async def start(self):
         if self.config.enable_e2e:
             try:
                 from contextlib import asynccontextmanager
+
+                from mautrix.client.state_store import MemoryStateStore
                 from mautrix.crypto import StateStore
                 from mautrix.crypto.store import MemoryCryptoStore
-                from mautrix.client.state_store import MemoryStateStore
 
                 # Create a custom CryptoStore that overrides the transaction() method
                 class CustomCryptoStore(MemoryCryptoStore):
@@ -283,13 +284,13 @@ async def _get_profile(self, user_id: str) -> tuple[str, str]:
             name = await self._client.get_displayname(UserID(user_id))
             if name:
                 display_name = name
-        except Exception:
+        except Exception:  # noqa: S110
             pass
         try:
             mxc = await self._client.get_avatar_url(UserID(user_id))
             if mxc:
                 avatar_url = self._mxc_to_http(str(mxc))
-        except Exception:
+        except Exception:  # noqa: S110
             pass
         return display_name, avatar_url
 
@@ -311,21 +312,27 @@ async def _on_encrypted_message(self, event) -> None:
 
             # Convert to a regular MessageEvent and process
             if decrypted_event:
-                # Create a mock MessageEvent with the decrypted content
-                from mautrix.types import MessageEvent, RoomID, UserID
-
-                # Create a new event with decrypted content
-                decrypted_msg_event = MessageEvent(
-                    content=decrypted_event,
-                    type=EventType.ROOM_MESSAGE,
-                    room_id=RoomID(event.room_id),
-                    event_id=event.event_id,
-                    sender=UserID(event.sender),
-                    timestamp=event.timestamp,
-                )
-
-                # Process the decrypted message
-                await self._on_message(decrypted_msg_event)
+                # Create a mock MessageEvent with the decrypted message content.
+                decrypted_content = getattr(decrypted_event, "content", None)
+                if isinstance(
+                    decrypted_content,
+                    (TextMessageEventContent, MediaMessageEventContent),
+                ):
+                    from mautrix.types import MessageEvent, RoomID, UserID
+
+                    decrypted_msg_event = MessageEvent(
+                        content=decrypted_content,
+                        type=EventType.ROOM_MESSAGE,
+                        room_id=RoomID(event.room_id),
+                        event_id=event.event_id,
+                        sender=UserID(event.sender),
+                        timestamp=event.timestamp,
+                    )
+                    await self._on_message(decrypted_msg_event)
+                else:
+                    logger.warning(
+                        f"Matrix [{self.instance_id}] unsupported decrypted content type"
+                    )
             else:
                 logger.warning(f"Matrix [{self.instance_id}] Failed to decrypt event")
         except Exception as e:

drivers/slack.py

@@ -23,32 +23,30 @@
 #   channel_id – Slack channel ID, e.g. "C1234567890"
 #                (ignored when send_method="webhook"; channel is fixed by the webhook URL)
 
-from drivers.registry import register
 import asyncio
 import hashlib
 import hmac as _hmac
 import json
 import time
+from typing import Literal
 
 import aiohttp
 from aiohttp_socks import ProxyConnector
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse, PlainTextResponse
-
 from slack_sdk.socket_mode.aiohttp import SocketModeClient
 from slack_sdk.socket_mode.async_client import AsyncBaseSocketModeClient
 from slack_sdk.socket_mode.request import SocketModeRequest
 from slack_sdk.socket_mode.response import SocketModeResponse
 from slack_sdk.web.async_client import AsyncWebClient
 
-from typing import Literal
-
 import services.logger as log
-import services.media as media
-from services.message import Attachment, NormalizedMessage
-from services.config_schema import _DriverConfig
-from services.config import get_proxy, UNSET
 from drivers import BaseDriver
+from drivers.registry import register
+from services import media
+from services.config import UNSET, get_proxy
+from services.config_schema import _DriverConfig
+from services.message import Attachment, NormalizedMessage
 
 
 class SlackConfig(_DriverConfig):
@@ -206,7 +204,7 @@ async def _on_request(
     async def _handle_events_api(
         self, request: Request
     ) -> JSONResponse | PlainTextResponse:
-        body = await request.read()
+        body = await request.body()
 
         if self.config.signing_secret and not _verify_slack_signature(
             self.config.signing_secret, request.headers, body
@@ -430,8 +428,10 @@ def _post_kwargs(msg_text: str) -> dict:
                         mid = resp.get("ts")
                         if not first_msg_id:
                             first_msg_id = str(mid)
-                except Exception:
-                    pass
+                except Exception as e:
+                    logger.warning(
+                        f"Slack [{self.instance_id}] failed to send attachment label: {e}"
+                    )
                 continue
 
             data_bytes, mime = result

drivers/teams.py

@@ -18,7 +18,6 @@
 #                     (e.g. "https://smba.trafficmanager.net/amer/")
 #   conversation_id – Value of activity.conversation.id
 
-from drivers.registry import register
 import asyncio
 import json
 import time
@@ -29,11 +28,12 @@
 from fastapi.responses import PlainTextResponse
 
 import services.logger as log
-import services.media as media
-from services.message import Attachment, NormalizedMessage
-from services.config_schema import _DriverConfig
-from services.config import get_proxy, UNSET
 from drivers import BaseDriver
+from drivers.registry import register
+from services import media
+from services.config import UNSET, get_proxy
+from services.config_schema import _DriverConfig
+from services.message import Attachment, NormalizedMessage
 
 
 class TeamsConfig(_DriverConfig):
@@ -125,7 +125,7 @@ async def _get_token(self) -> str:
 
     async def _handle_activity(self, request: Request) -> PlainTextResponse:
         try:
-            body = await request.read()
+            body = await request.body()
             activity = json.loads(body)
         except Exception:
             return PlainTextResponse("Bad JSON", status_code=400)