pypresence

https://qwertyquerty.github.io/pypresence/html/
Admin
pypresence is a Python library for interacting with Discord's Rich Presence and Client APIs,...
Tokens:13,937
Snippets:88
Trust Score:8.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Basic Rich Presence using Pypresence

Source: https://qwertyquerty.github.io/pypresence/html/_sources/info/examples.rst

This example demonstrates how to set up a basic rich presence using the Pypresence library. It requires the 'pypresence' package to be installed. The code initializes the Discord client and sets the presence.

```python
from pypresence import DiscordRPC

RPC_CLIENT_ID = 'YOUR_CLIENT_ID'  # Replace with your client ID

def update_presence():
    RPC = DiscordRPC(endpoint=f'unix://{os.environ["XDG_RUNTIME_DIR"]}/discord-ipc-0') # DO NOT CHANGE
    RPC.connect()

    presence = {
        "state": "Playing a game",
        "details": "In the main menu",
        "timestamps": {
            "start": time.time()
        },
        "large_image": "your_large_image_key",  # Replace with your large image key
        "large_text": "Game Name",
        "small_image": "your_small_image_key",  # Replace with your small image key
        "small_text": "Status",
        "buttons": [
            {"label": "Button 1", "url": "https://example.com"},
            {"label": "Button 2", "url": "https://example.com"}
        ]
    }

    RPC.set_activity(presence)
    print("Presence updated")

if __name__ == "__main__":
    update_presence()
```

--------------------------------

### Customize Activity and Status Display Types (Python)

Source: https://qwertyquerty.github.io/pypresence/html/_sources/info/quickstart.rst

Demonstrates how to use ActivityType and StatusDisplayType enums to customize the presence. This allows changing the display from 'Playing' to 'Listening' and controlling which information (like state or details) is shown in the user's status.

```python
from pypresence import Presence
from pypresence.types import ActivityType, StatusDisplayType
import time

client_id = "ID HERE"
RPC = Presence(client_id)
RPC.connect()

# Show as "Listening to" instead of "Playing"
RPC.update(
    activity_type=ActivityType.LISTENING,
    details="My Favorite Song",
    state="By My Favorite Artist"
)

# Or use StatusDisplayType to control what appears in the user's status
RPC.update(
    status_display_type=StatusDisplayType.STATE,
    state="Building something awesome",
    details="Using pypresence"
)

while True:
    time.sleep(15)
```

--------------------------------

### Make Presence Interactive with URLs (Python)

Source: https://qwertyquerty.github.io/pypresence/html/_sources/info/quickstart.rst

Shows how to make parts of the Discord Rich Presence clickable by associating URLs with state, details, and images. This allows users to click on elements like game names or status indicators to open specific web links.

```python
from pypresence import Presence
import time

client_id = "ID HERE"
RPC = Presence(client_id)
RPC.connect()

# Make state and details clickable
RPC.update(
    state="Playing an Awesome Game",
    state_url="https://example.com/game",
    details="In the Main Menu",
    details_url="https://example.com/game/menu"
)

# Make images clickable
RPC.update(
    large_image="game_logo",
    large_text="My Game",
    large_url="https://example.com/game",
    small_image="status_online",
    small_text="Online",
    small_url="https://example.com/status"
)

while True:
    time.sleep(15)
```

--------------------------------

### Import PyPresence and Initialize Client (Python)

Source: https://qwertyquerty.github.io/pypresence/html/_sources/info/quickstart.rst

Imports the necessary Presence class from pypresence and the time module. It then initializes the Presence client with a provided Client ID, which is essential for connecting to Discord's Rich Presence service.

```python
from pypresence import Presence # The simple rich presence client in pypresence
import time
```

```python
client_id = "ID HERE"  # Put your Client ID in here
RPC = Presence(client_id)  # Initialize the Presence client
```

--------------------------------

### Import PyPresence and Time

Source: https://qwertyquerty.github.io/pypresence/html/info/quickstart

Imports the necessary Presence class from the pypresence library and the time module for managing update intervals. This is the first step in creating a Discord Rich Presence application.

```python
from pypresence import Presence
import time
```

--------------------------------

### Connect PyPresence Client to Discord

Source: https://qwertyquerty.github.io/pypresence/html/info/quickstart

Establishes a connection between the PyPresence client and Discord to enable sending presence updates. This step is crucial for your rich presence to appear on Discord.

```python
RPC.connect() # Start the handshake loop
```

--------------------------------

### Basic Discord Rich Presence with pypypresence

Source: https://qwertyquerty.github.io/pypresence/html/info/examples

This example shows how to initialize pypresence, connect to Discord, and set a basic Rich Presence with state, details, and name. It requires a valid Discord Client ID and runs indefinitely, updating the presence every 15 seconds. The 'pypresence' library is the primary dependency.

```python
from pypresence import Presence
import time

client_id = "717091213148160041"  # Fake ID, put your real one here
RPC = Presence(client_id)  # Initialize the client class
RPC.connect()  # Start the handshake loop

print(
    RPC.update(
        state="Here it is!",
        details="A working presence, from python!",
        name="Rich Presence Example",
    )
)  # Set the presence

while True:  # The presence will stay on as long as the program is running
    time.sleep(15)  # Can only update rich presence every 15 seconds

```

--------------------------------

### Initialize PyPresence Client

Source: https://qwertyquerty.github.io/pypresence/html/info/quickstart

Initializes the Rich Presence client using your Discord application's Client ID. Ensure you have created a Discord RPC app and obtained its Client ID from the Discord Developer Portal. This client will be used to connect to Discord and send presence updates.

```python
client_id = "ID HERE"  # Put your Client ID in here
RPC = Presence(client_id)  # Initialize the Presence client
```

--------------------------------

### Connect and Update Rich Presence (Python)

Source: https://qwertyquerty.github.io/pypresence/html/_sources/info/quickstart.rst

Connects the initialized PyPresence client to Discord to enable presence updates. The update() function is then used to set the presence status, including state, details, and the application name. A loop keeps the program running to maintain the presence.

```python
RPC.connect() # Start the handshake loop
```

```python
RPC.update(
    state="Here it is!",
    details="A working presence, from python!",
    name="Rich Presence Example",
) # Updates our presence
```

```python
while True:  # The presence will stay on as long as the program is running
    time.sleep(15) # Can only update rich presence every 15 seconds
```

--------------------------------

### Rich Presence with CPU Usage using Pypresence

Source: https://qwertyquerty.github.io/pypresence/html/_sources/info/examples.rst

This example showcases how to display CPU usage in your Discord rich presence using Pypresence. It requires the 'pypresence' and 'psutil' packages. The code continuously updates the presence with the current CPU percentage.

```python
from pypresence import DiscordRPC
import psutil
import time
import os

RPC_CLIENT_ID = 'YOUR_CLIENT_ID'  # Replace with your client ID

def update_presence_with_cpu():
    RPC = DiscordRPC(endpoint=f'unix://{os.environ["XDG_RUNTIME_DIR"]}/discord-ipc-0') # DO NOT CHANGE
    RPC.connect()

    while True:
        cpu_percent = psutil.cpu_percent()
        presence = {
            "state": f"CPU Usage: {cpu_percent}%",
            "details": "Monitoring System",
            "large_image": "your_large_image_key",
            "large_text": "System Monitor",
        }
        RPC.set_activity(presence)
        time.sleep(15)  # Update every 15 seconds

if __name__ == "__main__":
    update_presence_with_cpu()
```

--------------------------------

### Discord Rich Presence Showing CPU and RAM Usage with pypresence

Source: https://qwertyquerty.github.io/pypresence/html/info/examples

This example demonstrates how to display real-time CPU and RAM usage in Discord Rich Presence. It uses the 'psutil' library to fetch system metrics and 'pypresence' to update the Discord status. The presence is updated every 15 seconds and requires a Discord Client ID.

```python
import psutil
from pypresence import Presence
import time

client_id = "64567352374564"  # Fake ID, put your real one here
RPC = Presence(client_id, pipe=0)  # Initialize the client class
RPC.connect()  # Start the handshake loop


while True:  # The presence will stay on as long as the program is running
    cpu_per = round(psutil.cpu_percent(), 1)  # Get CPU Usage
    mem = psutil.virtual_memory()
    mem_per = round(psutil.virtual_memory().percent, 1)
    print(
        RPC.update(
            details="RAM: " + str(mem_per) + "%", state="CPU: " + str(cpu_per) + "%"
        )
    )  # Set the presence
    time.sleep(15)  # Can only update rich presence every 15 seconds

```

--------------------------------

### Combine Clickable URLs with Buttons in Rich Presence

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

This example demonstrates how to combine clickable text and image URLs with explicit buttons in a Rich Presence update. It shows how to link various elements of the presence to different URLs, including custom buttons for specific actions.

```python
RPC.update(
    state="Building Something Cool",
    state_url="https://github.com/username",
    details="pypresence with URL support",
    details_url="https://github.com/qwertyquerty/pypresence",
    large_image="project_logo",
    large_url="https://project-website.com",
    buttons=[
        {"label": "View Project", "url": "https://github.com/username/project"},
        {"label": "Documentation", "url": "https://docs.project.com"}
    ]
)
```

--------------------------------

### Connection Management

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Functions to start and close the connection to the Discord client.

```APIDOC
## start()

### Description
Initializes the connection - must be done in order to run RPC commands.

### Method
GET/POST (Internal)

### Endpoint
N/A

### Parameters
None

### Request Example
```python
client.start()
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - The response from the Discord client.

## close()

### Description
Closes the connection to the Discord client.

### Method
GET/POST (Internal)

### Endpoint
N/A

### Parameters
None

### Request Example
```python
client.close()
```

### Response
#### Success Response (200)
This method does not return a value.
```

--------------------------------

### Update Discord Rich Presence

Source: https://qwertyquerty.github.io/pypresence/html/info/quickstart

Sets the rich presence details that will be displayed on Discord. The `update()` function can be customized with parameters like `state`, `details`, and `name`. This function updates the presence displayed to other users.

```python
RPC.update(
    state="Here it is!",
    details="A working presence, from python!",
    name="Rich Presence Example",
) # Updates our presence
```

--------------------------------

### Rich Presence Looping Through Quotes using Pypresence

Source: https://qwertyquerty.github.io/pypresence/html/_sources/info/examples.rst

This example demonstrates how to cycle through a list of quotes in your Discord rich presence using Pypresence. It requires the 'pypresence' package. The code iterates through predefined quotes and updates the presence accordingly.

```python
from pypresence import DiscordRPC
import time
import os

RPC_CLIENT_ID = 'YOUR_CLIENT_ID'  # Replace with your client ID

QUOTES = [
    "Quote 1: Be the change you want to see.",
    "Quote 2: The only way to do great work is to love what you do.",
    "Quote 3: Strive not to be a success, but rather to be of value."
]

def update_presence_loop():
    RPC = DiscordRPC(endpoint=f'unix://{os.environ["XDG_RUNTIME_DIR"]}/discord-ipc-0') # DO NOT CHANGE
    RPC.connect()

    quote_index = 0
    while True:
        current_quote = QUOTES[quote_index % len(QUOTES)]
        presence = {
            "state": current_quote,
            "details": "Inspirational Quotes",
            "large_image": "your_large_image_key",
            "large_text": "Quote Display",
        }
        RPC.set_activity(presence)
        quote_index += 1
        time.sleep(30)  # Change quote every 30 seconds

if __name__ == "__main__":
    update_presence_loop()
```

--------------------------------

### Keep Presence Active with a Loop

Source: https://qwertyquerty.github.io/pypresence/html/info/quickstart

Ensures the Discord Rich Presence remains active by running an infinite loop. A `time.sleep(15)` is included to adhere to Discord's rate limits, allowing presence updates only every 15 seconds. The presence stays active as long as the program is running.

```python
while True:
    time.sleep(15) # Can only update rich presence every 15 seconds
```

--------------------------------

### Looping Quotes in Discord Rich Presence with pypresence

Source: https://qwertyquerty.github.io/pypresence/html/info/examples

This example cycles through a predefined list of quotes, displaying a random one in Discord Rich Presence. It uses the 'random' module to select quotes and 'pypresence' to update the status. The presence is updated every 60 seconds and requires a Discord Client ID. The 'pypresence' library is the primary dependency.

```python
from pypresence import Presence
import time
import random

client_id = "64567352374564"  # Put your Client ID here, this is a fake ID
RPC = Presence(client_id)  # Initialize the Presence class
RPC.connect()  # Start the handshake loop


quotes = [
    "If you can dream it, you can achieve it.",
    "Either write something worth reading or do something worth writing.",
    "You become what you believe.",
    "Fall seven times and stand up eight.",
    "The best revenge is massive success.",
    "Eighty percent of success is showing up.",
    "Life is what happens to you while you’re busy making other plans.",
    "Strive not to be a success, but rather to be of value.",
    "The best time to plant a tree was 20 years ago. The second best time is now.",
    "Everything you’ve ever wanted is on the other side of fear.",
]  # The quotes to choose from


while True:  # The presence will stay on as long as the program is running
    RPC.update(
        details="Famous Quote:", state=random.choice(quotes)
    )  # Set the presence, picking a random quote
    time.sleep(60)  # Wait a wee bit

```

--------------------------------

### Get Voice Settings

Source: https://qwertyquerty.github.io/pypresence/html/doc/client

Retrieves the current user's voice connection settings.

```APIDOC
## GET /api/voice/settings

### Description
Retrieves the current user's voice settings, including input, output, and various audio processing options.

### Method
GET

### Endpoint
/api/voice/settings

### Response
#### Success Response (200)
- **input** (dict) - Input device settings.
- **output** (dict) - Output device settings.
- **mode** (dict) - Voice mode settings.
- **automatic_gain_control** (bool) - State of automatic gain control.
- **echo_cancellation** (bool) - State of echo cancellation.
- **noise_suppression** (bool) - State of noise suppression.
- **qos** (bool) - State of voice quality of service.
- **silence_warning** (bool) - State of silence warning notice.
- **deaf** (bool) - State of self-deafen.
- **mute** (bool) - State of self-mute.

#### Response Example
```json
{
  "input": {"device_id": "default", "sensitivity": 0},
  "output": {"device_id": "default", "volume": 100},
  "mode": {"type": "VOICE"},
  "automatic_gain_control": true,
  "echo_cancellation": true,
  "noise_suppression": true,
  "qos": true,
  "silence_warning": false,
  "deaf": false,
  "mute": false
}
```
```

--------------------------------

### connect()

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

Initializes the connection to Discord, enabling Rich Presence updates.

```APIDOC
## connect()

### Description
Initializes the connection - must be done in order to make any updates to Rich Presence.

### Return Type
* pypresence.Response
```

--------------------------------

### Client Initialization

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Initializes the RPC client for interacting with Discord.

```APIDOC
## Client()

### Description
Creates the RPC client ready for usage.

### Method
Constructor

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **client_id** (str) - Required - OAuth2 App ID (found at https://discord.com/developers/applications/me)
- **pipe** (int) - Optional - Pipe that should be used to connect to the Discord client. Defaults to 0, can be 0-9
- **loop** (asyncio.BaseEventLoop) - Optional - Your own event loop (if you have one) that PyPresence should use. One will be created if not supplied.
- **handler** (function) - Optional - The exception handler pypresence should send asynchronous errors to. This can be a coroutine or standard function as long as it takes two arguments (exception, future). Exception will be the exception to handle and future will be an instance of asyncio.Future

### Request Example
```python
from pypresence import Client
client = Client(client_id="YOUR_CLIENT_ID")
```

### Response
#### Success Response (200)
This is a constructor, no direct response.
```

--------------------------------

### Presence Class Initialization

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

Initializes the Presence client, preparing it for usage with Discord Rich Presence.

```APIDOC
## Presence()

### Description
Creates the Presence client ready for usage.

### Parameters
* **client_id** (str) - OAuth2 App ID (found here)
* **pipe** (int) - Pipe that should be used to connect to the Discord client. Defaults to 0, can be 0-9
* **loop** (asyncio.BaseEventLoop) - Your own event loop (if you have one) that PyPresence should use. One will be created if not supplied.
* **handler** (function) - The exception handler pypresence should send asynchronous errors to. This can be a coroutine or standard function as long as it takes two arguments (exception, future).

### Return Type
* pypresence.Presence
```

--------------------------------

### Initialize and Connect PyPresence

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/presence.rst

Creates a Presence client and initializes the connection to Discord. This must be done before any presence updates. Requires a client ID.

```python
from pypresence import Presence

RPC = Presence("YOUR_CLIENT_ID")
RPC.connect()
```

--------------------------------

### Presence Client Initialization

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/presence.rst

Initializes the Presence client for Discord Rich Presence. Requires your Discord application's OAuth2 App ID.

```APIDOC
## Presence Client Initialization

### Description
Creates the Presence client ready for usage. This is the first step to interacting with Discord Rich Presence.

### Method
Constructor

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **client_id** (str) - Required - OAuth2 App ID (found at https://discord.com/developers/applications/me)
- **pipe** (int) - Optional - Pipe that should be used to connect to the Discord client. Defaults to 0, can be 0-9.
- **loop** (asyncio.BaseEventLoop) - Optional - Your own event loop (if you have one) that PyPresence should use. One will be created if not supplied.
- **handler** (function) - Optional - The exception handler pypresence should send asynchronous errors to. This can be a coroutine or standard function as long as it takes two arguments (exception, future).

### Request Example
```python
from pypresence import Presence

RPC = Presence("YOUR_CLIENT_ID")
```

### Response
#### Success Response (200)
N/A (Constructor)

#### Response Example
N/A
```

--------------------------------

### PyPresence Client Initialization and Connection

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

Initializes the PyPresence client with a client ID and connects to Discord. The client_id is your OAuth2 App ID. Optional parameters include pipe for Discord client connection, an asyncio event loop, and an exception handler. The connect() method must be called to enable Rich Presence updates.

```python
from pypresence import Presence
from pypresence.types import ActivityType

RPC = Presence(client_id)
RPC.connect()
```

--------------------------------

### Capture Shortcut

Source: https://qwertyquerty.github.io/pypresence/html/doc/client

Captures a keyboard shortcut action initiated by the user.

```APIDOC
## POST /api/shortcuts/capture

### Description
Used to capture a keyboard shortcut entered by the user. This can be used for custom in-game keybindings or commands.

### Method
POST

### Endpoint
/api/shortcuts/capture

### Parameters
#### Request Body
- **action** (string) - Required - Capture action, either 'START' or 'STOP'.

### Request Example
```json
{
  "action": "START"
}
```

### Response
#### Success Response (200)
- **status** (str) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Send Activity Join Invite

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Sends an 'Ask to Join' request to another user. This allows users to invite others to join their current game session.

```APIDOC
## POST /send_activity_join_invite

### Description
Accepts an 'Ask to Join' request from another user. This allows the user to join the game session of the requester.

### Method
POST

### Endpoint
/send_activity_join_invite

### Parameters
#### Query Parameters
- **user_id** (str) - Required - The user ID of the person requesting to join.

### Request Example
```json
{
  "user_id": "123456789012345678"
}
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - Indicates the success or failure of the operation.

#### Response Example
```json
{
  "response": "success"
}
```
```

--------------------------------

### Make Rich Presence Text Clickable with URL Parameters

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

URL parameters like state_url and details_url enable making the state and details text in your Rich Presence clickable, opening a specified URL when clicked. This enhances user engagement by linking to external resources.

```python
from pypresence import Presence

RPC = Presence(client_id)
RPC.connect()
RPC.update(
    state="Playing an Awesome Game",
    state_url="https://example.com/game",
    details="In the Main Menu",
    details_url="https://example.com/game/menu"
)
```

--------------------------------

### Set Voice Settings

Source: https://qwertyquerty.github.io/pypresence/html/doc/client

Configures the user's voice connection settings.

```APIDOC
## PUT /api/voice/settings

### Description
Sets the user's voice settings, allowing customization of input/output devices, audio processing, and mute/deafen states.

### Method
PUT

### Endpoint
/api/voice/settings

### Parameters
#### Request Body
- **input** (dict) - Optional - Input device settings.
- **output** (dict) - Optional - Output device settings.
- **mode** (dict) - Optional - Voice mode settings.
- **automatic_gain_control** (bool) - Optional - State of automatic gain control.
- **echo_cancellation** (bool) - Optional - State of echo cancellation.
- **noise_suppression** (bool) - Optional - State of noise suppression.
- **qos** (bool) - Optional - State of voice quality of service.
- **silence_warning** (bool) - Optional - State of silence warning notice.
- **deaf** (bool) - Optional - State of self-deafen.
- **mute** (bool) - Optional - State of self-mute.

### Request Example
```json
{
  "automatic_gain_control": false,
  "mute": true
}
```

### Response
#### Success Response (200)
- **status** (str) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Send Join Invite

Source: https://qwertyquerty.github.io/pypresence/html/doc/client

Sends an invitation to join a user's activity.

```APIDOC
## POST /api/users/{user_id}/invite/join

### Description
Used to accept an "Ask to Join" request from another user. This sends a confirmation to Discord to allow the user to join your activity.

### Method
POST

### Endpoint
/api/users/{user_id}/invite/join

### Parameters
#### Path Parameters
- **user_id** (str) - Required - The user ID of the person sending the "Ask to Join" request.

### Response
#### Success Response (200)
- **status** (str) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Make Rich Presence Images Clickable with URL Parameters

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

The large_url and small_url parameters allow you to make the large and small images in your Rich Presence clickable, directing users to a specified URL. This is useful for linking game logos or status icons to relevant web pages.

```python
RPC.update(
    large_image="game_logo",
    large_text="My Game",
    large_url="https://example.com/game",
    small_image="status_icon",
    small_text="Online",
    small_url="https://example.com/status"
)
```

--------------------------------

### update()

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

Sets the user's presence on Discord with various activity details.

```APIDOC
## update()

### Description
Sets the user’s presence on Discord.

### Parameters
* **pid** (int) - the process id of your game
* **activity_type** (ActivityType) - the type of activity (PLAYING, LISTENING, WATCHING, or COMPETING). Defaults to PLAYING.
* **status_display_type** (StatusDisplayType) - which field to display in the status (NAME, STATE, or DETAILS). Defaults to NAME.
* **state** (str) - the user’s current status
* **state_url** (str) - URL to make the state text clickable
* **details** (str) - what the player is currently doing
* **details_url** (str) - URL to make the details text clickable
* **name** (str) - directly set what discord will display in places like the user list
* **start** (int) - epoch time for game start (in milliseconds)
* **end** (int) - epoch time for game end (in milliseconds)
* **large_image** (str) - name of the uploaded image for the large profile artwork
* **large_text** (str) - tooltip for the large image
* **large_url** (str) - URL to make the large image clickable
* **small_image** (str) - name of the uploaded image for the small profile artwork
* **small_text** (str) - tooltip for the small image
* **small_url** (str) - URL to make the small image clickable
* **party_id** (str) - id of the player’s party, lobby, or group
* **party_size** (list) - current size of the player’s party, lobby, or group, and the max in this format: `[1,4]`
* **join** (str) - unique hashed string for chat invitations and ask to join
* **spectate** (str) - unique hashed string for spectate button
* **match** (str) - unique hashed string for spectate and join
* **buttons** (list) - list of dicts for buttons on your profile in the format `[{"label": "My Website", "url": "https://qtqt.cf"}, ...]`, can list up to two buttons
* **instance** (bool) - marks the match as a game session with a specific beginning and end

### Return Type
* pypresence.Response
```

--------------------------------

### Close Activity Request

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Rejects an 'Ask to Join' request from another user. This denies the request for the user to join your game session.

```APIDOC
## POST /close_activity_request

### Description
Rejects an 'Ask to Join' request from another user. This denies the request for the user to join your game session.

### Method
POST

### Endpoint
/close_activity_request

### Parameters
#### Query Parameters
- **user_id** (str) - Required - The user ID of the person whose request is being rejected.

### Request Example
```json
{
  "user_id": "123456789012345678"
}
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - Indicates the success or failure of the operation.

#### Response Example
```json
{
  "response": "success"
}
```
```

--------------------------------

### Subscribe to Event

Source: https://qwertyquerty.github.io/pypresence/html/doc/client

Subscribes to a specific Discord event.

```APIDOC
## POST /api/events/subscribe

### Description
Used to subscribe to specific events emitted by Discord. When an event is subscribed to, the library will receive and process these events.

### Method
POST

### Endpoint
/api/events/subscribe

### Parameters
#### Request Body
- **event** (str) - Required - The name of the event to subscribe to.
- **args** (dict) - Optional - Any additional arguments required for the subscription.

### Request Example
```json
{
  "event": "READY",
  "args": {}
}
```

### Response
#### Success Response (200)
- **status** (str) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### ActivityType Enum

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

Defines the available types for Discord activities.

```APIDOC
# ActivityType Enum

### Description
The `ActivityType` enum specifies what type of activity is being displayed. It is imported from `pypresence.types`.

### Available values
* **ActivityType.PLAYING** (0) - Shows “Playing {game name}” (default)
* **ActivityType.LISTENING** (2) - Shows “Listening to {name}”
* **ActivityType.WATCHING** (3) - Shows “Watching {name}”
* **ActivityType.COMPETING** (5) - Shows “Competing in {name}”

### Note
Discord only supports activity types 0, 2, 3, and 5. Types 1 (STREAMING) and 4 (CUSTOM) are not available via Rich Presence.
```

--------------------------------

### Close Join Request

Source: https://qwertyquerty.github.io/pypresence/html/doc/client

Rejects an "Ask to Join" request from another user.

```APIDOC
## DELETE /api/users/{user_id}/request/join

### Description
Used to reject an "Ask to Join" request from another user. This will dismiss the request without joining their activity.

### Method
DELETE

### Endpoint
/api/users/{user_id}/request/join

### Parameters
#### Path Parameters
- **user_id** (str) - Required - The user ID of the person who sent the "Ask to Join" request.

### Response
#### Success Response (200)
- **status** (str) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Authentication

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Functions for authenticating with your Discord application.

```APIDOC
## authorize(client_id, scopes, rpc_token=None, username=None)

### Description
Used to authenticate a new client with your app. By default this pops up a modal in-app that asks the user to authorize access to your app.

### Method
POST

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **client_id** (str) - Required - OAuth2 application id
- **scopes** (list) - Required - A list of OAuth scopes as strings. All the different scopes can be found `here <https://discord.com/developers/docs/topics/oauth2>`_.
- **rpc_token** (str) - Optional - One-time use RPC token.
- **username** (str) - Optional - Username to create a guest account with if the user does not have Discord.

### Request Example
```python
client.authorize(client_id='YOUR_CLIENT_ID', scopes=['identify', 'email'])
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - The response from the Discord client.

## authenticate(token)

### Description
Used to authenticate an existing client with your app.

### Method
POST

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **token** (str) - Required - OAuth2 access token.

### Request Example
```python
client.authenticate(token='YOUR_ACCESS_TOKEN')
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - The response from the Discord client.
```

--------------------------------

### Set Activity

Source: https://qwertyquerty.github.io/pypresence/html/doc/client

Sets or updates the user's Discord Rich Presence activity with various details.

```APIDOC
## POST /api/activity

### Description
Sets or updates the user's Discord Rich Presence activity. This method allows for detailed customization of the presence, including game state, timestamps, images, party information, and join/spectate secrets.

### Method
POST

### Endpoint
/api/activity

### Parameters
#### Request Body
- **state** (str) - Optional - The user's current status.
- **details** (str) - Optional - What the player is currently doing.
- **start** (int) - Optional - Epoch time for game start.
- **end** (int) - Optional - Epoch time for game end.
- **large_image** (str) - Optional - Name of the uploaded image for the large profile artwork.
- **large_text** (str) - Optional - Tooltip for the large image.
- **small_image** (str) - Optional - Name of the uploaded image for the small profile artwork.
- **small_text** (str) - Optional - Tooltip for the small image.
- **party_id** (str) - Optional - ID of the player's party, lobby, or group.
- **party_size** (list) - Optional - Current size of the player's party, lobby, or group, and the max in this format: `[1,4]`.
- **join** (str) - Optional - Unique hashed string for chat invitations and ask to join.
- **spectate** (str) - Optional - Unique hashed string for spectate button.
- **match** (str) - Optional - Unique hashed string for spectate and join.
- **instance** (bool) - Optional - Marks the match as a game session with a specific beginning and end.

### Request Example
```json
{
  "state": "Playing a Game",
  "details": "In the main menu",
  "start": 1678886400,
  "end": 1678890000,
  "large_image": "game_art",
  "large_text": "Awesome Game",
  "small_image": "dlc_icon",
  "small_text": "DLC Available",
  "party_id": "party_123",
  "party_size": [2, 4],
  "join": "join_secret_abc",
  "spectate": "spectate_secret_xyz",
  "match": "match_secret_123",
  "instance": true
}
```

### Response
#### Success Response (200)
- **status** (str) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Presence Management Functions

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/presence.rst

Functions to manage the Discord Rich Presence connection and update the user's presence.

```APIDOC
## Presence Management Functions

### Description
Provides methods to connect to Discord, clear presence, and update presence details.

### connect()

#### Description
Initializes the connection to Discord. Must be called before any presence updates.

#### Method
`connect()`

#### Endpoint
N/A (Internal method)

#### Parameters
None

### clear(pid=os.getpid())

#### Description
Clears the current Rich Presence status on Discord.

#### Method
`clear(pid: int = os.getpid())`

#### Endpoint
N/A (Internal method)

#### Parameters
- **pid** (int) - Optional - The process ID of your game. Defaults to the current process ID.

### close()

#### Description
Closes the connection to Discord.

#### Method
`close()`

#### Endpoint
N/A (Internal method)

#### Parameters
None

### update(**options)

#### Description
Sets the user's presence on Discord with various customizable options.

#### Method
`update(**options)`

#### Endpoint
N/A (Internal method)

#### Parameters
- **pid** (int) - Optional - The process ID of your game.
- **activity_type** (ActivityType) - Optional - The type of activity (PLAYING, LISTENING, WATCHING, or COMPETING). Defaults to PLAYING.
- **status_display_type** (StatusDisplayType) - Optional - Which field to display in the status (NAME, STATE, or DETAILS). Defaults to NAME.
- **state** (str) - Optional - The user's current status text.
- **state_url** (str) - Optional - URL to make the state text clickable.
- **details** (str) - Optional - What the player is currently doing.
- **details_url** (str) - Optional - URL to make the details text clickable.
- **name** (str) - Optional - Directly set what Discord will display in places like the user list.
- **start** (int) - Optional - Epoch time for game start (in milliseconds).
- **end** (int) - Optional - Epoch time for game end (in milliseconds).
- **large_image** (str) - Optional - Name of the uploaded image for the large profile artwork.
- **large_text** (str) - Optional - Tooltip for the large image.
- **large_url** (str) - Optional - URL to make the large image clickable.
- **small_image** (str) - Optional - Name of the uploaded image for the small profile artwork.
- **small_text** (str) - Optional - Tooltip for the small image.
- **small_url** (str) - Optional - URL to make the small image clickable.
- **party_id** (str) - Optional - ID of the player's party, lobby, or group.
- **party_size** (list) - Optional - Current size of the player's party, lobby, or group, and the max in the format: `[1,4]`.
- **join** (str) - Optional - Unique hashed string for chat invitations and ask to join.
- **spectate** (str) - Optional - Unique hashed string for spectate button.
- **match** (str) - Optional - Unique hashed string for spectate and join.
- **buttons** (list) - Optional - List of dictionaries for buttons on your profile in the format `[{"label": "My Website", "url": "https://qtqt.cf"}, ...]`. Can list up to two buttons.
- **instance** (bool) - Optional - Marks the match as a game session with a specific beginning and end.

### Request Example
```python
RPC.update(state="Gaming", details="Playing a cool game", name="My Game")
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - Indicates success or failure of the update operation.

#### Response Example
```json
{
  "response": "Success"
}
```
```

--------------------------------

### clear()

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

Clears the current Rich Presence for the specified process ID.

```APIDOC
## clear()

### Description
Clears the presence.

### Parameters
* **pid** (int) - The process ID of your game. Defaults to the current process ID.

### Return Type
* pypresence.Response
```

--------------------------------

### close()

Source: https://qwertyquerty.github.io/pypresence/html/doc/presence

Closes the connection to Discord.

```APIDOC
## close()

### Description
Closes the connection.

### Return Type
* pypresence.Response
```

--------------------------------

### Set Voice Settings

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Configures the user's Discord voice connection settings. Allows modification of input/output devices, volume, and various audio processing options.

```APIDOC
## POST /set_voice_settings

### Description
Sets the user's Discord voice connection settings. This allows for customization of audio input/output, volume, and various audio processing features.

### Method
POST

### Endpoint
/set_voice_settings

### Parameters
#### Query Parameters
- **input** (dict) - Optional - Input settings, including 'device' (str) and 'volume' (int).
- **output** (dict) - Optional - Output settings, including 'device' (str) and 'volume' (int).
- **mode** (dict) - Optional - Voice mode settings.
- **automatic_gain_control** (bool) - Optional - State of automatic gain control.
- **echo_cancellation** (bool) - Optional - State of echo cancellation.
- **noise_suppression** (bool) - Optional - State of noise suppression.
- **qos** (bool) - Optional - State of voice quality of service.
- **silence_warning** (bool) - Optional - State of silence warning notice.
- **deaf** (bool) - Optional - State of self-deafen.
- **mute** (bool) - Optional - State of self-mute.

### Request Example
```json
{
  "input": {"volume": 80},
  "automatic_gain_control": false,
  "mute": true
}
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - Indicates the success or failure of the operation.

#### Response Example
```json
{
  "response": "success"
}
```
```

--------------------------------

### Text Channel Management

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Functions for managing text channel connections.

```APIDOC
## select_text_channel(channel_id)

### Description
Used to join and leave text channels, group DMs, or DMs.

### Method
POST

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **channel_id** (str or None) - Required - Channel ID to join (or ``None`` to leave).

### Request Example
```python
client.select_text_channel(channel_id='YOUR_CHANNEL_ID') # To join
client.select_text_channel(channel_id=None) # To leave
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - The response from the Discord client.
```

--------------------------------

### Guild and Channel Information

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Functions to retrieve information about guilds and channels.

```APIDOC
## get_guilds()

### Description
Used to get a list of guilds the client is in.

### Method
GET

### Endpoint
N/A

### Parameters
None

### Request Example
```python
guilds = client.get_guilds()
print(guilds)
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - A list of guilds the client is in.

## get_channels()

### Description
Used to get a list of channels the client is in.

### Method
GET

### Endpoint
N/A

### Parameters
None

### Request Example
```python
channels = client.get_channels()
print(channels)
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - A list of channels the client is in.

## channel_id()

### Description
Used to get a channel the client is in.

### Method
GET

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **channel_id** (str) - Required - ID of the channel to get.

### Request Example
```python
channel_info = client.channel_id(channel_id='YOUR_CHANNEL_ID')
print(channel_info)
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - Information about the specified channel.
```

--------------------------------

### Subscribe to Events

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/client.rst

Subscribes to a specific Discord event. This allows your application to receive real-time updates from Discord.

```APIDOC
## POST /subscribe

### Description
Subscribes to a specified Discord event. The application will receive notifications when the event occurs.

### Method
POST

### Endpoint
/subscribe

### Parameters
#### Query Parameters
- **event** (str) - Required - The name of the event to subscribe to.
- **args** (dict) - Optional - Additional arguments to go along with the event subscription.

### Request Example
```json
{
  "event": "READY",
  "args": {"some_param": "value"}
}
```

### Response
#### Success Response (200)
- **response** (pypresence.Response) - Indicates the success or failure of the subscription.

#### Response Example
```json
{
  "response": "success"
}
```
```

--------------------------------

### Update Discord Rich Presence

Source: https://qwertyquerty.github.io/pypresence/html/_sources/doc/presence.rst

Sets the user's presence on Discord with various activity details. Supports game name, state, details, timestamps, images, party size, and buttons. Uses ActivityType and StatusDisplayType enums for customization.

```python
from pypresence import Presence
from pypresence.types import ActivityType

RPC = Presence("YOUR_CLIENT_ID")
RPC.connect()

RPC.update(
    activity_type=ActivityType.LISTENING,
    details="My Favorite Song",
    state="By My Favorite Artist",
    large_image="my_large_image",
    large_text="Now Listening",
    buttons=[
        {"label": "My Website", "url": "https://qtqt.cf"}
    ]
)
```
Tokens:
Raw