refactor: ユーザー周りのモデルを改善

mipac/actions/user.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 from aiocache import Cache, cached
 
@@ -127,9 +127,9 @@ class UserActions:
         until_date: int = 0,
         include_my_renotes: bool = True,
         with_files: bool = False,
-        file_type: Optional[List[str]] = None,
+        file_type: Optional[list[str]] = None,
         exclude_nsfw: bool = True,
-    ) -> List[Note]:
+    ) -> list[Note]:
 
         if check_multi_arg(user_id, self.__user):
             raise ParameterError('user_idがありません')

mipac/core/models/user.py

@@ -28,7 +28,50 @@ class RawChannel:
         self.is_following: Optional[bool] = data.get('is_following')
         self.user_id: Optional[str] = data.get('user_id')
 
-__all__ = ('RawUserDetails', 'RawUser')
+
+class RawPinnedNote:
+    def __init__(self, data: IPinnedNote):
+        self.id: Optional[str] = data.get('id')
+        self.created_at: Optional[datetime] = datetime.strptime(
+            data['created_at'], '%Y-%m-%dT%H:%M:%S.%fZ'
+        ) if 'created_at' in data else None
+        self.text: Optional[str] = data.get('text')
+        self.cw: Optional[str] = data.get('cw')
+        self.user_id: Optional[str] = data.get('user_id')
+        self.user: Optional[RawUser] = RawUser(
+            data['user']
+        ) if 'user' in data else None
+        self.reply_id: Optional[str] = data.get('reply_id')
+        self.reply: Optional[dict[str, Any]] = data.get('reply')
+        self.renote: Optional[dict[str, Any]] = data.get('renote')
+        self.via_mobile: bool = data.get('via_mobile', False)
+        self.is_hidden: bool = data.get('is_hidden', False)
+        self.visibility: bool = bool(
+            data['visibility']
+        ) if 'visibility' in data else False  # TODO: これ公開範囲?
+        self.mentions: Optional[list[str]] = data.get('mentions')
+        self.visible_user_ids: Optional[list[str]] = data.get(
+            'visible_user_ids'
+        )
+        self.file_ids: Optional[list[str]] = data.get('file_ids')
+        self.files: list[RawFile] = [
+            RawFile(i) for i in data['files']
+        ] if 'files' in data else []
+        self.tags: Optional[list[str]] = data.get('tags')
+        self.poll: Optional[dict[str, Any]] = data.get('poll')
+        self.channel: Optional[RawChannel] = RawChannel(
+            data['channel']
+        ) if 'channel' in data else None
+        self.local_only: bool = data.get('local_only', False)
+        self.emojis: Optional[list[RawEmoji]] = [
+            RawEmoji(i) for i in data['emojis']
+        ] if 'emojis' in data else None
+        self.reactions: Optional[dict[str, Any]] = data.get('reactions')
+        self.renote_count: Optional[int] = data.get('renote_count')
+        self.replies_count: Optional[int] = data.get('replies_count')
+        self.uri: Optional[str] = data.get('uri')
+        self.url: Optional[str] = data.get('url')
+        self.my_reaction: Optional[dict[str, Any]] = data.get('my_reaction')
 
 
 class RawUserDetails:

mipac/models/user.py

@@ -1,23 +1,18 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, List, Optional, Union
 
-from mipac.core.models.user import RawUser
+from mipac import File
+from mipac.core.models.user import RawChannel, RawPinnedNote, RawUser
 from mipac.models.emoji import Emoji
 from mipac.models.instance import Instance
-from mipac.types.user import (
-    ChannelPayload,
-    FieldContentPayload,
-    PinnedNotePayload,
-    PinnedPagePayload,
-)
+from mipac.types.user import FieldContentPayload, PinnedPagePayload
 
 if TYPE_CHECKING:
     from mipac.actions.user import UserActions
     from mipac.manager.client import ClientActions
 
-
 __all__ = ['User', 'FollowRequest', 'Followee']
 
 
@@ -49,62 +44,163 @@ class FollowRequest:
 
 
 class Channel:
-    def __init__(self, data: ChannelPayload):
-        self.id: Optional[str] = data.get('id')
-        self.created_at: Optional[datetime] = datetime.strptime(
-            data['created_at'], '%Y-%m-%dT%H:%M:%S.%fZ'
-        ) if data.get('created_at') else None
-        self.last_noted_at: Optional[str] = data.get('last_noted_at')
-        self.name: Optional[str] = data.get('name')
-        self.description: Optional[str] = data.get('description')
-        self.banner_url: Optional[str] = data.get('banner_url')
-        self.notes_count: Optional[int] = data.get('notes_count')
-        self.users_count: Optional[int] = data.get('users_count')
-        self.is_following: Optional[bool] = data.get('is_following')
-        self.user_id: Optional[str] = data.get('user_id')
+    def __init__(self, raw_data: RawChannel, *, client: ClientActions):
+        self.__client: ClientActions = client
+        self.__raw_data: RawChannel = raw_data
+
+    @property
+    def id(self) -> str:
+        return self.__raw_data.id
+
+    @property
+    def created_at(self) -> Optional[datetime]:
+        return self.__raw_data.created_at
+
+    @property
+    def last_noted_at(self) -> Optional[str]:
+        return self.__raw_data.last_noted_at
+
+    @property
+    def name(self) -> Optional[str]:
+        return self.__raw_data.name
+
+    @property
+    def description(self) -> Optional[str]:
+        return self.__raw_data.description
+
+    @property
+    def banner_url(self) -> Optional[str]:
+        return self.__raw_data.banner_url
+
+    @property
+    def notes_count(self) -> Optional[int]:
+        return self.__raw_data.notes_count
+
+    @property
+    def users_count(self) -> Optional[int]:
+        return self.__raw_data.users_count
+
+    @property
+    def is_following(self) -> Optional[bool]:
+        return self.__raw_data.is_following
+
+    @property
+    def user_id(self) -> Optional[str]:
+        return self.__raw_data.user_id
 
 
 class PinnedNote:
-    def __init__(self, data: PinnedNotePayload, *, client: ClientActions):
-        self.id: Optional[str] = data.get('id')
-        self.created_at: Optional[datetime] = datetime.strptime(
-            data['created_at'], '%Y-%m-%dT%H:%M:%S.%fZ'
-        ) if data.get('created_at') else None
-        self.text: Optional[str] = data.get('text')
-        self.cw: Optional[str] = data.get('cw')
-        self.user_id: Optional[str] = data.get('user_id')
-        self.user: Optional[User] = User(
-            RawUser(data['user']), client=client
-        ) if data.get('user') else None
-        self.reply_id: Optional[str] = data.get('reply_id')
-        self.reply: Optional[Dict[str, Any]] = data.get('reply')
-        self.renote: Optional[Dict[str, Any]] = data.get('renote')
-        self.via_mobile: Optional[bool] = data.get('via_mobile')
-        self.is_hidden: Optional[bool] = data.get('is_hidden')
-        self.visibility: Optional[bool] = bool(data['visibility']) if data.get(
-            'visibility'
-        ) else None
-        self.mentions: Optional[List[str]] = data.get('mentions')
-        self.visible_user_ids: Optional[List[str]] = data.get(
-            'visible_user_ids'
-        )
-        self.file_ids: Optional[List[str]] = data.get('file_ids')
-        self.files: Optional[List[str]] = data.get('files')
-        self.tags: Optional[List[str]] = data.get('tags')
-        self.poll: Optional[List[str]] = data.get('poll')
-        self.channel: Optional[Channel] = Channel(data['channel']) if data.get(
-            'channel'
-        ) else None
-        self.local_only: Optional[bool] = data.get('local_only')
-        self.emojis: Optional[List[Emoji]] = [
-            Emoji(i) for i in data['emojis']
-        ] if data.get('emojis') else None
-        self.reactions: Optional[Dict[str, Any]] = data.get('reactions')
-        self.renote_count: Optional[int] = data.get('renote_count')
-        self.replies_count: Optional[int] = data.get('replies_count')
-        self.uri: Optional[str] = data.get('uri')
-        self.url: Optional[str] = data.get('url')
-        self.my_reaction: Optional[Dict[str, Any]] = data.get('my_reaction')
+    def __init__(self, raw_data: RawPinnedNote, *, client: ClientActions):
+        self._client: ClientActions = client
+        self._raw_data: RawPinnedNote = raw_data
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._raw_data.id
+
+    @property
+    def created_at(self) -> Optional[datetime]:
+        return self._raw_data.created_at
+
+    @property
+    def text(self) -> Optional[str]:
+        return self._raw_data.text
+
+    @property
+    def cw(self) -> Optional[str]:
+        return self._raw_data.cw
+
+    @property
+    def user_id(self) -> Optional[str]:
+        return self._raw_data.user_id
+
+    @property
+    def user(self) -> Optional[User]:
+        return User(self._raw_data.user, client=self._client)
+
+    @property
+    def reply_id(self) -> Optional[str]:
+        return self._raw_data.reply_id
+
+    @property
+    def reply(self) -> Optional[dict[str, Any]]:
+        return self._raw_data.reply
+
+    @property
+    def renote(self) -> Optional[dict[str, Any]]:
+        return self._raw_data.renote
+
+    @property
+    def via_mobile(self) -> bool:
+        return self._raw_data.via_mobile
+
+    @property
+    def is_hidden(self) -> bool:
+        return self._raw_data.is_hidden
+
+    @property
+    def visibility(self) -> bool:
+        return self._raw_data.visibility
+
+    @property
+    def mentions(self) -> Optional[list[str]]:
+        return self._raw_data.mentions
+
+    @property
+    def visible_user_ids(self) -> Optional[list[str]]:
+        return self._raw_data.visible_user_ids
+
+    @property
+    def file_ids(self) -> Optional[list[str]]:
+        return self._raw_data.file_ids
+
+    @property
+    def files(self) -> list[File]:
+        return [File(i, client=self._client) for i in self._raw_data.files]
+
+    @property
+    def tags(self) -> Optional[list[str]]:
+        return self._raw_data.tags
+
+    @property
+    def poll(self) -> Optional[dict[str, Any]]:
+        return self._raw_data.poll
+
+    @property
+    def channel(self) -> Optional[Channel]:
+        return Channel(self._raw_data.channel, client=self._client)
+
+    @property
+    def local_only(self) -> bool:
+        return self._raw_data.local_only
+
+    @property
+    def emojis(self) -> Optional[list[Emoji]]:
+        return [Emoji(i, client=self._client) for i in self._raw_data.emojis]
+
+    @property
+    def reactions(self) -> Optional[dict[str, Any]]:
+        return self._raw_data.reactions
+
+    @property
+    def renote_count(self) -> Optional[int]:
+        return self._raw_data.renote_count
+
+    @property
+    def replies_count(self) -> Optional[int]:
+        return self._raw_data.replies_count
+
+    @property
+    def uri(self) -> Optional[str]:
+        return self._raw_data.uri
+
+    @property
+    def url(self) -> Optional[str]:
+        return self._raw_data.url
+
+    @property
+    def my_reaction(self) -> Optional[dict[str, Any]]:
+        return self._raw_data.my_reaction
 
 
 class PinnedPage:
@@ -120,7 +216,7 @@ class PinnedPage:
         self.content: Optional[List] = data.get('content')
         self.variables: Optional[List] = data.get('variables')
         self.user_id: Optional[str] = data.get('user_id')
-        self.author: Optional[Dict[str, Any]] = data.get('author')
+        self.author: Optional[dict[str, Any]] = data.get('author')
 
 
 class FieldContent:

mipac/types/user.py

@@ -1,64 +1,64 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, TypedDict
+from typing import Any, List, Optional, TypedDict
 
 from .drive import FilePayload
 from .emoji import EmojiPayload
 from .instance import InstancePayload
 
 __all__ = (
-    'ChannelPayload',
+    'IChannel',
     'FieldContentPayload',
     'UserPayload',
     'PinnedPagePayload',
-    'PinnedNotePayload',
+    'IPinnedNote',
     'OptionalUser',
 )
 
 
-class ChannelPayload(TypedDict):
-    id: Optional[str]
-    created_at: Optional[str]
-    last_noted_at: Optional[str]
-    name: Optional[str]
-    description: Optional[str]
-    banner_url: Optional[str]
-    notes_count: Optional[int]
-    users_count: Optional[int]
-    is_following: Optional[bool]
-    user_id: Optional[str]
+class IChannel(TypedDict, total=False):
+    id: str
+    created_at: str
+    last_noted_at: str
+    name: str
+    description: str
+    banner_url: str
+    notes_count: int
+    users_count: int
+    is_following: bool
+    user_id: str
 
 
-class PinnedNotePayload(TypedDict):
-    id: Optional[str]
-    created_at: Optional[str]
-    text: Optional[str]
-    cw: Optional[str]
-    user_id: Optional[str]
-    user: Optional['UserPayload']
-    reply_id: Optional[str]
-    renote_id: Optional[str]
-    reply: Optional[Dict[str, Any]]
-    renote: Optional[Dict[str, Any]]
-    via_mobile: Optional[bool]
-    is_hidden: Optional[bool]
-    visibility: Optional[str]
-    mentions: Optional[List[str]]
-    visible_user_ids: Optional[List[str]]
-    file_ids: Optional[List[str]]
-    files: Optional[List[FilePayload]]
-    tags: Optional[List[str]]
-    poll: Optional[Dict[str, Any]]
-    channel_id: Optional[str]
-    channel: Optional[ChannelPayload]
-    local_only: Optional[bool]
-    emojis: Optional[List[EmojiPayload]]
-    reactions: Optional[Dict[str, Any]]
-    renote_count: Optional[int]
-    replies_count: Optional[int]
-    uri: Optional[str]
-    url: Optional[str]
-    my_reaction: Optional[Dict[str, Any]]
+class IPinnedNote(TypedDict, total=False):
+    id: str
+    created_at: str
+    text: str
+    cw: str
+    user_id: str
+    user: 'UserPayload'
+    reply_id: str
+    renote_id: str
+    reply: dict[str, Any]
+    renote: dict[str, Any]
+    via_mobile: bool
+    is_hidden: bool
+    visibility: str
+    mentions: list[str]
+    visible_user_ids: list[str]
+    file_ids: list[str]
+    files: list[FilePayload]
+    tags: list[str]
+    poll: dict[str, Any]
+    channel_id: str
+    channel: IChannel
+    local_only: bool
+    emojis: list[EmojiPayload]
+    reactions: dict[str, Any]
+    renote_count: int
+    replies_count: int
+    uri: str
+    url: str
+    my_reaction: dict[str, Any]
 
 
 class PinnedPagePayload(TypedDict):
@@ -71,7 +71,7 @@ class PinnedPagePayload(TypedDict):
     content: Optional[List]
     variables: Optional[List]
     user_id: Optional[str]
-    author: Optional[Dict[str, Any]]
+    author: Optional[dict[str, Any]]
 
 
 class FieldContentPayload(TypedDict):
@@ -97,7 +97,7 @@ class UserPayload(OptionalUser):
     avatar_url: Optional[str]
     avatar_blurhash: Optional[str]
     avatar_color: Optional[str]
-    emojis: Optional[List[str]]
+    emojis: Optional[list[str]]
     url: str
     uri: str
     created_at: str
@@ -112,8 +112,8 @@ class UserPayload(OptionalUser):
     followers_count: int
     following_count: int
     notes_count: int
-    pinned_note_ids: List[str]
-    pinned_notes: List[str]
+    pinned_note_ids: list[str]
+    pinned_notes: list[str]
     pinned_page_id: str
     pinned_page: str
     ff_visibility: str