nerimity 1.2.1__tar.gz

nerimity-1.2.1/LICENSE.TXT

@@ -0,0 +1,7 @@
+Copyright 2023 "Fiiral"
+Maintained by "Deutscher775" as of 02.02.2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

nerimity-1.2.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.2
+Name: nerimity
+Version: 1.2.1
+License-File: LICENSE.TXT
+Requires-Dist: aiohttp>=3.11.13
+Requires-Dist: websockets>=15.0.1
+Requires-Dist: requests>=2.32.3
+Dynamic: requires-dist

nerimity-1.2.1/README.md

@@ -0,0 +1,200 @@
+# nerimity.py
+
+Python API wrapper for Nerimity originating from [Fiiral](https://github.com/F-iiral), maintained by [Deutscher775](https://github.com/Deutscher775)
+### **[Nerimity Server](https://nerimity.com/i/493CV)** <br>
+For questions, help or anything else feel free to join the **[nerimity.py](https://nerimity.com/i/493CV)** Nerimity server.
+# Quick jumps
+- **[Current Features](#current-features)** <br>
+See the features that the framework currently supports.
+- **[Installation](#installation)** <br>
+Guide on how to install nerimity.py.
+- **[Example Bot](#example-commands-bot)** <br>
+An example bot you can directly use.
+- **[Use-case-examples](#use-case-examples)** <br>
+Many various examples on how to use specific functions.
+
+# Current features
+#### Command Handling:
+- Define and register commands using the @client.command decorator.
+- Execute commands with parameters.
+Register event listeners using the @client.listen decorator.
+Handle various events such as:
+- on_ready
+- on_message_create
+- on_message_updated
+- on_message_deleted
+- on_button_clicked
+- on_presence_change
+- on_reaction_add
+- on_member_updated
+- on_role_updated
+- on_role_deleted
+- on_role_created
+- on_channel_updated
+- on_channel_deleted
+- on_channel_created
+- on_server_updated
+- on_member_join
+- on_member_left
+- on_server_joined
+- on_server_left
+- on_friend_request_sent
+- on_friend_request_pending
+- on_friend_request_accepted
+- on_friend_removed
+- on_minute_pulse
+- on_hour_pulse
+
+#### Message Handling:
+- Send messages to channels.
+    - add attachments
+    - add buttons with custom callback
+- Edit and delete messages.
+- React and unreact to messages.
+
+#### Attachment Handling:
+- Create and upload attachments.
+- Deserialize attachments from JSON.
+
+#### Channel Management:
+- Update channel information.
+- Send messages to channels.
+- Get messages from channels.
+- Purge messages from channels.
+- Deserialize channels from JSON.
+
+#### Context Handling:
+- Send messages, remove messages, and react to messages within a command context.
+
+#### Invite Management:
+- Create and delete server invites.
+- Deserialize invites from JSON.
+
+#### Member Management:
+- Follow, unfollow, add friend, remove friend, and send direct messages to members.
+- Kick, ban, and unban server members.
+- Deserialize members and server members from JSON.
+
+#### Post Management:
+- Create, delete, comment on, like, and unlike posts.
+- Get comments on posts.
+- Deserialize posts from JSON.
+
+#### Role Management:
+- Create, update, and delete roles.
+- Deserialize roles from JSON.
+
+#### Server Management:
+- Get server details and ban list.
+- Create, update, and delete channels and roles.
+- Create and delete invites.
+- Update server members.
+- Deserialize servers from JSON.
+
+#### Status Management:
+- Change the presence status of the bot.
+
+#### Button Interaction:
+- Handle button interactions and send popups.
+- Deserialize button interactions from JSON.
+
+
+# Installation
+Currently there is no direct installation method. (WIP)
+### Follow these 2 simple steps:
+1. Clone the repository
+```shell
+git clone https://github.com/deutscher775/nerimity.py.git
+```
+2. Copy the `nerimity` folder and insert it into your workspace. It should look like this:
+![Image](./readme-assets/directory-view.png)
+
+### Done!
+## Example commands bot
+```py
+import nerimity
+
+
+client = nerimity.Client(
+    token="YOUR_BOT_TOKEN",
+    prefix='!',
+)
+
+@client.command(name="ping")
+async def ping(ctx: nerimity.Context, params: str):
+    await ctx.send("Pong!")
+
+
+@client.listen("on_ready")
+async def on_ready(params):
+    print(f"Logged in as {client.account.username}")
+
+
+client.run()
+```
+
+## Use case examples
+### Sending an attachment
+```py
+@client.command(name="testattachment")
+async def testattachment(ctx: nerimity.Context, params):
+    file = await nerimity.Attachment.construct("test.png").upload()
+    result = await ctx.send("Test", attachment=file)
+```
+
+### Sending buttons with messages
+```py
+@client.command(name="testbutton")
+async def testbutton(ctx: nerimity.Context, params):
+    popup_button = nerimity.Button.construct(label="Popup!", id="popuptestbutton", alert=True)
+    async def popup_callback(buttoninteraction: nerimity.ButtonInteraction):
+        user = client.get_user(buttoninteraction.userId)
+        buttoninteraction.send_popup("Test", f"Hello, {user.username}!")
+    await popup_button.set_callback(popup_callback)
+
+    message_button = nerimity.Button.construct(label="Message!", id="messagetestbutton")
+    async def message_callback(buttoninteraction: nerimity.ButtonInteraction):
+        user = client.get_user(buttoninteraction.userId)
+        await ctx.send(f"Hello, {user.username}!")
+    await message_button.set_callback(message_callback)
+    await ctx.send("Test", buttons=[message_button, popup_button])
+```
+
+### Creating a post
+```py
+@client.command(name="createpost")
+async def createpost(ctx: nerimity.Context, params):
+    content = ""
+    for param in params:
+        content += param + " "
+    await ctx.send("Creating post with text: " + content)
+    post = nerimity.Post.create_post(content)
+    print(post)
+    await ctx.send("Post created.")
+```
+
+### Commenting on a post
+```py
+@client.command(name="comment")
+async def comment(ctx: nerimity.Context, params):
+    post_id = int(params[0])
+    content = ""
+    for param in params[1:]:
+        content += param + " "
+    post = nerimity.Post.get_post(post_id)
+    post.create_comment(content)
+    await ctx.send("Commented on post.")
+```
+
+### Deleting a post
+```py
+@client.command(name="deletepost")
+async def deletepost(ctx: nerimity.Context, params):
+    post_id = int(params[0])
+    post = nerimity.Post.get_post(post_id)
+    post.delete_post()
+    await ctx.send("Deleted post.")
+```
+
+## Issues
+If you encounter any issues while using the framework feel free to open an [Issue](https://github.com/deutscher775/nerimity.py).

nerimity-1.2.1/nerimity/__init__.py

@@ -0,0 +1,16 @@
+from nerimity._enums import GlobalClientInformation, Colors, ChannelTypes, PresenceTypes, BadgeTypes, AttachmentTypes
+from nerimity.attachment import Attachment
+from nerimity.channel import Channel
+from nerimity.client import Client
+from nerimity.context import Context
+from nerimity.member import Member, ServerMember
+from nerimity.message import Message
+from nerimity.server import Server
+from nerimity.roles import Role
+from nerimity.invite import Invite
+from nerimity.post import Post
+from nerimity.status import Status
+from nerimity.button import Button
+from nerimity.buttoninteraction import ButtonInteraction
+
+pass

nerimity-1.2.1/nerimity/_enums.py

@@ -0,0 +1,53 @@
+import datetime
+
+class GlobalClientInformation():
+    TOKEN = ''
+    SERVERS = {}
+    BUTTONS = []
+
+class ConsoleShortcuts():
+    def log():   return f"{Colors.MAGENTA}[{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')}]{Colors.WHITE} |"
+    def ok():    return f"{Colors.GREEN}[{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')}]{Colors.WHITE} |"
+    def warn():  return f"{Colors.YELLOW}[{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')}]{Colors.WHITE} |"
+    def error(): return f"{Colors.RED}[{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')}]{Colors.WHITE} |"
+
+class Colors():
+    BLACK = "\u001b[30m"
+    RED = "\u001b[31m"
+    GREEN = "\u001b[32m"
+    YELLOW = "\u001b[33m"
+    BLUE = "\u001b[34m"
+    MAGENTA = "\u001b[35m"
+    CYAN = "\u001b[36m"
+    WHITE = "\u001b[37m"
+
+class ChannelTypes():
+    DM_TEXT = 0
+    SERVER_TEXT = 1
+    CATEGORY = 2
+
+class PresenceTypes():
+    OFFLINE = 0
+    ONLINE = 1
+    LTP = 2
+    AFK = 3
+    DND = 4
+
+class BadgeTypes():
+    OWNER = 1
+    ADMIN = 2
+    CONTRIBUTOR = 4
+    SUPPORTER = 8
+    BOT = 16
+
+class MessageType():
+    CONTENT = 0
+    JOIN_SERVER = 1
+    LEAVE_SERVER = 2
+    KICK_USER = 3
+    BAN_USER = 4
+    CALL_STARTED = 5
+
+class AttachmentTypes():
+    INCOMING = 0
+    OUTGOING = 1

nerimity-1.2.1/nerimity/attachment.py

@@ -0,0 +1,74 @@
+from nerimity._enums import AttachmentTypes, GlobalClientInformation
+import aiohttp
+import mimetypes
+
+class Attachment():
+    """
+    Represents an attachment in Nerimity.
+
+    construct(file_path): static | Creates a new Attachment object from a file path.
+    upload(): |coro| Uploads the attachment to the CDN.
+    deserialize(): static | Deserialize a json string to a Attachment object.
+    """
+
+    def __init__(self) -> None:
+        self.internal_type  : int               = None
+        self.data_type      : str | None        = None
+        self.size           : int | None        = None
+        self.data           : str | None        = None
+        self.height         : int | None        = None
+        self.width          : int | None        = None
+        self.name           : str | None        = None
+        self.id             : int | None        = None
+        self.provider       : str | None        = None
+        self.file_id        : str | None        = None
+        self.mime           : str | None        = None
+        self.created_at     : float | None      = None
+
+    # Public Static: Creates a new Attachment object from a file.
+    @staticmethod
+    def construct(file_path) -> 'Attachment':
+        """Creates a new Attachment object from a file path."""
+
+        new_attachment = Attachment()
+        new_attachment.internal_type = AttachmentTypes.OUTGOING
+
+        with open(file_path, 'rb') as file:
+            new_attachment.data = file.read()
+            new_attachment.data_type, _ = mimetypes.guess_type(file_path)
+            new_attachment.size = len(new_attachment.data)
+            new_attachment.name = file_path.split("/")[-1] if "/" in file_path else file_path
+        
+        return new_attachment
+    
+    # Public: Uploads the attachment to the CDN.
+    async def upload(self):
+        """|coro| Uploads the attachment to the CDN. Returns the file ID. This is not a usable file yet. It will be automatically uploaded with the send_message method."""
+        formdata = aiohttp.FormData()
+        formdata.add_field("f", self.data, filename=self.name, content_type=self.data_type)
+        headers = {
+            "Authorization": GlobalClientInformation.TOKEN,
+            }
+        async with aiohttp.ClientSession() as session:
+            async with session.post("https://cdn.nerimity.com/upload", headers=headers, data=formdata) as cdn_response:
+                json = await cdn_response.json()
+                self.file_id = json.get("fileId")
+                return self
+    
+    # Public Static: Deserialize a json string to a Attachment object.
+    @staticmethod
+    def deserialize(json: dict) -> 'Attachment':
+        """Deserialize a json string to a Attachment object."""
+
+        new_attachment = Attachment()
+        new_attachment.internal_type    = AttachmentTypes.INCOMING
+        new_attachment.height           = json["height"]
+        new_attachment.width            = json["width"]
+        new_attachment.path             = json["path"]
+        new_attachment.id               = int(json["id"])       if json["id"] is not None else None
+        new_attachment.provider         = json["provider"]
+        new_attachment.file_id          = json["fileId"]
+        new_attachment.mime             = json["mime"]
+        new_attachment.created_at       = json["createdAt"]
+
+        return new_attachment

nerimity-1.2.1/nerimity/button.py

@@ -0,0 +1,42 @@
+class Button():
+    """Represents a button.
+    ## Attributes
+
+    label: string | The label of the button.
+    id: string | The ID of the button.
+    alert: bool | Whether the button is an alert button. (Button will be red if true)
+    """
+    def __init__(self) -> None:
+        self.label      : str           = None
+        self.id         : str           = None
+        self.alert      : bool          = False
+        self._callback                  = None
+    
+    @classmethod
+    def construct(cls, label: str, id: str, alert: bool = False) -> 'Button':
+        """Constructs a button."""
+        button = cls()
+        button.label = label
+        button.id = id
+        button.alert = alert
+        return button
+    
+    async def callback(self, buttoninteraction):
+        """Callback function for the button."""
+        if self._callback:
+            await self._callback(buttoninteraction)
+    
+    async def set_callback(self, callback_func):
+        """Sets the callback function for the button."""
+        self._callback = callback_func
+    
+    # Public: Serializes the button to a json string.
+    @staticmethod
+    def deserialize(json: dict) -> 'Button':
+        """Deserialize a json string to a Button object."""
+        button = Button()
+        button.label        = str(json["label"])
+        button.id           = str(json["id"])
+        button.alert        = bool(json["alert"])
+
+        return button

nerimity-1.2.1/nerimity/buttoninteraction.py

@@ -0,0 +1,44 @@
+from nerimity.button import Button
+import requests
+from nerimity._enums import ConsoleShortcuts, GlobalClientInformation
+
+class ButtonInteraction():
+    def __init__(self, messageId: int = None, channelId: int = None, button: Button = None, userId: int = None) -> None:
+        self.messageId = messageId
+        self.channelId = channelId
+        self.button = button
+        self.userId = userId
+    
+
+    def send_popup(self, title: str, content: str) -> None:
+        """Sends a popup to the user who clicked the button."""
+        api_url = f"https://nerimity.com/api/channels/{self.channelId}/messages/{self.messageId}/buttons/{self.button.id}/callback"
+
+        headers = {
+            "Authorization": GlobalClientInformation.TOKEN
+        }
+
+        data = {
+            "userId": str(self.userId),
+            "title": title,
+            "content": content
+        }
+
+        response = requests.post(api_url, json=data, headers=headers)
+        if response.status_code != 200:
+            print(f"{ConsoleShortcuts.error} Failed to send popup: {response.text}")
+
+    
+    @staticmethod
+    def deserialize(json: dict) -> 'ButtonInteraction':
+        """Deserialize a json string to a ButtonInteraction object."""
+        print(json)
+        buttonInteraction = ButtonInteraction()
+        buttonInteraction.messageId     = int(json["messageId"])
+        buttonInteraction.channelId     = int(json["channelId"])
+        buttonInteraction.button        = json["button"]
+        buttonInteraction.userId        = int(json["userId"])
+
+        return buttonInteraction
+
+        

nerimity-1.2.1/nerimity/channel.py

@@ -0,0 +1,186 @@
+import aiohttp
+import asyncio
+import json
+from nerimity.message import Message
+from nerimity.attachment import Attachment
+from nerimity._enums import GlobalClientInformation, ConsoleShortcuts
+from nerimity.button import Button
+
+class Channel():
+    """
+    Represents a channel in Nerimity.
+
+    id: Snowflake ID of the channel
+    name: Name of the channel.
+    type: Type of the channel
+    creator_id: ID of the creator of the channel.
+    server_id: ID of the server the channel is in.
+    category_id: ID of the category the channel is in.
+    last_messaged_at: Timestamp from when the last message was send.
+    created_at: Timestamp from when the channel was created.
+    order: Priority of the channel in its category.
+    
+    update_channel(): Updates itself with specified information.
+    send_message(): Sends a message to the channel.
+    get_messages(): Gets a list of up to 50 message from the channel.
+
+    deserialize(json): static | Deserialize a json string to a Channel object.
+    """
+
+    def __init__(self) -> None:
+        self.id               : int             = None
+        self.name             : str             = None
+        self.type             : int             = None
+        self.creator_id       : int             = None
+        self.server_id        : int             = None
+        self.category_id      : int             = None
+        self.last_messaged_at : float | None    = None
+        self.created_at       : float           = None
+        self.order            : int | None      = None
+    
+    # Public: Updates itself with specified information.
+    async def update_channel(self, server_id: int, name: str=None, icon: str=None, content: str=None) -> None:
+        """Updates itself with specified information."""
+
+        api_endpoint = f"https://nerimity.com/api/servers/{server_id}/channels/{self.id}"
+
+        headers = {
+            "Authorization": GlobalClientInformation.TOKEN,
+            "Content-Type": "application/json",
+        }
+        data = {
+            "name": name,
+            "icon": icon,
+        }
+
+        if icon is None:
+            del data["icon"]
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(api_endpoint, headers=headers, json=data) as response:
+                if response.status != 200:
+                    print(f"{ConsoleShortcuts.error()} Failed to update a channel for {self}. Status code: {response.status}. Response Text: {await response.text()}")
+                    raise aiohttp.ClientResponseError(response.request_info, response.history)
+
+            if content is not None:
+                api_endpoint = f"https://nerimity.com/api/servers/{server_id}/channels/{self.id}/notice"
+
+                if content == "":
+                    async with session.delete(api_endpoint, headers=headers) as response:
+                        if response.status != 200:
+                            print(f"{ConsoleShortcuts.error()} Failed to update a channel for {self}. Status code: {response.status}. Response Text: {await response.text()}")
+                            raise aiohttp.ClientResponseError(response.request_info, response.history)
+                else:
+                    async with session.put(api_endpoint, headers=headers, json={"content": content}) as response:
+                        if response.status != 200:
+                            print(f"{ConsoleShortcuts.error()} Failed to update a channel for {self}. Status code: {response.status}. Response Text: {await response.text()}")
+                            raise aiohttp.ClientResponseError(response.request_info, response.history)
+
+    # Public: Sends a message to the channel.
+    async def send_message(self, message_content: str, attachment: Attachment | None = None, buttons: list[Button] | None = None) -> Message:
+        """Sends a message to the channel."""
+        
+        api_endpoint = f"https://nerimity.com/api/channels/{self.id}/messages"
+        headers = {
+            "Authorization": GlobalClientInformation.TOKEN,
+            "Content-Type": "application/json",
+        }
+        data = {
+            "content": message_content,
+            "buttons": []
+        }
+
+        if buttons is not None:
+            for button in buttons:
+                data["buttons"].append({
+                    "label": str(button.label),
+                    "id": str(button.id),
+                    "alert": button.alert
+                })
+                GlobalClientInformation.BUTTONS.append(button)
+        print(data["buttons"])
+                
+
+        async with aiohttp.ClientSession() as session:
+            if attachment is not None:
+                async with session.post(f"https://cdn.nerimity.com/attachments/{str(self.id)}/{attachment.file_id}") as response:
+                    if response.status != 200:
+                        print(f"{ConsoleShortcuts.error()} Failed to send attachment to {self}. Status code: {response.status}. Response Text: {await response.text()}")
+                        raise aiohttp.ClientResponseError(response.request_info, response.history)
+                    data["nerimityCdnFileId"] = (await response.json()).get("fileId")
+
+            async with session.post(api_endpoint, headers=headers, json=data) as response:
+                if response.status != 200:
+                    print(f"{ConsoleShortcuts.error()} Failed to send message to {self}. Status code: {response.status}. Response Text: {await response.text()}")
+                    raise aiohttp.ClientResponseError(response.request_info, response.history)
+                message_data = await response.json()
+                return Message.deserialize(message_data)
+
+    # Private: Gets a raw string of messages.
+    async def _get_messages_raw(self, amount: int) -> str:
+        if amount > 50:
+            amount = 50
+        elif amount < 1:
+            raise ValueError("Amount of requested messages must be positive.")
+
+        api_endpoint = f"https://nerimity.com/api/channels/{self.id}/messages?limit={amount}"
+
+        headers = {
+            "Authorization": GlobalClientInformation.TOKEN,
+            "Content-Type": "application/json",
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(api_endpoint, headers=headers) as response:
+                if response.status != 200:
+                    print(f"Failed to get messages from {self}. Status code: {response.status}. Response Text: {await response.text()}")
+                    raise aiohttp.ClientResponseError(response.request_info, response.history)
+                
+                return await response.text()
+
+    # Public: Gets a list of up to 50 message from the channel.
+    async def get_messages(self, amount: int) -> list[Message]:
+        """Gets a list of up to 50 message from the channel."""
+
+        messages_raw = json.loads(await self._get_messages_raw(amount))
+        messages = []
+        for message_raw in messages_raw:
+            message = Message.deserialize(message_raw)
+            messages.append(message)
+        
+        return messages
+    
+    # Public: Purge the channel of the specified amount of messages.
+    async def purge(self, amount: int) -> None:
+        """Purges the channel of the specified amount of messages."""
+
+        if amount > 50: 
+            print(f"{ConsoleShortcuts.warn()} Attempted to purge an illegal amount '{amount}' of messages in {self}.")
+            amount = 50
+        if amount <= 0: 
+            print(f"{ConsoleShortcuts.warn()} Attempted to purge an illegal amount '{amount}' of messages in {self}.")
+            return
+
+        messages = await self.get_messages(amount)
+        messages.reverse()
+        messages = messages[:amount]
+        for message in messages:
+            await message.delete()
+
+    # Public Static: Deserialize a json string to a Channel object.
+    @staticmethod
+    def deserialize(json: dict) -> 'Channel':
+        """static | Deserialize a json string to a Channel object."""
+
+        new_channel = Channel()
+        new_channel.id                  = int(json["id"])
+        new_channel.name                = str(json["name"])
+        new_channel.type                = int(json["type"])
+        new_channel.creator_id          = int(json["createdById"])      if json["createdById"]    is not None else 0
+        new_channel.server_id           = int(json["serverId"])         if json["serverId"]       is not None else 0
+        new_channel.category_id         = int(json["categoryId"])       if json["categoryId"]     is not None else 0
+        new_channel.last_messaged_at    = float(json["lastMessagedAt"]) if json["lastMessagedAt"] is not None else None
+        new_channel.created_at          = float(json["createdAt"])
+        new_channel.order               = json["order"]
+    
+        return new_channel