modifyself 0.2.1__tar.gz → 0.2.3__tar.gz

{modifyself-0.2.1 → modifyself-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modifyself
-Version: 0.2.1
+Version: 0.2.3
 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.3/modifyself/components.py

@@ -0,0 +1,286 @@
+"""
+Discord components (buttons, selects, modals).
+"""
+
+from typing import Optional, List, Dict, Any, Union, Callable, Awaitable
+from enum import IntEnum
+import json
+
+class ComponentType(IntEnum):
+    ACTION_ROW = 1
+    BUTTON = 2
+    SELECT_MENU = 3
+    TEXT_INPUT = 4
+    CHANNEL_SELECT = 5
+    ROLE_SELECT = 6
+    MENTIONABLE_SELECT = 7
+    USER_SELECT = 8
+
+class ButtonStyle(IntEnum):
+    PRIMARY = 1
+    SECONDARY = 2
+    SUCCESS = 3
+    DANGER = 4
+    LINK = 5
+
+class TextInputStyle(IntEnum):
+    SHORT = 1
+    PARAGRAPH = 2
+
+class Component:
+    def __init__(self, data: dict):
+        self.type = data.get("type")
+        self._data = data
+
+    def to_dict(self) -> dict:
+        return self._data
+
+class Button(Component):
+    def __init__(
+        self,
+        style: Union[ButtonStyle, int] = ButtonStyle.PRIMARY,
+        label: Optional[str] = None,
+        custom_id: Optional[str] = None,
+        url: Optional[str] = None,
+        emoji: Optional[Dict[str, Any]] = None,
+        disabled: bool = False,
+    ):
+        data = {
+            "type": ComponentType.BUTTON,
+            "style": int(style),
+            "disabled": disabled,
+        }
+        if label:
+            data["label"] = label
+        if custom_id:
+            data["custom_id"] = custom_id
+        if url:
+            data["url"] = url
+        if emoji:
+            data["emoji"] = emoji
+        super().__init__(data)
+        self.style = style
+        self.label = label
+        self.custom_id = custom_id
+        self.url = url
+        self.emoji = emoji
+        self.disabled = disabled
+
+    @classmethod
+    def primary(cls, label: str, custom_id: str, emoji: Optional[Dict[str, Any]] = None) -> "Button":
+        return cls(style=ButtonStyle.PRIMARY, label=label, custom_id=custom_id, emoji=emoji)
+
+    @classmethod
+    def secondary(cls, label: str, custom_id: str, emoji: Optional[Dict[str, Any]] = None) -> "Button":
+        return cls(style=ButtonStyle.SECONDARY, label=label, custom_id=custom_id, emoji=emoji)
+
+    @classmethod
+    def success(cls, label: str, custom_id: str, emoji: Optional[Dict[str, Any]] = None) -> "Button":
+        return cls(style=ButtonStyle.SUCCESS, label=label, custom_id=custom_id, emoji=emoji)
+
+    @classmethod
+    def danger(cls, label: str, custom_id: str, emoji: Optional[Dict[str, Any]] = None) -> "Button":
+        return cls(style=ButtonStyle.DANGER, label=label, custom_id=custom_id, emoji=emoji)
+
+    @classmethod
+    def link(cls, label: str, url: str, emoji: Optional[Dict[str, Any]] = None) -> "Button":
+        return cls(style=ButtonStyle.LINK, label=label, url=url, emoji=emoji)
+
+class SelectOption:
+    def __init__(
+        self,
+        label: str,
+        value: str,
+        description: Optional[str] = None,
+        emoji: Optional[Dict[str, Any]] = None,
+        default: bool = False,
+    ):
+        self.label = label
+        self.value = value
+        self.description = description
+        self.emoji = emoji
+        self.default = default
+
+    def to_dict(self) -> dict:
+        data = {"label": self.label, "value": self.value}
+        if self.description:
+            data["description"] = self.description
+        if self.emoji:
+            data["emoji"] = self.emoji
+        if self.default:
+            data["default"] = True
+        return data
+
+class SelectMenu(Component):
+    def __init__(
+        self,
+        custom_id: str,
+        options: List[SelectOption],
+        placeholder: Optional[str] = None,
+        min_values: int = 1,
+        max_values: int = 1,
+        disabled: bool = False,
+    ):
+        data = {
+            "type": ComponentType.SELECT_MENU,
+            "custom_id": custom_id,
+            "options": [opt.to_dict() for opt in options],
+            "min_values": min_values,
+            "max_values": max_values,
+            "disabled": disabled,
+        }
+        if placeholder:
+            data["placeholder"] = placeholder
+        super().__init__(data)
+        self.custom_id = custom_id
+        self.options = options
+        self.placeholder = placeholder
+        self.min_values = min_values
+        self.max_values = max_values
+        self.disabled = disabled
+
+class ChannelSelect(Component):
+    def __init__(
+        self,
+        custom_id: str,
+        placeholder: Optional[str] = None,
+        min_values: int = 1,
+        max_values: int = 1,
+        disabled: bool = False,
+        channel_types: Optional[List[int]] = None,
+    ):
+        data = {
+            "type": ComponentType.CHANNEL_SELECT,
+            "custom_id": custom_id,
+            "min_values": min_values,
+            "max_values": max_values,
+            "disabled": disabled,
+        }
+        if placeholder:
+            data["placeholder"] = placeholder
+        if channel_types:
+            data["channel_types"] = channel_types
+        super().__init__(data)
+
+class RoleSelect(Component):
+    def __init__(
+        self,
+        custom_id: str,
+        placeholder: Optional[str] = None,
+        min_values: int = 1,
+        max_values: int = 1,
+        disabled: bool = False,
+    ):
+        data = {
+            "type": ComponentType.ROLE_SELECT,
+            "custom_id": custom_id,
+            "min_values": min_values,
+            "max_values": max_values,
+            "disabled": disabled,
+        }
+        if placeholder:
+            data["placeholder"] = placeholder
+        super().__init__(data)
+
+class MentionableSelect(Component):
+    def __init__(
+        self,
+        custom_id: str,
+        placeholder: Optional[str] = None,
+        min_values: int = 1,
+        max_values: int = 1,
+        disabled: bool = False,
+    ):
+        data = {
+            "type": ComponentType.MENTIONABLE_SELECT,
+            "custom_id": custom_id,
+            "min_values": min_values,
+            "max_values": max_values,
+            "disabled": disabled,
+        }
+        if placeholder:
+            data["placeholder"] = placeholder
+        super().__init__(data)
+
+class UserSelect(Component):
+    def __init__(
+        self,
+        custom_id: str,
+        placeholder: Optional[str] = None,
+        min_values: int = 1,
+        max_values: int = 1,
+        disabled: bool = False,
+    ):
+        data = {
+            "type": ComponentType.USER_SELECT,
+            "custom_id": custom_id,
+            "min_values": min_values,
+            "max_values": max_values,
+            "disabled": disabled,
+        }
+        if placeholder:
+            data["placeholder"] = placeholder
+        super().__init__(data)
+
+class TextInput(Component):
+    def __init__(
+        self,
+        custom_id: str,
+        label: str,
+        style: Union[TextInputStyle, int] = TextInputStyle.SHORT,
+        placeholder: Optional[str] = None,
+        value: Optional[str] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        required: bool = True,
+    ):
+        data = {
+            "type": ComponentType.TEXT_INPUT,
+            "custom_id": custom_id,
+            "label": label,
+            "style": int(style),
+            "required": required,
+        }
+        if placeholder:
+            data["placeholder"] = placeholder
+        if value:
+            data["value"] = value
+        if min_length:
+            data["min_length"] = min_length
+        if max_length:
+            data["max_length"] = max_length
+        super().__init__(data)
+
+class ActionRow:
+    def __init__(self, *components: Component):
+        self.components = list(components)
+
+    def add_component(self, component: Component):
+        self.components.append(component)
+
+    def to_dict(self) -> dict:
+        return {
+            "type": ComponentType.ACTION_ROW,
+            "components": [c.to_dict() for c in self.components],
+        }
+
+class Modal:
+    def __init__(
+        self,
+        custom_id: str,
+        title: str,
+        components: Optional[List[Component]] = None,
+    ):
+        self.custom_id = custom_id
+        self.title = title
+        self.components = components or []
+
+    def add_component(self, component: Component):
+        self.components.append(component)
+
+    def to_dict(self) -> dict:
+        return {
+            "custom_id": self.custom_id,
+            "title": self.title,
+            "components": [ActionRow(c).to_dict() for c in self.components],
+        }

modifyself-0.2.3/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.3/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.3/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.3/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.3/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.1 → modifyself-0.2.3}/modifyself.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modifyself
-Version: 0.2.1
+Version: 0.2.3
 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.1 → modifyself-0.2.3}/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.1 → modifyself-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modifyself"
-version = "0.2.1"
+version = "0.2.3"
 description = "A clean, pythonic Discord self-bot library"
 readme = "README.md"
 license = "MIT"
@@ -19,6 +19,8 @@ dependencies = [
     "plyer>=0.9",
     "pillow>=10.0",
     "requests>=2.28",
+    "PyNaCl>=1.5.0",
+    "opuslib>=3.0.0",
 ]
 
 [project.urls]
@@ -27,4 +29,6 @@ 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.1/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)