refactor: PartialInviteCodeをInviteCodeに統合

mipac/actions/admins/invite.py

@@ -4,8 +4,8 @@ from typing import TYPE_CHECKING, AsyncGenerator, Literal
 
 from mipac.abstract.action import AbstractAction
 from mipac.http import HTTPClient, Route
-from mipac.models.invite import InviteCode, PartialInviteCode
-from mipac.types.invite import IInviteCode, IPartialInviteCode
+from mipac.models.invite import InviteCode
+from mipac.types.invite import IInviteCode
 from mipac.utils.format import remove_dict_empty
 from mipac.utils.pagination import Pagination
 
@@ -20,13 +20,13 @@ class AdminInviteActions(AbstractAction):
 
     async def create_invite(
         self, count: int = 1, expires_at: str | None = None
-    ) -> list[PartialInviteCode]:
-        raw_codes: list[IPartialInviteCode] = await self.__session.request(
+    ) -> list[InviteCode]:
+        raw_codes: list[IInviteCode] = await self.__session.request(
             route=Route(method="POST", path="/api/admin/invite/create"),
             json={"count": count, "expiresAt": expires_at},
             auth=True,
         )
-        return [PartialInviteCode(raw_code, client=self.__client) for raw_code in raw_codes]
+        return [InviteCode(raw_code, client=self.__client) for raw_code in raw_codes]
 
     async def get_invite_list(
         self,

mipac/models/invite.py

@@ -1,78 +1,69 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import TYPE_CHECKING, Generic, TypeVar
+from typing import TYPE_CHECKING
 
-from mipac.abstract.model import AbstractModel
 from mipac.models.lite.user import PartialUser
-from mipac.types.invite import IInviteCode, IPartialInviteCode
+from mipac.types.invite import IInviteCode
 from mipac.utils.format import str_to_datetime
 
 if TYPE_CHECKING:
     from mipac.manager.client import ClientManager
 
 
-T = TypeVar("T", bound=IPartialInviteCode)
-
-
-class PartialInviteCode(Generic[T], AbstractModel):
-    def __init__(self, raw_invite_code: T, *, client: ClientManager) -> None:
-        self._raw_invite_code: T = raw_invite_code
-        self._client = client
-
-    @property
-    def code(self) -> str:
-        return self._raw_invite_code["code"]
-
-
-class InviteCode(PartialInviteCode[IInviteCode]):
+class InviteCode:
     def __init__(self, raw_invite_code: IInviteCode, *, client: ClientManager) -> None:
-        super().__init__(raw_invite_code=raw_invite_code, client=client)
+        self.__raw_invite_code: IInviteCode = raw_invite_code
+        self.__client = client
 
     @property
     def id(self) -> str:
-        return self._raw_invite_code["id"]
+        return self.__raw_invite_code["id"]
+
+    @property
+    def code(self) -> str:
+        return self.__raw_invite_code["code"]
 
     @property
     def expires_at(self) -> datetime | None:
         return (
-            str_to_datetime(self._raw_invite_code["expires_at"])
-            if self._raw_invite_code["expires_at"]
+            str_to_datetime(self.__raw_invite_code["expires_at"])
+            if self.__raw_invite_code["expires_at"]
             else None
         )
 
     @property
     def created_at(self) -> datetime | None:
         return (
-            str_to_datetime(self._raw_invite_code["created_at"])
-            if self._raw_invite_code["created_at"]
+            str_to_datetime(self.__raw_invite_code["created_at"])
+            if self.__raw_invite_code["created_at"]
             else None
         )
 
     @property
     def created_by(self) -> PartialUser | None:
         return (
-            PartialUser(self._raw_invite_code["created_by"], client=self._client)
-            if self._raw_invite_code["created_by"]
+            PartialUser(self.__raw_invite_code["created_by"], client=self.__client)
+            if self.__raw_invite_code["created_by"]
             else None
         )
 
     @property
     def used_by(self) -> PartialUser | None:
         return (
-            PartialUser(self._raw_invite_code["used_by"], client=self._client)
-            if self._raw_invite_code["used_by"]
+            PartialUser(self.__raw_invite_code["used_by"], client=self.__client)
+            if self.__raw_invite_code["used_by"]
             else None
         )
 
     @property
     def used_at(self) -> datetime | None:
         return (
-            str_to_datetime(self._raw_invite_code["used_at"])
-            if self._raw_invite_code["used_at"]
+            str_to_datetime(self.__raw_invite_code["used_at"])
+            if self.__raw_invite_code["used_at"]
             else None
         )
 
     @property
     def used(self) -> bool:
-        return self._raw_invite_code["used"]
+        return self.__raw_invite_code["used"]

mipac/types/invite.py

@@ -3,12 +3,9 @@ from typing import TypedDict
 from mipac.types.user import IPartialUser
 
 
-class IPartialInviteCode(TypedDict):
-    code: str
-
-
-class IInviteCode(IPartialInviteCode):
+class IInviteCode(TypedDict):
     id: str
+    code: str
     expires_at: str | None
     created_at: str
     created_by: IPartialUser | None