send and User

pytecord/__init__.py

@@ -1,2 +1,2 @@
-from pytecord.client import Client
-from pytecord.guild import Guild, GuildChannel, Message, MessageDeleteEvent
+from .client import Client
+from .guild import Guild, GuildChannel, Message, MessageDeleteEvent

pytecord/client.py

@@ -1,34 +1,42 @@
-from pytecord.web import BaseWebhook
+from .web import BaseWebhook
 from asyncio import run as arun
 
 from typing import TYPE_CHECKING, Literal, Callable, Coroutine, Any
 
-from pytecord.guild import Message, Guild, GuildChannel, MessageDeleteEvent
-from pytecord.enums import GatewayIntents
+from .guild import Message, Guild, GuildChannel, MessageDeleteEvent
+from .enums import GatewayIntents
+from .user import User
 
 if TYPE_CHECKING:
-    from pytecord.web import GatewayOutput
+    from .web import GatewayOutput
 
 class Client:
     def __init__(self, token: str, debug: bool = False) -> None:
         self.webhook = BaseWebhook(token, debug)
         self.token = token
         self.__intents = GatewayIntents.GUILD_INTEGRATIONS
+        self.__user_id = None
+
+    @property
+    def user(self) -> User:
+        return User(self.webhook.get_user(self.__user_id))
 
     def listen(self):
         def decorator(func_to_decorate: Callable[..., Coroutine[Any, Any, Any]]):
             event_name = func_to_decorate.__name__
             match event_name:
                 case 'ready':
                     async def func(data: 'GatewayOutput'):
+                        self.__user_id = data.d['user']['id']
                         await func_to_decorate()
                 case 'message_create' | 'message_update':
                     self.__intents += GatewayIntents.GUILD_MESSAGES
                     self.__intents += GatewayIntents.MESSAGE_CONTENT
                     self.__intents += GatewayIntents.DIRECT_MESSAGES
                     async def func(data: 'GatewayOutput'):
-                        message = Message(data.d, self.token)
-                        await func_to_decorate(message)
+                        if not data.d['author'].get('bot', False):
+                            message = Message(data.d, self.token)
+                            await func_to_decorate(message)
                 case 'message_delete':
                     self.__intents += GatewayIntents.GUILD_MESSAGES
                     self.__intents += GatewayIntents.DIRECT_MESSAGES

pytecord/guild.py

@@ -1,7 +1,9 @@
 from typing import Any
 
-from pytecord.interfaces import Object
-from pytecord.utils import rget, rfetch
+from .user import User
+
+from .interfaces import Object
+from .utils import rget, apost, MessagePayload
 
 class Guild(Object):
     def __init__(self, data: dict[str, Any], token: str):
@@ -11,8 +13,7 @@ def __init__(self, data: dict[str, Any], token: str):
         self.icon_hash = data.get('icon_hash')
         self.splash = data.get('splash')
         self.discovery_splash = data.get('discovery_splash')
-        self.owner  = data.get('owner')
-        self.owner_id = data.get('owner_id')
+        self.is_owner  = data.get('owner')
         self.permissions  = data.get('permissions')
         self.region  = data.get('region ')
         self.afk_channel_id = int(x) if (x := data.get('afk_channel_id')) else None
@@ -49,9 +50,15 @@ def __init__(self, data: dict[str, Any], token: str):
         self.premium_progress_bar_enabled = data.get('premium_progress_bar_enabled')
         self.safety_alerts_channel_id = int(x) if (x := data.get('safety_alerts_channel_id')) else None
 
+        self.__owner_id = data.get('owner_id')
         self.__token = token
         self.__data = data
 
+    @property
+    def owner(self) -> User:
+        data = rget(f'/users/{self.__owner_id}', self.__token).json()
+        return User(data, self.__token)
+
     def __int__(self) -> int:
         """
         Returns a guild id
@@ -98,7 +105,7 @@ def __init__(self, data: dict[str, Any], token: str):
         self.bitrate = data.get('bitrate')
         self.user_limit = data.get('user_limit')
         self.rate_limit_per_user = data.get('rate_limit_per_user')
-        self.recipients = data.get('recipients')
+        self.recipients = [User(i) for i in x] if (x := data.get('recipients')) else None
         self.icon = data.get('icon')
         self.owner_id = int(x) if (x := data.get('owner_id')) else None
         self.application_id = int(x) if (x := data.get('application_id')) else None
@@ -129,7 +136,7 @@ def __init__(self, data: dict[str, Any], token: str):
     @property
     def guild(self) -> Guild | None:
         if self.__guild_id:
-            data = rget('guild', self.__guild_id, self.__token).json()
+            data = rget(f'/guilds/{self.__guild_id}', self.__token).json()
             return Guild(data, self.__token)
         return None
 
@@ -186,19 +193,24 @@ def fetch(self, id: int) -> 'Message':
         >>> message = channel.fetch(955886808095399996)
         ```
         """
-        data = rfetch('channel', 'message', self.id, id, self.__token).json()
+        data = rget(f'/channels/{self.id}/messages/{id}', self.__token).json()
+        return Message(data, self.__token)
+
+    async def send(self, content: str) -> 'Message':
+        payload = MessagePayload(content)
+        data = await apost(f'/channels/{self.id}/messages', self.__token, data=payload.eval())
         return Message(data, self.__token)
 
 class Message:
     def __init__(self, data: dict[str, Any], token: str) -> None:
         self.id = int(data.get('id'))
-        self.author = data.get('author')
+        self.author = User(data.get('author'), token)
         self.content = data.get('content')
         self.timestamp = data.get('timestamp')
         self.edited_timestamp = data.get('edited_timestamp')
         self.tts = data.get('tts')
         self.mention_everyone = data.get('mention_everyone')
-        self.mentions = data.get('mentions')
+        self.mentions = [User(i) for i in x] if (x := data.get('mentions')) else None
         self.mention_roles = data.get('mention_roles')
         self.mention_channels = data.get('mention_channels')
         self.attachments = data.get('attachments')
@@ -225,15 +237,14 @@ def __init__(self, data: dict[str, Any], token: str) -> None:
         # Extra fields for message create
         self.guild_id = int(x) if (x := data.get('guild_id')) else None
         self.member = data.get('member')
-        self.mentions = data.get('mentions')
 
         self.__channel_id = data.get('channel_id')
         self.__token = token
         self.__data = data
 
     @property
     def channel(self) -> GuildChannel:
-        data = rget('channel', self.__channel_id, self.__token).json()
+        data = rget(f'/channels/{self.__channel_id}', self.__token).json()
         return GuildChannel(data, self.__token)
 
     def __int__(self) -> int:
@@ -279,12 +290,12 @@ def __init__(self, data: dict[str, Any], token: str) -> None:
 
     @property
     def channel(self) -> GuildChannel:
-        data = rget('channel', self.__channel_id, self.__token).json()
+        data = rget(f'/channels/{self.__channel_id}', self.__token).json()
         return GuildChannel(data, self.__token)
 
     @property
     def guild(self) -> Guild:
-        data = rget('guild', self.__guild_id, self.__token).json()
+        data = rget(f'/guilds/{self.__guild_id}', self.__token).json()
         return Guild(data, self.__token)
 
     def __int__(self) -> int:

pytecord/user.py

@@ -0,0 +1,30 @@
+from .interfaces import Object
+from typing import Any
+
+class User(Object):
+    def __init__(self, data: dict[str, Any], token: str) -> None:
+        self.__token = token
+        self.__data = data
+
+    def eval(self) -> dict[str, Any]:
+        """
+        Returns a dict representation of user
+
+        ```
+        >>> user = User()
+        >>> user.eval()
+        ```
+        """
+        return self.__data
+
+    def __int__(self) -> int:
+        """
+        Returns an object id
+
+        ```
+        >>> obj = Object()
+        >>> int(obj)
+        ```
+        """
+        print('Is under developerment!')
+        return 0

pytecord/utils.py

@@ -1,18 +1,31 @@
 from requests import get, post
+from aiohttp import ClientSession
 
 from typing import Literal, Any
 
-from pytecord.config import API_VERSION
+from .config import API_VERSION
+
+class MessagePayload:
+    def __init__(self, content: str) -> None:
+        self.json = {
+            'content': content
+        }
+    def eval(self) -> dict[str, Any]:
+        return self.json
 
 def get_headers(token: str):
     return {'Authorization': f'Bot {token}'}
 
-def rget(what_to_get: Literal['channel', 'guild', 'user'], id: int, token: str = None, headers: dict[str, Any] = None):
+def rget(endpoint: str, token: str = None, headers: dict[str, Any] = None):
     if token:
         headers = get_headers(token)
-    return get(f'https://discord.com/api/v{API_VERSION}/{what_to_get}s/{id}', headers=headers)
+    return get(f'https://discord.com/api/v{API_VERSION}{endpoint}', headers=headers)
 
-def rfetch(where_get: Literal['channel'], what_to_fetch: Literal['message'], first_id: int, second_id: int, token: str = None, headers: dict[str, Any] = None):
+async def apost(endpoint: str, token: str = None, headers: dict[str, Any] = None, data: dict[str, Any] = None):
     if token:
         headers = get_headers(token)
-    return get(f'https://discord.com/api/v{API_VERSION}/{where_get}s/{first_id}/{what_to_fetch}s/{second_id}', headers=headers)
+    async with ClientSession(headers=headers) as s:
+        async with s.post(f'https://discord.com/api/v{API_VERSION}{endpoint}', data=data) as r:
+            if r.status == 200:
+                return  await r.json()
+            raise Exception(await r.json())

pytecord/web.py

@@ -1,16 +1,17 @@
-from pytecord.interfaces import BaseDataStreamListener
+from .interfaces import BaseDataStreamListener
 
 from typing import Callable, Coroutine, Any, TYPE_CHECKING
 from aiohttp import ClientSession
 from datetime import datetime
 from time import mktime
 from asyncio import gather, create_task
 from asyncio import sleep as asleep
-from pytecord.config import GATEWAY_VERSION
-from pytecord.utils import rget
+from .config import GATEWAY_VERSION
+from .utils import rget
 
 if TYPE_CHECKING:
-    from pytecord.guild import Guild, GuildChannel
+    from .guild import Guild, GuildChannel
+    from .user import User
 
 class ApiRequest:
     ...
@@ -175,13 +176,19 @@ async def run(self, intents: int = 0):
         await self.stream.run(intents)
 
     def get_guild(self, id: int) -> 'Guild':
-        from pytecord.guild import Guild
+        from .guild import Guild
 
-        data = rget('guild', id, self.token).json()
+        data = rget(f'/guilds/{id}', self.token).json()
         return Guild(data, self.token) 
 
     def get_channel(self, id: int) -> 'GuildChannel':
-        from pytecord.guild import GuildChannel
+        from .guild import GuildChannel
 
-        data = rget('channel', id, self.token).json()
-        return GuildChannel(data, self.token) 
+        data = rget(f'/channels/{id}', self.token).json()
+        return GuildChannel(data, self.token)
+
+    def get_user(self, id: int) -> 'User':
+        from .user import User
+
+        data = rget(f'/users/{id}', self.token).json()
+        return User(data, self.token)