modifyself 0.2.0__tar.gz → 0.2.2__tar.gz

{modifyself-0.2.0 → modifyself-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modifyself
-Version: 0.2.0
+Version: 0.2.2
 Summary: A clean, pythonic Discord self-bot library
 Author-email: modifyself <modifyself@example.com>
 License-Expression: MIT
@@ -16,6 +16,8 @@ Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: plyer>=0.9
 Requires-Dist: pillow>=10.0
 Requires-Dist: requests>=2.28
+Requires-Dist: PyNaCl>=1.5.0
+Requires-Dist: opuslib>=3.0.0
 Dynamic: license-file
 
 # modifyself

{modifyself-0.2.0 → modifyself-0.2.2}/README.md

@@ -1,31 +1,31 @@
-# modifyself
-
-A clean, pythonic Discord self-bot library.
-
-## Installation
-
-pip install modifyself
-
-## Quick Example
-
-rom modifyself import Client, command
-
-bot = Client(token="your_token")
-
-@bot.command()
-async def ping(ctx):
-    await ctx.reply("Pong!")
-
-bot.run()
-
-## Features
-
-- Clean, intuitive API
-- Command framework with cogs
-- Automatic rate limiting
-- Gateway event handling
-- Full API coverage
-
-## License
-
+# modifyself
+
+A clean, pythonic Discord self-bot library.
+
+## Installation
+
+pip install modifyself
+
+## Quick Example
+
+rom modifyself import Client, command
+
+bot = Client(token="your_token")
+
+@bot.command()
+async def ping(ctx):
+    await ctx.reply("Pong!")
+
+bot.run()
+
+## Features
+
+- Clean, intuitive API
+- Command framework with cogs
+- Automatic rate limiting
+- Gateway event handling
+- Full API coverage
+
+## License
+
 MIT

modifyself-0.2.2/modifyself/models/billing.py

@@ -0,0 +1,88 @@
+"""
+Billing models (payment sources, etc.)
+"""
+
+from typing import Optional, Dict, Any
+from .base import DiscordObject
+
+class PaymentSource(DiscordObject):
+    """Represents a payment source (card, PayPal, etc.)."""
+    
+    __slots__ = (
+        "type",
+        "brand",
+        "last_4",
+        "expires_month",
+        "expires_year",
+        "default",
+        "invalid",
+        "billing_address",
+    )
+    
+    def __init__(self, *, state, data: dict):
+        super().__init__(state=state, data=data)
+        self._update(data)
+    
+    def _update(self, data: dict):
+        self.type = data.get("type")
+        self.brand = data.get("brand")
+        self.last_4 = data.get("last_4")
+        self.expires_month = data.get("expires_month")
+        self.expires_year = data.get("expires_year")
+        self.default = data.get("default", False)
+        self.invalid = data.get("invalid", False)
+        self.billing_address = data.get("billing_address")
+    
+    @property
+    def is_card(self) -> bool:
+        return self.type == 1
+    
+    @property
+    def is_paypal(self) -> bool:
+        return self.type == 2
+    
+    def __repr__(self) -> str:
+        return f"<PaymentSource id={self.id} type={self.type} last4={self.last_4}>"
+
+class Subscription(DiscordObject):
+    """Represents a subscription (Nitro, etc.)."""
+    
+    __slots__ = (
+        "type",
+        "plan_id",
+        "status",
+        "current_period_start",
+        "current_period_end",
+        "renewal_interval",
+        "renewal_interval_count",
+        "entitlement_id",
+    )
+    
+    def __init__(self, *, state, data: dict):
+        super().__init__(state=state, data=data)
+        self._update(data)
+    
+    def _update(self, data: dict):
+        self.type = data.get("type")
+        self.plan_id = data.get("plan_id")
+        self.status = data.get("status")
+        self.current_period_start = data.get("current_period_start")
+        self.current_period_end = data.get("current_period_end")
+        self.renewal_interval = data.get("renewal_interval")
+        self.renewal_interval_count = data.get("renewal_interval_count")
+        self.entitlement_id = data.get("entitlement_id")
+    
+    @property
+    def is_nitro(self) -> bool:
+        return self.type == 1
+    
+    @property
+    def is_nitro_classic(self) -> bool:
+        return self.type == 2
+    
+    @property
+    def is_active(self) -> bool:
+        return self.status == 1
+    
+    def __repr__(self) -> str:
+        return f"<Subscription id={self.id} type={self.type} status={self.status}>"

modifyself-0.2.2/modifyself/models/message.py

@@ -0,0 +1,222 @@
+"""
+Discord Message model.
+"""
+
+from typing import TYPE_CHECKING, Optional, List, Dict, Any, Union
+from datetime import datetime
+
+from .base import DiscordObject
+from .user import User
+from .member import Member
+from ..core.enums import MessageType
+from ..utils import parse_time
+from ..components import Component, ActionRow, ComponentType
+
+if TYPE_CHECKING:
+    from ..state import ConnectionState
+
+
+class Message(DiscordObject):
+    """Represents a Discord message."""
+
+    __slots__ = (
+        "channel_id",
+        "author",
+        "content",
+        "timestamp",
+        "edited_timestamp",
+        "tts",
+        "mention_everyone",
+        "mentions",
+        "mention_roles",
+        "attachments",
+        "embeds",
+        "reactions",
+        "pinned",
+        "type",
+        "guild_id",
+        "member",
+        "referenced_message",
+        "flags",
+        "thread",
+        "application",
+        "message_reference",
+        "interaction",
+        "components",
+        "sticker_items",
+        "position",
+        "role_subscription_data",
+        "resolved",
+        "poll",
+        "call",
+        "author",
+    )
+
+    def __init__(self, *, state: "ConnectionState", data: dict):
+        super().__init__(state=state, data=data)
+        self._update(data)
+
+    def _update(self, data: dict):
+        self.id = int(data["id"])
+        self.channel_id = int(data["channel_id"])
+        self.content = data.get("content", "")
+        self.timestamp = parse_time(data["timestamp"])
+        self.edited_timestamp = parse_time(data["edited_timestamp"]) if data.get("edited_timestamp") else None
+        self.tts = data.get("tts", False)
+        self.mention_everyone = data.get("mention_everyone", False)
+        self.mentions = [User(state=self._state, data=u) for u in data.get("mentions", [])]
+        self.mention_roles = data.get("mention_roles", [])
+        self.attachments = data.get("attachments", [])
+        self.embeds = data.get("embeds", [])
+        self.reactions = data.get("reactions", [])
+        self.pinned = data.get("pinned", False)
+        self.type = MessageType(data.get("type", 0))
+        self.guild_id = int(data["guild_id"]) if data.get("guild_id") else None
+        self.flags = data.get("flags", 0)
+        self.sticker_items = data.get("sticker_items", [])
+        self.position = data.get("position", 0)
+        self.role_subscription_data = data.get("role_subscription_data")
+        self.resolved = data.get("resolved")
+        self.poll = data.get("poll")
+        self.call = data.get("call")
+        
+        # Author
+        self.author = User(state=self._state, data=data["author"])
+        
+        # Member (if in guild)
+        self.member = None
+        if data.get("member"):
+            self.member = Member(state=self._state, data=data["member"], guild_id=self.guild_id)
+        
+        # Referenced message
+        self.referenced_message = None
+        if data.get("referenced_message"):
+            self.referenced_message = Message(state=self._state, data=data["referenced_message"])
+        
+        # Thread
+        self.thread = data.get("thread")
+        
+        # Application
+        self.application = data.get("application")
+        
+        # Message reference
+        self.message_reference = data.get("message_reference")
+        
+        # Interaction
+        self.interaction = data.get("interaction")
+        
+        # Components
+        self._components = []
+        for comp_data in data.get("components", []):
+            if comp_data.get("type") == ComponentType.ACTION_ROW:
+                row = ActionRow()
+                for child_data in comp_data.get("components", []):
+                    row.components.append(Component(child_data))
+                self._components.append(row)
+
+    @property
+    def jump_url(self) -> str:
+        """The jump URL for this message."""
+        return f"https://discord.com/channels/{self.guild_id or '@me'}/{self.channel_id}/{self.id}"
+
+    @property
+    def clean_content(self) -> str:
+        """The content of the message with mentions cleaned."""
+        content = self.content
+        for user in self.mentions:
+            content = content.replace(f"<@{user.id}>", f"@{user.name}")
+            content = content.replace(f"<@!{user.id}>", f"@{user.name}")
+        for role_id in self.mention_roles:
+            content = content.replace(f"<@&{role_id}>", f"@<role>")
+        if self.mention_everyone:
+            content = content.replace("@everyone", "@everyone")
+            content = content.replace("@here", "@here")
+        return content
+
+    @property
+    def components(self) -> List[ActionRow]:
+        """The components in this message."""
+        return self._components
+
+    async def edit(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        components: Optional[List[ActionRow]] = None,
+        **kwargs,
+    ) -> "Message":
+        """Edit this message."""
+        payload = {}
+        if content is not None:
+            payload["content"] = content
+        if embeds is not None:
+            payload["embeds"] = embeds
+        if components is not None:
+            payload["components"] = [c.to_dict() for c in components]
+        payload.update(kwargs)
+        
+        data = await self._state.http.edit_message(
+            self.channel_id,
+            self.id,
+            **payload,
+        )
+        self._update(data)
+        return self
+
+    async def delete(self) -> None:
+        """Delete this message."""
+        await self._state.http.delete_message(self.channel_id, self.id)
+
+    async def reply(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        components: Optional[List[ActionRow]] = None,
+        **kwargs,
+    ) -> "Message":
+        """Reply to this message."""
+        payload = {
+            "message_reference": {"message_id": self.id},
+        }
+        if content is not None:
+            payload["content"] = content
+        if embeds is not None:
+            payload["embeds"] = embeds
+        if components is not None:
+            payload["components"] = [c.to_dict() for c in components]
+        payload.update(kwargs)
+        
+        data = await self._state.http.send_message(
+            self.channel_id,
+            **payload,
+        )
+        return self._state._store_message(data)
+
+    async def add_reaction(self, emoji: str) -> None:
+        """Add a reaction to this message."""
+        await self._state.http.add_reaction(self.channel_id, self.id, emoji)
+
+    async def remove_reaction(self, emoji: str) -> None:
+        """Remove a reaction from this message."""
+        await self._state.http.remove_reaction(self.channel_id, self.id, emoji)
+
+    async def clear_reactions(self) -> None:
+        """Clear all reactions from this message."""
+        await self._state.http.clear_reactions(self.channel_id, self.id)
+
+    async def pin(self) -> None:
+        """Pin this message."""
+        await self._state.http.pin_message(self.channel_id, self.id)
+
+    async def unpin(self) -> None:
+        """Unpin this message."""
+        await self._state.http.unpin_message(self.channel_id, self.id)
+
+    async def get_reaction_users(self, emoji: str, limit: int = 100) -> List[User]:
+        """Get users who reacted with a specific emoji."""
+        # This would need to be implemented in the HTTP client
+        # For now, just return an empty list
+        return []
+
+    def __repr__(self) -> str:
+        return f"<Message id={self.id} content={self.content[:50]!r}>"

modifyself-0.2.2/modifyself/models/relationship.py

@@ -0,0 +1,47 @@
+"""
+Relationship models (friends, blocks, etc.)
+"""
+
+from typing import Optional, Dict, Any
+from .base import DiscordObject
+
+class Relationship(DiscordObject):
+    """Represents a relationship (friend, block, etc.)."""
+    
+    __slots__ = (
+        "user_id",
+        "type",
+        "nickname",
+        "since",
+        "user",
+    )
+    
+    def __init__(self, *, state, data: dict):
+        super().__init__(state=state, data=data)
+        self._update(data)
+    
+    def _update(self, data: dict):
+        self.user_id = int(data.get("user_id", 0))
+        self.type = data.get("type", 0)  # 1=friends, 2=blocked, 3=incoming, 4=outgoing
+        self.nickname = data.get("nickname")
+        self.since = data.get("since")
+        self.user = data.get("user")
+    
+    @property
+    def is_friend(self) -> bool:
+        return self.type == 1
+    
+    @property
+    def is_blocked(self) -> bool:
+        return self.type == 2
+    
+    @property
+    def is_incoming_request(self) -> bool:
+        return self.type == 3
+    
+    @property
+    def is_outgoing_request(self) -> bool:
+        return self.type == 4
+    
+    def __repr__(self) -> str:
+        return f"<Relationship id={self.id} type={self.type}>"

modifyself-0.2.2/modifyself/models/settings.py

@@ -0,0 +1,54 @@
+"""
+User settings models.
+"""
+
+from typing import Optional, Dict, Any, List
+from .base import DiscordObject
+
+class GuildSettings(DiscordObject):
+    """Settings for a specific guild."""
+    
+    __slots__ = (
+        "guild_id",
+        "channel_overwrites",
+        "muted",
+        "mute_config",
+        "mobile_push",
+        "message_notifications",
+        "flags",
+        "notify_highlights",
+    )
+    
+    def __init__(self, *, state, data: dict):
+        super().__init__(state=state, data=data)
+        self._update(data)
+    
+    def _update(self, data: dict):
+        self.guild_id = int(data.get("guild_id", 0))
+        self.channel_overwrites = data.get("channel_overwrites", {})
+        self.muted = data.get("muted", False)
+        self.mute_config = data.get("mute_config", {})
+        self.mobile_push = data.get("mobile_push", False)
+        self.message_notifications = data.get("message_notifications", 0)
+        self.flags = data.get("flags", 0)
+        self.notify_highlights = data.get("notify_highlights", {})
+    
+    def __repr__(self) -> str:
+        return f"<GuildSettings guild_id={self.guild_id}>"
+
+class UserSettings:
+    """Container for user settings (not a model)."""
+    
+    def __init__(self, data: dict):
+        self.theme = data.get("theme", "dark")
+        self.locale = data.get("locale", "en-US")
+        self.status = data.get("status", "online")
+        self.developer_mode = data.get("developer_mode", False)
+        self.afk_timeout = data.get("afk_timeout", 600)
+        self.animate_emoji = data.get("animate_emoji", True)
+        self.animate_stickers = data.get("animate_stickers", True)
+        self.enable_tts = data.get("enable_tts", False)
+        self.guilds = data.get("guild_settings", {})
+    
+    def __repr__(self) -> str:
+        return f"<UserSettings theme={self.theme} status={self.status}>"

modifyself-0.2.2/modifyself/models/webhook.py

@@ -0,0 +1,168 @@
+"""
+Discord Webhook models.
+"""
+
+from typing import TYPE_CHECKING, Optional, List, Dict, Any, Union
+from .base import DiscordObject
+from .user import User
+from .channel import Channel
+from ..utils import parse_time
+
+if TYPE_CHECKING:
+    from ..state import ConnectionState
+
+
+class Webhook(DiscordObject):
+    """Represents a Discord webhook."""
+
+    __slots__ = (
+        "type",
+        "name",
+        "avatar",
+        "channel_id",
+        "guild_id",
+        "user",
+        "token",
+        "source_guild",
+        "source_channel",
+        "url",
+    )
+
+    def __init__(self, *, state: "ConnectionState", data: dict):
+        super().__init__(state=state, data=data)
+        self._update(data)
+
+    def _update(self, data: dict):
+        self.id = int(data["id"])
+        self.type = data.get("type", 1)  # 1=incoming, 2=channel follower
+        self.name = data.get("name")
+        self.avatar = data.get("avatar")
+        self.channel_id = int(data["channel_id"])
+        self.guild_id = int(data["guild_id"]) if data.get("guild_id") else None
+        self.token = data.get("token")
+        self.source_guild = data.get("source_guild")
+        self.source_channel = data.get("source_channel")
+        
+        self.user = None
+        if data.get("user"):
+            self.user = User(state=self._state, data=data["user"])
+        
+        self.url = data.get("url")
+
+    @property
+    def avatar_url(self) -> Optional[str]:
+        """The URL of the webhook's avatar."""
+        if self.avatar:
+            return f"https://cdn.discordapp.com/avatars/{self.id}/{self.avatar}.png"
+        return None
+
+    @property
+    def display_name(self) -> str:
+        """The display name of the webhook."""
+        return self.name or "Unknown Webhook"
+
+    async def send(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        username: Optional[str] = None,
+        avatar_url: Optional[str] = None,
+        tts: bool = False,
+        components: Optional[List] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Send a message with this webhook."""
+        payload = {}
+        if content is not None:
+            payload["content"] = content
+        if embeds is not None:
+            payload["embeds"] = embeds
+        if username is not None:
+            payload["username"] = username
+        if avatar_url is not None:
+            payload["avatar_url"] = avatar_url
+        if tts:
+            payload["tts"] = tts
+        if components is not None:
+            payload["components"] = [c.to_dict() for c in components]
+        payload.update(kwargs)
+        
+        url = f"/webhooks/{self.id}/{self.token}"
+        return await self._state.http.request(
+            method="POST",
+            url=url,
+            json=payload,
+        )
+
+    async def edit(
+        self,
+        name: Optional[str] = None,
+        avatar: Optional[str] = None,
+        channel_id: Optional[int] = None,
+        **kwargs,
+    ) -> "Webhook":
+        """Edit this webhook."""
+        payload = {}
+        if name is not None:
+            payload["name"] = name
+        if avatar is not None:
+            payload["avatar"] = avatar
+        if channel_id is not None:
+            payload["channel_id"] = str(channel_id)
+        payload.update(kwargs)
+        
+        data = await self._state.http.request(
+            method="PATCH",
+            url=f"/webhooks/{self.id}",
+            json=payload,
+        )
+        self._update(data)
+        return self
+
+    async def delete(self) -> None:
+        """Delete this webhook."""
+        await self._state.http.request(
+            method="DELETE",
+            url=f"/webhooks/{self.id}",
+        )
+
+    def __repr__(self) -> str:
+        return f"<Webhook id={self.id} name={self.name!r}>"
+
+
+class WebhookMessage:
+    """A message sent via webhook."""
+    
+    def __init__(self, data: dict):
+        self.id = int(data["id"])
+        self.channel_id = int(data["channel_id"])
+        self.content = data.get("content", "")
+        self.timestamp = parse_time(data["timestamp"])
+        self.edited_timestamp = parse_time(data["edited_timestamp"]) if data.get("edited_timestamp") else None
+        self.embeds = data.get("embeds", [])
+        self.attachments = data.get("attachments", [])
+        self.components = data.get("components", [])
+        self.flags = data.get("flags", 0)
+        self.webhook_id = int(data.get("webhook_id", 0))
+    
+    async def edit(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        components: Optional[List] = None,
+        **kwargs,
+    ) -> "WebhookMessage":
+        """Edit this webhook message."""
+        payload = {}
+        if content is not None:
+            payload["content"] = content
+        if embeds is not None:
+            payload["embeds"] = embeds
+        if components is not None:
+            payload["components"] = [c.to_dict() for c in components]
+        payload.update(kwargs)
+        return self
+    
+    async def delete(self) -> None:
+        """Delete this webhook message."""
+        pass

{modifyself-0.2.0 → modifyself-0.2.2}/modifyself.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modifyself
-Version: 0.2.0
+Version: 0.2.2
 Summary: A clean, pythonic Discord self-bot library
 Author-email: modifyself <modifyself@example.com>
 License-Expression: MIT
@@ -16,6 +16,8 @@ Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: plyer>=0.9
 Requires-Dist: pillow>=10.0
 Requires-Dist: requests>=2.28
+Requires-Dist: PyNaCl>=1.5.0
+Requires-Dist: opuslib>=3.0.0
 Dynamic: license-file
 
 # modifyself

{modifyself-0.2.0 → modifyself-0.2.2}/modifyself.egg-info/requires.txt

@@ -4,3 +4,5 @@ aiohttp>=3.8.0
 plyer>=0.9
 pillow>=10.0
 requests>=2.28
+PyNaCl>=1.5.0
+opuslib>=3.0.0

{modifyself-0.2.0 → modifyself-0.2.2}/pyproject.toml

@@ -1,30 +1,34 @@
-[build-system]
-requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "modifyself"
-version = "0.2.0"
-description = "A clean, pythonic Discord self-bot library"
-readme = "README.md"
-license = "MIT"
-authors = [
-    {name = "modifyself", email = "modifyself@example.com"}
-]
-requires-python = ">=3.9"
-dependencies = [
-    "websockets>=10.0",
-    "wreq>=0.1.0",
-    "aiohttp>=3.8.0",
-    "plyer>=0.9",
-    "pillow>=10.0",
-    "requests>=2.28",
-]
-
-[project.urls]
-Homepage = "https://github.com/clashings/modifyself"
-Bug-Reports = "https://github.com/clashings/modifyself/issues"
-Source = "https://github.com/clashings/modifyself"
-
-[tool.setuptools.packages.find]
-include = ["modifyself*"]
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "modifyself"
+version = "0.2.2"
+description = "A clean, pythonic Discord self-bot library"
+readme = "README.md"
+license = "MIT"
+authors = [
+    {name = "modifyself", email = "modifyself@example.com"}
+]
+requires-python = ">=3.9"
+dependencies = [
+    "websockets>=10.0",
+    "wreq>=0.1.0",
+    "aiohttp>=3.8.0",
+    "plyer>=0.9",
+    "pillow>=10.0",
+    "requests>=2.28",
+    "PyNaCl>=1.5.0",
+    "opuslib>=3.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/clashings/modifyself"
+Bug-Reports = "https://github.com/clashings/modifyself/issues"
+Source = "https://github.com/clashings/modifyself"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["modifyself*"]
+exclude = ["tests*", "examples*", "docs*"]

modifyself-0.2.0/modifyself/models/message.py

@@ -1,180 +0,0 @@
-"""
-Discord Message model.
-"""
-
-from typing import TYPE_CHECKING
-
-from .base import DiscordObject
-from .user import User
-from ..core.snowflake import Snowflake
-from ..utils import parse_time
-
-if TYPE_CHECKING:
-    from ..state import ConnectionState
-    from .member import Member
-    from .channel import Channel
-    from .guild import Guild
-
-
-class Message(DiscordObject):
-    """Represents a message in Discord."""
-
-    __slots__ = (
-        "channel_id",
-        "author",
-        "content",
-        "timestamp",
-        "edited_at",
-        "tts",
-        "mention_everyone",
-        "mentions",
-        "mention_roles",
-        "attachments",
-        "embeds",
-        "reactions",
-        "pinned",
-        "type",
-        "guild_id",
-        "member",
-        "referenced_message",
-        "_cs_channel",
-        "_cs_guild",
-    )
-
-    def __init__(self, *, state: "ConnectionState", data: dict):
-        super().__init__(state=state, data=data)
-        self._cs_channel = None
-        self._cs_guild = None
-        self._update(data)
-
-    def _update(self, data: dict):
-        self.channel_id = Snowflake(data.get("channel_id", 0))
-        author_data = data.get("author", {})
-        self.author = User(state=self._state, data=author_data)
-        self.content = data.get("content", "")
-        self.timestamp = parse_time(data["timestamp"]) if "timestamp" in data else None
-        self.edited_at = (
-            parse_time(data["edited_timestamp"]) if data.get("edited_timestamp") else None
-        )
-        self.tts = data.get("tts", False)
-        self.mention_everyone = data.get("mention_everyone", False)
-        self.mentions = [
-            User(state=self._state, data=u) for u in data.get("mentions", [])
-        ]
-        self.mention_roles = [int(r) for r in data.get("mention_roles", [])]
-        self.attachments = data.get("attachments", [])
-        self.embeds = data.get("embeds", [])
-        self.reactions = data.get("reactions", [])
-        self.pinned = data.get("pinned", False)
-        self.type = data.get("type", 0)
-        self.guild_id = (
-            Snowflake(data["guild_id"]) if data.get("guild_id") else None
-        )
-
-        # Member info if present
-        member_data = data.get("member")
-        if member_data and self.guild_id:
-            from .member import Member
-            self.member = Member(
-                state=self._state, data={**member_data, "user": author_data},
-                guild_id=self.guild_id
-            )
-        else:
-            self.member = None
-
-        # Referenced message
-        ref_data = data.get("referenced_message")
-        if ref_data:
-            self.referenced_message = Message(state=self._state, data=ref_data)
-        else:
-            self.referenced_message = None
-
-    def __repr__(self) -> str:
-        return f"<Message id={self.id} author={self.author!r} channel={self.channel_id}>"
-
-    def __str__(self) -> str:
-        return self.content
-
-    @property
-    def channel(self) -> "Channel | None":
-        if self._cs_channel is None:
-            self._cs_channel = self._state._channels.get(self.channel_id)
-        return self._cs_channel
-
-    @property
-    def guild(self) -> "Guild | None":
-        if self.guild_id is None:
-            return None
-        if self._cs_guild is None:
-            self._cs_guild = self._state._guilds.get(self.guild_id)
-        return self._cs_guild
-
-    @property
-    def jump_url(self) -> str:
-        guild_id = self.guild_id or "@me"
-        return f"https://discord.com/channels/{guild_id}/{self.channel_id}/{self.id}"
-
-    @property
-    def created_at(self):
-        return self.id.created_at
-
-    @property
-    def edited_timestamp(self):
-        return self.edited_at
-
-    @property
-    def clean_content(self) -> str:
-        """The message content with mentions replaced with names."""
-        content = self.content
-        for user in self.mentions:
-            content = content.replace(f"<@{user.id}>", f"@{user.display_name}")
-            content = content.replace(f"<@!{user.id}>", f"@{user.display_name}")
-        return content
-
-    async def delete(self, *, delay: float | None = None):
-        """Delete this message."""
-        if delay:
-            import asyncio
-            await asyncio.sleep(delay)
-        await self._state.http.delete_message(self.channel_id, self.id)
-
-    async def edit(self, content: str | None = None, **kwargs):
-        """Edit this message."""
-        data = await self._state.http.edit_message(
-            self.channel_id, self.id, content, **kwargs
-        )
-        self._update(data)
-        return self
-
-    async def reply(self, content: str | None = None, **kwargs):
-        """Reply to this message."""
-        ref = {
-            "type": 0,
-            "message_id": str(self.id),
-            "channel_id": str(self.channel_id),
-        }
-        if self.guild_id:
-            ref["guild_id"] = str(self.guild_id)
-        kwargs["message_reference"] = ref
-        data = await self._state.http.send_message(self.channel_id, content, **kwargs)
-        return self._state._store_message(data)
-
-    async def add_reaction(self, emoji: str):
-        """Add a reaction to this message."""
-        await self._state.http.add_reaction(self.channel_id, self.id, emoji)
-
-    async def remove_reaction(self, emoji: str):
-        """Remove a reaction from this message."""
-        await self._state.http.remove_reaction(self.channel_id, self.id, emoji)
-
-    async def clear_reactions(self):
-        """Clear all reactions from this message."""
-        await self._state.http.clear_reactions(self.channel_id, self.id)
-
-    async def pin(self):
-        """Pin this message."""
-        await self._state.http.pin_message(self.channel_id, self.id)
-
-    async def unpin(self):
-        """Unpin this message."""
-        await self._state.http.unpin_message(self.channel_id, self.id)