lynxpresence 4.4.0__py2.py3-none-any.whl

lynxpresence-4.4.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: lynxpresence
+Version: 4.4.0
+Summary: Discord RPC client written in Python
+Home-page: https://github.com/C0rn3j/pypresence
+Author: C0rn3j
+License: MIT
+Keywords: discord rich presence pypresence rpc api wrapper gamers chat irc
+Platform: Windows
+Platform: Linux
+Platform: OSX
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Typing :: Typed
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Communications :: Chat
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-python
+Dynamic: summary
+
+Forked as upstream did not make a release in quite a while, I hope to kill this fork off in the future.
+
+> A Discord Rich Presence Client in Python? Looks like you've come to the right place.
+![PyPI](https://img.shields.io/pypi/v/lynxpresence.svg?style=for-the-badge)
+
+----------
+
+# Installation
+
+Install pypresence with **`pip`**
+
+For the latest development version:
+
+### `pip install https://github.com/C0rn3j/pypresence/archive/master.zip`
+
+For the latest stable version:
+
+### `pip install lynxpresence`
+
+----------
+
+# Documentation
+
+> [!Note]
+> You need an **authorized app** to do anything besides rich presence!
+
+####  [pypresence Documentation](https://qwertyquerty.github.io/pypresence/html/index.html)
+####  [Discord Rich Presence Documentation](https://discord.com/developers/docs/rich-presence/how-to)
+####  [Discord RPC Documentation](https://discord.com/developers/docs/topics/rpc)
+####  [pyresence Discord Support Server](https://discord.gg/JF3kg77)
+####  [Discord API Support Server](https://discord.gg/discord-api)
+
+----------
+
+# Examples
+
+Examples can be found in the [examples](https://github.com/C0rn3j/pypresence/tree/master/examples) directory, and you can contribute your own examples if you wish, just read [examples.md](https://github.com/C0rn3j/pypresence/blob/master/examples/examples.md)!

lynxpresence-4.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+lynxpresence-4.4.0.dist-info/licenses/LICENSE,sha256=xHIb8Oev4PgFc1SNQc69cOh4-s8nd0EL6S-DhjEw2tA,1069
+pypresence/__init__.py,sha256=j08h4vFQRSztxkUkOxbsBE5esBGD_isXp63m7rO0V5g,421
+pypresence/baseclient.py,sha256=dPtxH2VfE5pbO5cMflZzhOpH9-6RV4gsGxQBaLaJ6hs,4997
+pypresence/client.py,sha256=mGCRU5LPBhiRtSNvC1MyY8emSbpoNX0R2HAQAcp3iKo,16106
+pypresence/exceptions.py,sha256=bj7P6lllBpxjsr6Y6HbmFgP1caA8QIDNjuBJ90CG364,2280
+pypresence/payloads.py,sha256=j2U6xpkrVaHvjh6RFLdfARgW5DX008Bj2r-xPvOc5vQ,9097
+pypresence/presence.py,sha256=1eSxnEPj56-242P98HdI1J85q_8gVBwSVbOBzywkTrk,4186
+pypresence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypresence/types.py,sha256=DuXV8zdKdZHmwOwEX9KcDGcvh7qRhHe9cVECexsMvdQ,334
+pypresence/utils.py,sha256=sa4zpFIb8IHj03yzd3HUWq7KFK566MPUIXFkZAeBT10,1959
+lynxpresence-4.4.0.dist-info/METADATA,sha256=Z0AktccWp7hNtw-WxgMrix8fAe2jRPB3ylRtKoIrOoo,2888
+lynxpresence-4.4.0.dist-info/WHEEL,sha256=9bhjOwO--Rs91xaPcBdlYFUmIudhuXqFlPriQeYQITw,109
+lynxpresence-4.4.0.dist-info/top_level.txt,sha256=HgPRAKZXYeILcC2btf3X4WYdVa6CdfiT2Kl_O42RSuY,11
+lynxpresence-4.4.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lynxpresence-4.4.0.dist-info/RECORD,,

lynxpresence-4.4.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (77.0.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

lynxpresence-4.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 qwertyquerty
+
+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.

lynxpresence-4.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pypresence

lynxpresence-4.4.0.dist-info/zip-safe

@@ -0,0 +1 @@
+

pypresence/__init__.py

@@ -0,0 +1,18 @@
+"""
+Python RPC Client for Discord
+-----------------------------
+By: qwertyquerty and LewdNeko
+"""
+
+from .baseclient import BaseClient
+from .client import Client, AioClient
+from .exceptions import *
+from .types import ActivityType
+from .presence import Presence, AioPresence
+
+
+__title__ = 'pypresence'
+__author__ = 'C0rn3j'
+__copyright__ = 'Copyright 2018 - Current qwertyquerty'
+__license__ = 'MIT'
+__version__ = '4.4.0'

pypresence/baseclient.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import struct
+import sys
+
+# TODO: Get rid of this import * lol
+from .exceptions import *
+from .payloads import Payload
+from .utils import get_ipc_path, get_event_loop
+
+
+class BaseClient:
+
+    def __init__(self, client_id: str, **kwargs):
+        loop = kwargs.get('loop', None)
+        handler = kwargs.get('handler', None)
+        self.pipe = kwargs.get('pipe', None)
+        self.isasync = kwargs.get('isasync', False)
+        self.connection_timeout = kwargs.get('connection_timeout', 30)
+        self.response_timeout = kwargs.get('response_timeout', 10)
+
+        client_id = str(client_id)
+
+        if loop is not None:
+            self.update_event_loop(loop)
+        else:
+            self.update_event_loop(get_event_loop())
+
+        self.sock_reader: asyncio.StreamReader | None = None
+        self.sock_writer: asyncio.StreamWriter | None = None
+
+        self.client_id = client_id
+
+        if handler is not None:
+            if not inspect.isfunction(handler):
+                raise PyPresenceException('Error handler must be a function.')
+            args = inspect.getfullargspec(handler).args
+            if args[0] == 'self':
+                args = args[1:]
+            if len(args) != 2:
+                raise PyPresenceException('Error handler should only accept two arguments.')
+
+            if self.isasync:
+                if not inspect.iscoroutinefunction(handler):
+                    raise InvalidArgument('Coroutine', 'Subroutine', 'You are running async mode - '
+                                                                     'your error handler should be awaitable.')
+                err_handler = self._async_err_handle
+            else:
+                err_handler = self._err_handle
+
+            self.loop.set_exception_handler(err_handler)
+            self.handler = handler
+
+        if getattr(self, "on_event", None):  # Tasty bad code ;^)
+            self._events_on = True
+        else:
+            self._events_on = False
+
+    def update_event_loop(self, loop):
+        # noinspection PyAttributeOutsideInit
+        self.loop = loop
+        asyncio.set_event_loop(self.loop)
+
+    def _err_handle(self, loop, context: dict):
+        result = self.handler(context['exception'], context['future'])
+        if inspect.iscoroutinefunction(self.handler):
+            loop.run_until_complete(result)
+
+    # noinspection PyUnusedLocal
+    async def _async_err_handle(self, loop, context: dict):
+        await self.handler(context['exception'], context['future'])
+
+    async def read_output(self):
+        try:
+            preamble = await asyncio.wait_for(self.sock_reader.read(8), self.response_timeout)
+            status_code, length = struct.unpack('<II', preamble[:8])
+            data = await asyncio.wait_for(self.sock_reader.read(length), self.response_timeout)
+        except (BrokenPipeError, struct.error):
+            raise PipeClosed
+        except asyncio.TimeoutError:
+            raise ResponseTimeout
+        payload = json.loads(data.decode('utf-8'))
+        if payload["evt"] == "ERROR":
+            raise ServerError(payload["data"]["message"])
+        return payload
+
+    def send_data(self, op: int, payload: dict | Payload):
+        if isinstance(payload, Payload):
+            payload = payload.data
+        payload = json.dumps(payload)
+
+        assert self.sock_writer is not None, "You must connect your client before sending events!"
+
+        self.sock_writer.write(
+            struct.pack(
+                '<II',
+                op,
+                len(payload)) +
+            payload.encode('utf-8'))
+
+    async def handshake(self):
+        ipc_path = get_ipc_path(self.pipe)
+        if not ipc_path:
+            raise DiscordNotFound
+
+        try:
+            if sys.platform == 'linux' or sys.platform == 'darwin':
+                self.sock_reader, self.sock_writer = await asyncio.wait_for(asyncio.open_unix_connection(ipc_path), self.connection_timeout)
+            elif sys.platform == 'win32':
+                self.sock_reader = asyncio.StreamReader(loop=self.loop)
+                reader_protocol = asyncio.StreamReaderProtocol(self.sock_reader, loop=self.loop)
+                self.sock_writer, _ = await asyncio.wait_for(self.loop.create_pipe_connection(lambda: reader_protocol, ipc_path), self.connection_timeout)
+        except FileNotFoundError:
+            raise InvalidPipe
+        except asyncio.TimeoutError:
+            raise ConnectionTimeout
+
+        self.send_data(0, {'v': 1, 'client_id': self.client_id})
+        preamble = await self.sock_reader.read(8)
+        code, length = struct.unpack('<ii', preamble)
+        data = json.loads(await self.sock_reader.read(length))
+        if 'code' in data:
+            if data['message'] == 'Invalid Client ID':
+                raise InvalidID
+            raise DiscordError(data['code'], data['message'])
+        if self._events_on:
+            self.sock_reader.feed_data = self.on_event

pypresence/client.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+import asyncio
+import inspect
+import struct
+import json
+import os
+from typing import List
+
+from .baseclient import BaseClient
+from .exceptions import *
+from .payloads import Payload
+from .types import ActivityType
+
+
+class Client(BaseClient):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._closed = False
+        self._events = {}
+
+    def register_event(self, event: str, func: callable, args=None):
+        if args is None:
+            args = {}
+        if inspect.iscoroutinefunction(func):
+            raise NotImplementedError
+        elif len(inspect.signature(func).parameters) != 1:
+            raise ArgumentError
+        self.subscribe(event, args)
+        self._events[event.lower()] = func
+
+    def unregister_event(self, event: str, args=None):
+        if args is None:
+            args = {}
+        event = event.lower()
+        if event not in self._events:
+            raise EventNotFound
+        self.unsubscribe(event, args)
+        del self._events[event]
+
+    # noinspection PyProtectedMember
+    def on_event(self, data):
+        if self.sock_reader._eof:
+            raise PyPresenceException('feed_data after feed_eof')
+        if not data:
+            return
+        self.sock_reader._buffer.extend(data)
+        self.sock_reader._wakeup_waiter()
+        if (self.sock_reader._transport is not None and
+                not self.sock_reader._paused and
+                len(self.sock_reader._buffer) > 2 * self.sock_reader._limit):
+            try:
+                self.sock_reader._transport.pause_reading()
+            except NotImplementedError:
+                self.sock_reader._transport = None
+            else:
+                self.sock_reader._paused = True
+
+        end = 0
+        while end < len(data):
+            # While chunks are available in data
+            start = end + 8
+            status_code, length = struct.unpack('<II', data[end:start])
+            end = length + start
+            payload = json.loads(data[start:end].decode('utf-8'))
+
+            if payload["evt"] is not None:
+                evt = payload["evt"].lower()
+                if evt in self._events:
+                    self._events[evt](payload["data"])
+                elif evt == 'error':
+                    raise DiscordError(payload["data"]["code"], payload["data"]["message"])
+
+    def authorize(self, client_id: str, scopes: List[str]):
+        payload = Payload.authorize(client_id, scopes)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def authenticate(self, token: str):
+        payload = Payload.authenticate(token)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def get_guilds(self):
+        payload = Payload.get_guilds()
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def get_guild(self, guild_id: str):
+        payload = Payload.get_guild(guild_id)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def get_channel(self, channel_id: str):
+        payload = Payload.get_channel(channel_id)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def get_channels(self, guild_id: str):
+        payload = Payload.get_channels(guild_id)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def set_user_voice_settings(self, user_id: str, pan_left: float | None = None,
+                                pan_right: float | None = None, volume: int | None = None,
+                                mute: bool | None = None):
+        payload = Payload.set_user_voice_settings(user_id, pan_left, pan_right, volume, mute)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def select_voice_channel(self, channel_id: str):
+        payload = Payload.select_voice_channel(channel_id)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def get_selected_voice_channel(self):
+        payload = Payload.get_selected_voice_channel()
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def select_text_channel(self, channel_id: str):
+        payload = Payload.select_text_channel(channel_id)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def set_activity(self, pid: int = os.getpid(),
+                     activity_type: ActivityType | None = None,
+                     state: str | None = None, details: str | None = None,
+                     start: int | None = None, end: int | None = None,
+                     large_image: str | None = None, large_text: str | None = None,
+                     small_image: str | None = None, small_text: str | None = None,
+                     party_id: str | None = None, party_size: list | None = None,
+                     join: str | None = None, spectate: str | None = None,
+                     match: str | None = None, buttons: list | None = None,
+                     instance: bool = True):
+        payload = Payload.set_activity(pid=pid, activity_type=activity_type, state=state, details=details, start=start,
+                                       end=end, large_image=large_image, large_text=large_text, small_image=small_image,
+                                       small_text=small_text, party_id=party_id, party_size=party_size, join=join,
+                                       spectate=spectate, match=match, buttons=buttons, instance=instance,
+                                       activity=True)
+
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def clear_activity(self, pid: int = os.getpid()):
+        payload = Payload.set_activity(pid, activity=None)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def subscribe(self, event: str, args=None):
+        if args is None:
+            args = {}
+        payload = Payload.subscribe(event, args)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def unsubscribe(self, event: str, args=None):
+        if args is None:
+            args = {}
+        payload = Payload.unsubscribe(event, args)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def get_voice_settings(self):
+        payload = Payload.get_voice_settings()
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def set_voice_settings(self, _input: dict | None = None, output: dict | None = None,
+                           mode: dict | None = None, automatic_gain_control: bool | None = None,
+                           echo_cancellation: bool | None = None, noise_suppression: bool | None = None,
+                           qos: bool | None = None, silence_warning: bool | None = None,
+                           deaf: bool | None = None, mute: bool | None = None):
+        payload = Payload.set_voice_settings(_input, output, mode, automatic_gain_control, echo_cancellation,
+                                             noise_suppression, qos, silence_warning, deaf, mute)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def capture_shortcut(self, action: str):
+        payload = Payload.capture_shortcut(action)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def send_activity_join_invite(self, user_id: str):
+        payload = Payload.send_activity_join_invite(user_id)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def close_activity_request(self, user_id: str):
+        payload = Payload.close_activity_request(user_id)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def close(self):
+        self.send_data(2, {'v': 1, 'client_id': self.client_id})
+        self.sock_writer.close()
+        self._closed = True
+        self.loop.close()
+
+    def start(self):
+        self.loop.run_until_complete(self.handshake())
+
+    def read(self):
+        return self.loop.run_until_complete(self.read_output())
+
+
+class AioClient(BaseClient):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs, isasync=True)
+        self._closed = False
+        self._events = {}
+
+    async def register_event(self, event: str, func: callable, args=None):
+        if args is None:
+            args = {}
+        if not inspect.iscoroutinefunction(func):
+            raise InvalidArgument('Coroutine', 'Subroutine', 'Event function must be a coroutine')
+        elif len(inspect.signature(func).parameters) != 1:
+            raise ArgumentError
+        await self.subscribe(event, args)
+        self._events[event.lower()] = func
+
+    async def unregister_event(self, event: str, args=None):
+        if args is None:
+            args = {}
+        event = event.lower()
+        if event not in self._events:
+            raise EventNotFound
+        await self.unsubscribe(event, args)
+        del self._events[event]
+
+    # noinspection PyProtectedMember
+    def on_event(self, data):
+        if self.sock_reader._eof:
+            raise PyPresenceException('feed_data after feed_eof')
+        if not data:
+            return
+        self.sock_reader._buffer.extend(data)
+        self.sock_reader._wakeup_waiter()
+        if (self.sock_reader._transport is not None and
+                not self.sock_reader._paused and
+                len(self.sock_reader._buffer) > 2 * self.sock_reader._limit):
+            try:
+                self.sock_reader._transport.pause_reading()
+            except NotImplementedError:
+                self.sock_reader._transport = None
+            else:
+                self.sock_reader._paused = True
+
+        payload = json.loads(data[8:].decode('utf-8'))
+
+        if payload["evt"] is not None:
+            evt = payload["evt"].lower()
+            if evt in self._events:
+                asyncio.create_task(self._events[evt](payload["data"]))
+            elif evt == 'error':
+                raise DiscordError(payload["data"]["code"], payload["data"]["message"])
+
+    async def authorize(self, client_id: str, scopes: List[str]):
+        payload = Payload.authorize(client_id, scopes)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def authenticate(self, token: str):
+        payload = Payload.authenticate(token)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def get_guilds(self):
+        payload = Payload.get_guilds()
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def get_guild(self, guild_id: str):
+        payload = Payload.get_guild(guild_id)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def get_channel(self, channel_id: str):
+        payload = Payload.get_channel(channel_id)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def get_channels(self, guild_id: str):
+        payload = Payload.get_channels(guild_id)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def set_user_voice_settings(self, user_id: str, pan_left: float | None = None,
+                                      pan_right: float | None = None, volume: int | None = None,
+                                      mute: bool | None = None):
+        payload = Payload.set_user_voice_settings(user_id, pan_left, pan_right, volume, mute)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def select_voice_channel(self, channel_id: str):
+        payload = Payload.select_voice_channel(channel_id)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def get_selected_voice_channel(self):
+        payload = Payload.get_selected_voice_channel()
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def select_text_channel(self, channel_id: str):
+        payload = Payload.select_text_channel(channel_id)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def set_activity(self, pid: int = os.getpid(),
+                           activity_type: ActivityType | None = None,
+                           state: str | None = None, details: str | None = None,
+                           start: int | None = None, end: int | None = None,
+                           large_image: str | None = None, large_text: str | None = None,
+                           small_image: str | None = None, small_text: str | None = None,
+                           party_id: str | None = None, party_size: list | None = None,
+                           join: str | None = None, spectate: str | None = None,
+                           buttons: list | None = None,
+                           match: str | None = None, instance: bool = True):
+        payload = Payload.set_activity(pid, activity_type, state, details, start, end, large_image,
+                                       large_text, small_image, small_text, party_id, party_size,
+                                       join, spectate, match, buttons, instance, activity=True)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def clear_activity(self, pid: int = os.getpid()):
+        payload = Payload.set_activity(pid, activity=None)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def subscribe(self, event: str, args=None):
+        if args is None:
+            args = {}
+        payload = Payload.subscribe(event, args)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def unsubscribe(self, event: str, args=None):
+        if args is None:
+            args = {}
+        payload = Payload.unsubscribe(event, args)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def get_voice_settings(self):
+        payload = Payload.get_voice_settings()
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def set_voice_settings(self, _input: dict | None = None, output: dict | None = None,
+                                 mode: dict | None = None, automatic_gain_control: bool | None = None,
+                                 echo_cancellation: bool | None = None, noise_suppression: bool | None = None,
+                                 qos: bool | None = None, silence_warning: bool | None = None,
+                                 deaf: bool | None = None, mute: bool | None = None):
+        payload = Payload.set_voice_settings(_input, output, mode, automatic_gain_control, echo_cancellation,
+                                             noise_suppression, qos, silence_warning, deaf, mute)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def capture_shortcut(self, action: str):
+        payload = Payload.capture_shortcut(action)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def send_activity_join_invite(self, user_id: str):
+        payload = Payload.send_activity_join_invite(user_id)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def close_activity_request(self, user_id: str):
+        payload = Payload.close_activity_request(user_id)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    def close(self):
+        self.send_data(2, {'v': 1, 'client_id': self.client_id})
+        self.sock_writer.close()
+        self._closed = True
+        self.loop.close()
+
+    async def start(self):
+        await self.handshake()
+
+    async def read(self):
+        return await self.read_output()

pypresence/exceptions.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+
+class PyPresenceException(Exception):
+    def __init__(self, message: str | None = None):
+        if message is None:
+            message = 'An error has occurred within PyPresence'
+        super().__init__(message)
+
+
+class DiscordNotFound(PyPresenceException):
+    def __init__(self):
+        super().__init__('Could not find Discord installed and running on this machine.')
+
+
+class InvalidPipe(PyPresenceException):
+    def __init__(self):
+        super().__init__('Pipe Not Found - Is Discord Running?')
+
+
+class InvalidArgument(PyPresenceException):
+    def __init__(self, expected, received, description: str | None = None):
+        description = '\n{0}'.format(description) if description else ''
+        super().__init__('Bad argument passed. Expected {0} but got {1} instead{2}'.format(expected, received,
+                                                                                           description)
+                         )
+
+
+class ServerError(PyPresenceException):
+    def __init__(self, message: str):
+        super().__init__(message.replace(']', '').replace('[', '').capitalize())
+
+
+class DiscordError(PyPresenceException):
+    def __init__(self, code: int, message: str, override: bool = False):
+        self.code = code
+        self.message = message
+        super().__init__('Error Code: {0} Message: {1}'.format(code, message) if not override else message)
+
+
+class InvalidID(DiscordError):
+    def __init__(self):
+        super().__init__(4000, 'Client ID is Invalid')
+
+
+class ArgumentError(PyPresenceException):
+    def __init__(self):
+        super().__init__('Supplied function must have one argument.')
+
+
+class EventNotFound(PyPresenceException):
+    def __init__(self, event):
+        super().__init__('No event with name {0} exists.'.format(event))
+
+
+class PipeClosed(PyPresenceException):
+    def __init__(self):
+        super().__init__('The pipe was closed. Catch this exception and re-connect your instance.')
+
+
+class ResponseTimeout(PyPresenceException):
+    def __init__(self):
+        super().__init__('No response was received from the pipe in time')
+
+
+class ConnectionTimeout(PyPresenceException):
+    def __init__(self):
+        super().__init__('Unable to create a connection to the pipe in time')

pypresence/payloads.py

@@ -0,0 +1,316 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+
+from .utils import remove_none
+from .types import ActivityType
+
+
+class Payload:
+
+    def __init__(self, data, clear_none=True):
+        if clear_none:
+            data = remove_none(data)
+        self.data = data
+
+    def __str__(self):
+        return json.dumps(self.data, indent=2)
+
+    @staticmethod
+    def time():
+        return time.time()
+
+    @classmethod
+    def set_activity(cls, pid: int = os.getpid(),
+                     activity_type: ActivityType | None = None,
+                     state: str | None = None, details: str | None = None,
+                     start: int | None = None, end: int | None = None,
+                     large_image: str | None = None, large_text: str | None = None,
+                     small_image: str | None = None, small_text: str | None = None,
+                     party_id: str | None = None, party_size: list | None = None,
+                     join: str | None = None, spectate: str | None = None,
+                     match: str | None = None, buttons: list | None = None,
+                     instance: bool = True, activity: bool | None = True,
+                     _rn: bool = True):
+
+        # They should already be an int because we give typehints, but some people are fucking stupid and use
+        # IDLE or some other stupid shit.
+        if start:
+            start = int(start)
+        if end:
+            end = int(end)
+        if activity_type:
+            if isinstance(activity_type, ActivityType):
+                activity_type = activity_type.value
+            else:
+                activity_type = int(activity_type)
+
+        if activity is None:
+            act_details = None
+            clear = True
+        else:
+            act_details = {
+                    "type": activity_type,
+                    "state": state,
+                    "details": details,
+                    "timestamps": {
+                        "start": start,
+                        "end": end
+                    },
+                    "assets": {
+                        "large_image": large_image,
+                        "large_text": large_text,
+                        "small_image": small_image,
+                        "small_text": small_text
+                    },
+                    "party": {
+                        "id": party_id,
+                        "size": party_size
+                    },
+                    "secrets": {
+                        "join": join,
+                        "spectate": spectate,
+                        "match": match
+                    },
+                    "buttons": buttons,
+                    "instance": instance
+                }
+            clear = False
+
+        payload = {
+            "cmd": "SET_ACTIVITY",
+            "args": {
+                "pid": pid,
+                "activity": act_details
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+        if _rn:
+            clear = _rn
+        return cls(payload, clear)
+
+    @classmethod
+    def authorize(cls, client_id: str, scopes: list[str]):
+        payload = {
+            "cmd": "AUTHORIZE",
+            "args": {
+                "client_id": str(client_id),
+                "scopes": scopes
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+        return cls(payload)
+
+    @classmethod
+    def authenticate(cls, token: str):
+        payload = {
+            "cmd": "AUTHENTICATE",
+            "args": {
+                "access_token": token
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def get_guilds(cls):
+        payload = {
+            "cmd": "GET_GUILDS",
+            "args": {
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def get_guild(cls, guild_id: str):
+        payload = {
+            "cmd": "GET_GUILD",
+            "args": {
+                "guild_id": str(guild_id),
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def get_channels(cls, guild_id: str):
+        payload = {
+            "cmd": "GET_CHANNELS",
+            "args": {
+                "guild_id": str(guild_id),
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def get_channel(cls, channel_id: str):
+        payload = {
+            "cmd": "GET_CHANNEL",
+            "args": {
+                "channel_id": str(channel_id),
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def set_user_voice_settings(cls, user_id: str, pan_left: float | None = None,
+                                pan_right: float | None = None, volume: int | None = None,
+                                mute: bool | None = None):
+        payload = {
+            "cmd": "SET_USER_VOICE_SETTINGS",
+            "args": {
+                "user_id": str(user_id),
+                "pan": {
+                    "left": pan_left,
+                    "right": pan_right
+                },
+                "volume": volume,
+                "mute": mute
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload, True)
+
+    @classmethod
+    def select_voice_channel(cls, channel_id: str):
+        payload = {
+            "cmd": "SELECT_VOICE_CHANNEL",
+            "args": {
+                "channel_id": str(channel_id),
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def get_selected_voice_channel(cls):
+        payload = {
+            "cmd": "GET_SELECTED_VOICE_CHANNEL",
+            "args": {
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def select_text_channel(cls, channel_id: str):
+        payload = {
+            "cmd": "SELECT_TEXT_CHANNEL",
+            "args": {
+                "channel_id": str(channel_id),
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def subscribe(cls, event: str, args=None):
+        if args is None:
+            args = {}
+        payload = {
+            "cmd": "SUBSCRIBE",
+            "args": args,
+            "evt": event.upper(),
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def unsubscribe(cls, event: str, args=None):
+        if args is None:
+            args = {}
+        payload = {
+            "cmd": "UNSUBSCRIBE",
+            "args": args,
+            "evt": event.upper(),
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def get_voice_settings(cls):
+        payload = {
+            "cmd": "GET_VOICE_SETTINGS",
+            "args": {
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def set_voice_settings(cls, _input: dict | None = None, output: dict | None = None,
+                           mode: dict | None = None, automatic_gain_control: bool | None = None,
+                           echo_cancellation: bool | None = None, noise_suppression: bool | None = None,
+                           qos: bool | None = None, silence_warning: bool | None = None,
+                           deaf: bool | None = None, mute: bool | None = None):
+        payload = {
+            "cmd": "SET_VOICE_SETTINGS",
+            "args": {
+                "input": _input,
+                "output": output,
+                "mode": mode,
+                "automatic_gain_control": automatic_gain_control,
+                "echo_cancellation": echo_cancellation,
+                "noise_suppression": noise_suppression,
+                "qos": qos,
+                "silence_warning": silence_warning,
+                "deaf": deaf,
+                "mute": mute
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload, True)
+
+    @classmethod
+    def capture_shortcut(cls, action: str):
+        payload = {
+            "cmd": "CAPTURE_SHORTCUT",
+            "args": {
+                "action": action.upper()
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def send_activity_join_invite(cls, user_id: str):
+        payload = {
+            "cmd": "SEND_ACTIVITY_JOIN_INVITE",
+            "args": {
+                "user_id": str(user_id)
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)
+
+    @classmethod
+    def close_activity_request(cls, user_id: str):
+        payload = {
+            "cmd": "CLOSE_ACTIVITY_REQUEST",
+            "args": {
+                "user_id": str(user_id)
+            },
+            "nonce": '{:.20f}'.format(cls.time())
+        }
+
+        return cls(payload)

pypresence/presence.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+import os
+import sys
+
+from .baseclient import BaseClient
+from .payloads import Payload
+from .utils import get_event_loop
+from .types import ActivityType
+
+
+class Presence(BaseClient):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def update(self, pid: int = os.getpid(),
+               activity_type: ActivityType | None = None,
+               state: str | None = None, details: str | None = None,
+               start: int | None = None, end: int | None = None,
+               large_image: str | None = None, large_text: str | None = None,
+               small_image: str | None = None, small_text: str | None = None,
+               party_id: str | None = None, party_size: list | None = None,
+               join: str | None = None, spectate: str | None = None,
+               match: str | None = None, buttons: list | None = None,
+               instance: bool = True, payload_override: dict | None = None):
+
+        if payload_override is None:
+            payload = Payload.set_activity(pid=pid, activity_type=activity_type, state=state, details=details,
+                                           start=start, end=end, large_image=large_image, large_text=large_text,
+                                           small_image=small_image, small_text=small_text, party_id=party_id,
+                                           party_size=party_size, join=join, spectate=spectate,
+                                           match=match, buttons=buttons, instance=instance, activity=True)
+        else:
+            payload = payload_override
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def clear(self, pid: int = os.getpid()):
+        payload = Payload.set_activity(pid, activity=None)
+        self.send_data(1, payload)
+        return self.loop.run_until_complete(self.read_output())
+
+    def connect(self):
+        self.update_event_loop(get_event_loop())
+        self.loop.run_until_complete(self.handshake())
+
+    def close(self):
+        self.send_data(2, {'v': 1, 'client_id': self.client_id})
+        self.loop.close()
+        if sys.platform == 'win32':
+            self.sock_writer._call_connection_lost(None)
+
+
+class AioPresence(BaseClient):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs, isasync=True)
+
+    async def update(self, pid: int = os.getpid(),
+                     activity_type: ActivityType | None = None,
+                     state: str | None = None, details: str | None = None,
+                     start: int | None = None, end: int | None = None,
+                     large_image: str | None = None, large_text: str | None = None,
+                     small_image: str | None = None, small_text: str | None = None,
+                     party_id: str | None = None, party_size: list | None = None,
+                     join: str | None = None, spectate: str | None = None,
+                     match: str | None = None, buttons: list | None = None,
+                     instance: bool = True):
+        payload = Payload.set_activity(pid=pid, activity_type=activity_type, state=state, details=details,
+                                       start=start, end=end, large_image=large_image, large_text=large_text,
+                                       small_image=small_image, small_text=small_text, party_id=party_id,
+                                       party_size=party_size, join=join, spectate=spectate,
+                                       match=match, buttons=buttons, instance=instance, activity=True)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def clear(self, pid: int = os.getpid()):
+        payload = Payload.set_activity(pid, activity=None)
+        self.send_data(1, payload)
+        return await self.read_output()
+
+    async def connect(self):
+        self.update_event_loop(get_event_loop())
+        await self.handshake()
+
+    def close(self):
+        self.send_data(2, {'v': 1, 'client_id': self.client_id})
+        self.loop.close()
+        if sys.platform == 'win32':
+            self.sock_writer._call_connection_lost(None)

pypresence/types.py

@@ -0,0 +1,15 @@
+import enum
+
+
+class ActivityType(enum.Enum):
+    """
+    https://discord.com/developers/docs/game-sdk/activities#data-models-activitytype-enum
+    "type" must be one of 0, 2, 3, 5 -- Discord only implemented these four
+    """
+
+    PLAYING = 0
+    # STREAMING = 1
+    LISTENING = 2
+    WATCHING = 3
+    # CUSTOM = 4
+    COMPETING = 5

pypresence/utils.py

@@ -0,0 +1,64 @@
+"""Util functions that are needed but messy."""
+import asyncio
+import os
+import sys
+import tempfile
+import socket
+
+
+def remove_none(d: dict):
+    for item in d.copy():
+        if isinstance(d[item], dict):
+            if len(d[item]):
+                d[item] = remove_none(d[item])
+            if not len(d[item]):
+                del d[item]
+        elif d[item] is None:
+            del d[item]
+    return d
+
+
+def test_ipc_path(path) -> bool:
+    '''Tests an IPC pipe to ensure that it actually works'''
+    if sys.platform == 'win32':
+        with open(path):
+            return True
+    else:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
+            client.connect(path)
+            return True
+
+
+# Returns on first IPC pipe matching Discord's
+def get_ipc_path(pipe=None):
+    ipc = 'discord-ipc-'
+    if pipe is not None:
+        ipc = f"{ipc}{pipe}"
+
+    if sys.platform in ('linux', 'darwin'):
+        tempdir = os.environ.get('XDG_RUNTIME_DIR') or (f"/run/user/{os.getuid()}" if os.path.exists(f"/run/user/{os.getuid()}") else tempfile.gettempdir())
+        paths = ['.', 'snap.discord', 'app/com.discordapp.Discord', 'app/com.discordapp.DiscordCanary']
+    elif sys.platform == 'win32':
+        tempdir = r'\\?\pipe'
+        paths = ['.']
+    else:
+        return
+
+    for path in paths:
+        full_path = os.path.abspath(os.path.join(tempdir, path))
+        if sys.platform == 'win32' or os.path.isdir(full_path):
+            for entry in os.scandir(full_path):
+                if entry.name.startswith(ipc) and os.path.exists(entry) and test_ipc_path(entry.path):
+                    return entry.path
+
+
+def get_event_loop(force_fresh: bool = False):
+    if force_fresh:
+        return asyncio.new_event_loop()
+    try:
+        running = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.new_event_loop()
+    if running.is_closed():
+        return asyncio.new_event_loop()
+    return running