lavasnek_rs

lavalink-rs bindings for Python

Cheat Sheet:

Functions that return a Result<T, E> mean that it can raise an exception. T is the type they return normally, and E is a list of possible exceptions that can raise.
Functions that return an Option<T> mean that the value returned can be None, where T would be the type of the returned value if not None.
If something returns a Future<T>, it means that it returns this, and that function should be awaited to work.
/ on arguments means the end of positional arguments.
Self (with a capital S) means the type of self.
A type prefixed with impl means it's a Class that implements that Trait type.

View Source

 1# -*- coding: utf-8 -*-
 2"""
 3lavasnek_rs
 4-------------------
 5lavalink-rs bindings for Python
 6
 7Cheat Sheet:
 8
 9- Functions that return a `Result<T, E>` mean that it can raise an exception. `T` is the type they
10return normally, and `E` is a list of possible exceptions that can raise.
11- Functions that return an `Option<T>` mean that the value returned can be `None`, where `T` would be
12the type of the returned value if not `None`.
13- If something returns a `Future<T>`, it means that it returns
14[this](https://docs.python.org/3/library/asyncio-future.html?#asyncio.Future),
15and that function should be awaited to work.
16- / on arguments means the end of positional arguments.
17- Self (with a capital S) means the type of self.
18- A type prefixed with `impl` means it's a Class that implements that Trait type.
19"""
20
21from .lavasnek_rs import *
22
23__version__ = "0.1.0-alpha.5"
24__author__ = "vicky5124 <vickyf5124@gmail.com>"
25__license__ = "MPL-2.0"
26
27__all__ = [
28    "rust_sleep",
29    "log_something",
30    "Lavalink",
31    "LavalinkBuilder",
32    "PlayBuilder",
33    "LavalinkEventHandler",
34    "ConnectionInfo",
35    "Track",
36    "Tracks",
37    "TrackQueue",
38    "Info",
39    "PlaylistInfo",
40    "Node",
41    "Band",
42    "Stats",
43    "PlayerUpdate",
44    "TrackStart",
45    "TrackFinish",
46    "TrackException",
47    "TrackStuck",
48    "WebSocketClosed",
49    "PlayerDestroyed",
50    "NoSessionPresent",
51    "NetworkError",
52]

def rust_sleep(seconds, /)

Test function, do not use.

def log_something()

Test function, do not use.

class Lavalink:

Lavalink()

async def start_discord_gateway(self, wait_time: int) -> None:

Start the discord gateway, if it has stopped, or it never started because the client builder was configured that way.

If wait_time is passed, it will override the previosuly configured wait time.

Positional Arguments:

wait_time : Optional Unsigned 64 bit integer -- seconds

Returns: Future<None>

async def join(self, guild_id: int, channel_id: int) -> lavasnek_rs.ConnectionInfo:

Joins a guild's voice channel using the lavalink-rs discord gateway.

Returns information about the gateway connection, which can be used with create_session() to connect lavalink to that voice connection.

lavalink: lavasnek_rs.Lavalink = ...

connection_info = await lavalink.join(guild_id, voice_channel_id)
await lavalink.create_session(connection_info)

await send_message(f"Joined <#{voice_channel_id}>")

Timing out means that there's either no permission to join the voice channel, or 5 seconds have happened since the function was called.

Positional Arguments:

guild_id : Unsigned 64 bit integer
channel_id : Unsigned 64 bit integer

Returns: Future<Result<ConnectionInfo, builtins.TimeoutError>>

async def leave(self, guild_id: int) -> None:

Leaves the current guild's voice channel using the lavalink-rs discord gateway.

Lavalink.destroy() should be ran as well before this, to safely stop the lavalink session.

lavalink: lavasnek_rs.Lavalink = ...

await lavalink.destroy(guild_id)
await lavalink.leave(guild_id)

await send_message("Left voice channel")

Timing out means that 5 seconds have happened since the function was called.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<Result<None, builtins.TimeoutError>>

async def create_session(self, connection_info: lavasnek_rs.ConnectionInfo) -> None:

Creates a session in Lavalink with a voice connection. This also creates a Node and inserts it. The node is not added to the loops unless PlayBuilder.queue() is ran.

This can raise a TypeError if a necessary field of ConnectionInfo is missing.

Positional Arguments:

connection_info : ConnectionInfo (obtained from Lavalink.join())

Returns: Future<Result<None, builtins.TypeError>>

async def destroy(self, guild_id: int) -> None:

Stops the session in Lavalink of the guild. This also creates a Node and inserts it.

This method does not remove the guild from the running event loops, nor does it clear the Node, this allows for reconnecting without losing data. If you are having issues with disconnecting and reconnecting the bot to a voice channel, remove the guild from the running event loops and reset the nodes.

lavalink.remove_guild_node(guild_id)
lavalink.remove_guild_from_loops(guild_id)

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

def play(self, guild_id: int, track: lavasnek_rs.Track) -> lavasnek_rs.PlayBuilder:

Returns the Play builder.

lavalink: lavasnek_rs.Lavalink = ...

query_information = await lavalink.auto_search_tracks(search_query_or_url)

if not query_information["tracks"]: # tracks is empty
    await send_message("Could not find any video of the search query.")
    return

try:
    await lavalink.play(
        guild_id, query_information["tracks"][0]
    ).requester(author_id).queue()
except lavasnek_rs.NoSessionPresent:
    await send_message(f"Use `{PREFIX}join` first")
    return

Positional Arguments:

guild_id : Unsigned 64 bit integer
track : Track - From the track search methods, it's a value from the "tracks" field.

Returns: PlayBuilder

async def get_tracks(self, query: str) -> lavasnek_rs.Tracks:

Returns the tracks from the URL or query provided.

This can raise an exception if a network error happens.

Positional Arguments:

query : String

Returns: Future<Result<Tracks, lavasnek_rs.NetworkError>>

async def auto_search_tracks(self, query: str) -> lavasnek_rs.Tracks:

Will automatically search the query on youtube if it's not a valid URL.

This can raise an exception if a network error happens.

Positional Arguments:

query : String

Returns: Future<Result<Tracks, lavasnek_rs.NetworkError>>

async def search_tracks(self, query: str) -> lavasnek_rs.Tracks:

Returns tracks from the search query. Uses youtube to search.

This can raise an exception if a network error happens.

Positional Arguments:

query : String

Returns: Future<Result<Tracks, lavasnek_rs.NetworkError>>

async def decode_track(self, track: str) -> lavasnek_rs.Info:

Returns information from a track.

This can raise an exception if a network error happens.

Positional Arguments:

track : String -- base 64

Returns: Future<Result<Info, lavasnek_rs.NetworkError>>

async def stop(self, guild_id: int) -> None:

Stops the current player.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def skip(self, guild_id: int) -> Optional[lavasnek_rs.TrackQueue]:

Skips the current playing track to the next item on the queue.

If nothing is in the queue, the currently playing track will keep playing. Check if the queue is empty and run stop() if that's the case.

lavalink: lavasnek_rs.Lavalink = ...

skip = await lavalink.skip(guild_id)
node = await lavalink.get_guild_node(guild_id)

if not skip:
    await send_message("Nothing to skip")
else:
    if not node["queue"] and not node["now_playing"]:
        await lavalink.stop(guild_id)

    await send_message(f"Skipped: {skip['track']['info']['title']}"

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<Option<TrackQueue>>

async def set_pause(self, guild_id: int, pause: bool) -> None:

Sets the pause status.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer
pause : bool

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def pause(self, guild_id: int) -> None:

Sets pause status to True

async def resume(self, guild_id: int) -> None:

Sets pause status to False

async def seek_secs(self, guild_id: int, time: int) -> None:

Jumps to a specific time in the currently playing track.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer
time : Unsigned 64 bit integer

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def jump_to_time_secs(self, guild_id: int, time: int) -> None:

Alias to seek_secs()

async def scrub_secs(self, guild_id: int, time: int) -> None:

Alias to seek_secs()

async def seek_millis(self, guild_id: int, time: int) -> None:

Jumps to a specific time in the currently playing track.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer
time : Unsigned 64 bit integer

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def jump_to_time_millis(self, guild_id: int, time: int) -> None:

Alias to seek_millis()

async def scrub_millis(self, guild_id: int, time: int) -> None:

Alias to seek_millis()

async def volume(self, guild_id: int, volume: int) -> None:

Sets the volume of the player. Max is 1000, min is 0

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer
Volume : Unsigned 16 bit integer

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def equalize_all(self, guild_id: int, bands: List[float]) -> None:

Sets all equalizer levels.

There are 15 bands (0-14) that can be changed.
The floating point value is the multiplier for the given band.
The default value is 0.
Valid values range from -0.25 to 1.0, where -0.25 means the given band is completely muted, and 0.25 means it is doubled.
Modifying the gain could also change the volume of the output.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer
bands : List<64 bit floating point> -- Must be 15 in length

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def equalize_dynamic(self, guild_id: int, bands: List[lavasnek_rs.Band]) -> None:

Equalize a dynamic set of bands, rather than just one or all of them at once.

Unmentioned bands will remain unmodified.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer
bands : List<64 bit floating point> -- Must be 15 or less in length

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def equalize_band(self, guild_id: int, band: lavasnek_rs.Band) -> None:

Equalizes a specific band.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer
band : Band

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def equalize_reset(self, guild_id: int) -> None:

Resets all equalizer levels.

This can raise an exception if a network error happens.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def remove_guild_from_loops(self, guild_id: int) -> None:

Remove the guild from the queue loops.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<None>

async def remove_guild_node(self, guild_id: int) -> None:

Remove the guild node.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<None>

async def get_guild_node(self, guild_id: int) -> Optional[lavasnek_rs.Node]:

Get the current guild from the queue nodes.

This returns a clone of the node, so modifying it won't change the real node, for that you will need to re-set the new node with set_guild_node().

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Future<Option<Node>>

async def set_guild_node(self, guild_id: int, node: lavasnek_rs.Node) -> None:

Set the node of a guild with a new one.

Positional Arguments:

guild_id : Unsigned 64 bit integer
node : Node

Returns: Future<None>

def get_guild_gateway_connection_info(self, guild_id: int) -> Optional[lavasnek_rs.ConnectionInfo]:

Get the current guild from the queue nodes.

This returns a clone of the value, modifying it won't change it internally.

Positional Arguments:

guild_id : Unsigned 64 bit integer

Returns: Option<ConnectionInfo>

async def wait_for_full_connection_info_insert(self, guild_id: int, event_count: int = 10) -> lavasnek_rs.ConnectionInfo:

Waits until the ConnectionInfo is complete and returns it.

Positional Arguments:

guild_id : Unsigned 64 bit integer
event_count : Unsigned 128 bit integer defaults to 10

Returns: Future<ConnectionInfo>

async def wait_for_connection_info_remove(self, guild_id: int, event_count: int = 10) -> None:

Waits until the ConnectionInfo is removed.

Positional Arguments:

guild_id : Unsigned 64 bit integer
event_count : Unsigned 128 bit integer defaults to 10

Returns: Future<None>

async def raw_handle_event_voice_server_update(self, guild_id: int, endpoint: str, token: str) -> None:

Handles voice events to manage ConnectionInfo internally. This one is for the VOICE_SERVER_UPDATE event.

Positional Arguments:

guild_id : Unsigned 64 bit integer
endpint : String
token : String

Returns: Future<None>

def raw_handle_event_voice_state_update( self, guild_id: int, user_id: int, session_id: str, channel_id: Optional[int]) -> None:

Handles voice events to manage ConnectionInfo internally. This one is for the VOICE_STATE_UPDATE event.

Positional Arguments:

guild_id : Unsigned 64 bit integer
user_id : Unsigned 64 bit integer
session_id : String
channel_id : Optional Unsigned 64 bit integer

Returns: None

class LavalinkBuilder:

__new__()

All of the methods that return Self also modify Self, so you can chain them, or call the individually.

Positional Arguments:

bot_id : Unsigned 64 bit integer
bot_token : String

Returns: Self

LavalinkBuilder()

async def build(cls, event_handler: object) -> lavasnek_rs.Lavalink:

Uses the Self data to build a Lavalink client and return it.

Can raise an exception if it's unable to connect to the lavalink server, discord server, or both.

Positional Arguments:

event_handler : impl LavalinkEventHandler

Returns: Future<Result<Lavalink, builtins.ConnectionError>>

def set_host(self, host: str) -> lavasnek_rs.LavalinkBuilder:

Sets the host. (Default to: 127.0.0.1)

Positional Arguments:

host : String

Returns: Self

def set_port(self, port: int) -> lavasnek_rs.LavalinkBuilder:

Sets the port. (Default to: 2333)

Positional Arguments:

port : Unsigned 16 bit integer

Returns: Self

def set_addr(self, address: str) -> lavasnek_rs.LavalinkBuilder:

Sets the host and port from an address.

Can raise an exception if the address is an invalid IPv4 or IPv6.

Positional Arguments:

address : String

Returns: Result<Self, ipaddress.AddressValueError>

def set_password(self, password: str) -> lavasnek_rs.LavalinkBuilder:

Sets the lavalink password. (Default to: "youshallnotpass")

Positional Arguments:

password : String

Returns: Self

def set_shard_count(self, shard_count: int) -> lavasnek_rs.LavalinkBuilder:

Sets the number of shards. (Default to: 1)

Positional Arguments:

shard_count : Unsigned 64 bit integer

Returns: Self

def set_bot_id(self, bot_id: int) -> lavasnek_rs.LavalinkBuilder:

Sets the ID of the bot.

Positional Arguments:

bot_id : Unsigned 64 bit integer

Returns: Self

def set_bot_token(self, bot_token: str) -> lavasnek_rs.LavalinkBuilder:

Sets the token of the bot.

Positional Arguments:

bot_token : String

Returns: Self

def set_is_ssl(self, is_ssl: bool) -> lavasnek_rs.LavalinkBuilder:

Sets if the lavalink server is behind SSL. (Default to: False)

Positional Arguments:

is_ssl : bool

Returns: Self

def set_start_gateway(self, start_gateway: bool) -> lavasnek_rs.LavalinkBuilder:

Sets if the discord gateway for voice connections should start or not. (Default to: True)

Positional Arguments:

start_gateway : bool

Returns: Self

def set_gateway_start_wait_time_secs(self, time: int) -> lavasnek_rs.LavalinkBuilder:

Sets the time to wait before starting the first discord gateway connection. (Default to: 6 seconds)

Positional Arguments:

time : Unsigned 64 bit integer

Returns: Self

def set_gateway_start_wait_time_millis(self, time: int) -> lavasnek_rs.LavalinkBuilder:

Sets the time to wait before starting the first discord gateway connection.

Positional Arguments:

time : Unsigned 64 bit integer

Returns: Self

class PlayBuilder:

PlayBuilder()

async def start(self) -> None:

Starts playing the track.

Returns: Future<Result<None, lavasnek_rs.NetworkError>>

async def queue(self) -> None:

Adds the track to the node queue.

If there's no queue loop running, this will start one up, and add it to the running loops on Lavalink.loops()

Needs for `Lavalink.create_session() to be called first.

Returns: Future<Result<None, [lavasnek_rs.NoSessionPresent, lavasnek_rs.NetworkError]>>

def to_track_queue(self) -> lavasnek_rs.TrackQueue:

Generates a TrackQueue from the builder.

Returns: TrackQueue

def requester(self, requester: int) -> lavasnek_rs.PlayBuilder:

Sets the person that requested the song

Positional Arguments:

requester : Unsigned 64 bit integer (User ID)

Returns: Self

def replace(self, replace: bool) -> lavasnek_rs.PlayBuilder:

Sets if the current playing track should be replaced with this new one.

Positional Arguments:

replace : bool

Returns: Self

def start_time_secs(self, start: int) -> lavasnek_rs.PlayBuilder:

Sets the time the track will start at in seconds.

Positional Arguments:

start : Unsigned 64 bit integer

Returns: Self

def finish_time_secs(self, finish: int) -> lavasnek_rs.PlayBuilder:

Sets the time the track will finish at in seconds.

Positional Arguments:

finish : Unsigned 64 bit integer

Returns: Self

def start_time_millis(self, start: int) -> lavasnek_rs.PlayBuilder:

Sets the time the track will start at in milliseconds.

Positional Arguments:

start : Unsigned 64 bit integer

Returns: Self

def finish_time_millis(self, finish: int) -> lavasnek_rs.PlayBuilder:

Sets the time the track will finish at in milliseconds.

Positional Arguments:

finish : Unsigned 64 bit integer

Returns: Self

class LavalinkEventHandler:

The lavalink event handler. This is a trait, so it defines the structure a class should have.

Make a class with the methods and signatures this class defines, and add that class to LavalinkBuilder.build()

If code inside any of the event raises an error, the traceback will be printed to stderr, and the variables sys.last_type, sys.last_value and sys.last_traceback will be set to the type, value and traceback of the printed exception respectively.

Some examples:

# Just a single event
class EventHandler:
    async def track_start(self, lava_client, event):
        print(event)

lavalink_client = await client_builder.build(EventHandler)

# No events
class EventHandler:
    pass

lavalink_client = await client_builder.build(EventHandler)

# Just a single event
class EventHandler:
    async def stats(self, lava_client, event):
        print(event)
    async def player_update(self, lava_client, event):
        print(event)
    async def track_start(self, lava_client, event):
        print(event)
    async def track_finish(self, lava_client, event):
        print(event)
    async def track_exception(self, lava_client, event):
        print(event)
    async def track_stuck(self, lava_client, event):
        print(event)
    async def websocket_closed(self, lava_client, event):
        print(event)
    async def player_destroyed(self, lava_client, event):
        print(event)

lavalink_client = await client_builder.build(EventHandler)

LavalinkEventHandler()

async def stats(self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.Stats) -> None:

Periodic event that returns the statistics of the server.

Positional Arguments:

client : Lavalink
event : Stats

Returns: Future<None>

async def player_update( self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.PlayerUpdate) -> None:

Event that triggers when a player updates.

Positional Arguments:

client : Lavalink
event : PlayerUpdate

Returns: Future<None>

async def track_start( self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.TrackStart) -> None:

Event that triggers when a track starts playing.

Positional Arguments:

client : Lavalink
event : TrackStart

Returns: Future<None>

async def track_finish( self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.TrackFinish) -> None:

Event that triggers when a track finishes playing.

Positional Arguments:

client : Lavalink
event : TrackFinish

Returns: Future<None>

async def track_exception( self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.TrackException) -> None:

Event that triggers when a track raises an exception on the Lavalink server.

Positional Arguments:

client : Lavalink
event : TrackException

Returns: Future<None>

async def track_stuck( self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.TrackStuck) -> None:

Event that triggers when a track gets stuck while playing.

Positional Arguments:

client : Lavalink
event : TrackStuck

Returns: Future<None>

async def websocket_closed( self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.WebsocketClosed) -> None:

Event that triggers when the websocket connection to the voice channel closes.

Positional Arguments:

client : Lavalink
event : WebSocketClosed

Returns: Future<None>

async def player_destroyed( self, client: lavasnek_rs.Lavalink, event: lavasnek_rs.PlayerDestroyed) -> None:

Event that triggers when the player gets destroyed on a guild.

Positional Arguments:

client : Lavalink
event : PlayerDestroyed

Returns: Future<None>

class ConnectionInfo:

If you use a 3rd party method of joining a voice channel, you can get the values required for this from the VOICE_STATE_UPDATE and VOICE_SERVER_UPDATE events, and use raw_handle_event_voice_state_update() + raw_handle_event_voice_server_update() or manually build a dict with them, and use ConnectionInfo({ ... })

With hikari:

@bot.listen()
async def voice_state_update(event: hikari.VoiceStateUpdateEvent) -> None:
    await bot.data.lavalink.raw_handle_event_voice_state_update(
        event.state.guild_id,
        event.state.user_id,
        event.state.session_id,
        event.state.channel_id,
    )

@bot.listen()
async def voice_server_update(event: hikari.VoiceServerUpdateEvent) -> None:
    await bot.data.lavalink.raw_handle_event_voice_server_update(
        event.guild_id, event.endpoint, event.token
    )

Fields:

guild_id : Unsigned 64 bit integer
channel_id : Unsigned 64 bit integer
endpoint : String
token : String
session_id : String

ConnectionInfo()

class Track:

__new__()

Positional Arguments:

track : str
info : Option<Info>

Returns: Self

Track()

track: str

The playable track.

Contains String

info: lavasnek_rs.Info

Information about the track.

Contains Option<Info>

class Tracks:

Tracks()

playlist_info: lavasnek_rs.PlaylistInfo

Information about the playlist.

Contains Option<PlaylistInfo>

tracks: List[lavasnek_rs.Track]

The tracks that can be played

Contains List<Track>

load_type: str

Contains String

class TrackQueue:

TrackQueue()

requester: int

The user id who requested the track if set by the PlayBuilder

Contains Option<Unsigned 64 bit integer>

track: lavasnek_rs.Track

The playable track.

Contains Track

start_time: int

The time the track will start at.

Contains Unsigned 64 bit integer

end_time: int

The time the track will finish at.

Contains Option<Unsigned 64 bit integer>

class Info:

__new__()

Arguments:

length : Unsigned 64 bit integer
position : Unsigned 64 bit integer
is_seekable : bool
is_stream : bool
identifier : str
author : str
title : str
uri : str

Returns: Self

Info()

is_seekable: bool

Contains bool

uri: str

Contains String

is_stream: bool

Contains bool

author: str

Contains String

identifier: str

Contains String

length: int

Contains Unsigned 64 bit integer

position: int

Contains Unsigned 64 bit integer

title: str

Contains String

class PlaylistInfo:

PlaylistInfo()

name: Optional[str]

The name of the playlist.

Contains Option<String>

selected_track: Optional[int]

Contains Option<Signed 64 bit integer>

class Node:

Node()

def get_data(self) -> Union[Any, Dict[Any, Any]]:

Use this to get the currently stored data on the Node.

T is whatever type you give to set_data's data parameter, but if you call this method before it, it will default to a Dict.

Returns T

def set_data(self, data: Union[Any, Dict[Any, Any]]) -> None:

Use this to set the tored data of the Node.

Returns None

volume: int

Contains Unsigned 16 bit integer

guild: int

Contains Unsigned 64 bit integer

is_paused: bool

Contains bool

is_on_loops: bool

Contains bool

now_playing: Optional[lavasnek_rs.TrackQueue]

Contains Option<TrackQueue>

queue: List[lavasnek_rs.TrackQueue]

Contains List<TrackQueue>

class Band:

See Lavalink.equalize_all for more info.

band_num: int = 14 # 0 to 14
bain: float = 0.125 # -0.25 to 1.0

band = Band(band_num, gain)

Band()

gain: float

Contains 64 bit float

band: int

Contains Unsigned 8 bit integer

class Stats:

Stats()

cpu_lavalink_load: float

Contains 64 bit floating point

memory_free: int

Contains Signed 64 bit integer

op: str

Contains String

players: int

Contains Signed 64 bit integer

memory_reservable: int

Contains Signed 64 bit integer

memory_used: int

Contains Signed 64 bit integer

memory_allocated: int

Contains Signed 64 bit integer

playing_players: int

Contains Signed 64 bit integer

uptime: int

Contains Signed 64 bit integer

cpu_cores: int

Contains Signed 64 bit integer

frame_stats_nulled: Optional[int]

Contains Optional Signed 64 bit integer

frame_stats_deficit: Optional[int]

Contains Optional Signed 64 bit integer

frame_stats_sent: Optional[int]

Contains Optional Signed 64 bit integer

cpu_system_load: float

Contains 64 bit floating point

class PlayerUpdate:

PlayerUpdate()

state_position: int

Contains Signed 64 bit integer

state_time: int

Contains Signed 64 bit integer

guild_id: int

Contains Unsigned 64 bit integer

op: str

Contains String

class TrackStart:

TrackStart()

op: str

Contains String

track: str

Contains String

track_start_type: str

Contains String

guild_id: int

Contains Unsigned 64 bit integer

class TrackFinish:

TrackFinish()

op: str

Contains String

reason: str

Contains String

track: str

Contains String

guild_id: int

Contains Unsigned 64 bit integer

track_finish_type: str

Contains String

class TrackException:

TrackException()

exception_severity: str

Contains String

track_exception_type: str

Contains String

op: str

Contains String

guild_id: int

Contains Unsigned 64 bit integer

exception_cause: str

Contains String

error: str

Contains String

track: str

Contains String

exception_message: str

Contains String

class TrackStuck:

TrackStuck()

track_stuck_type: str

Contains String

op: str

Contains String

track: str

Contains String

threshold_ms: int

Contains Unsigned 64 bit integer

guild_id: int

Contains Unsigned 64 bit integer

class WebSocketClosed:

WebSocketClosed()

guild_id

Contains Unsigned 64 bit integer

by_remote

Contains bool

Contains String

websocket_closed_type

Contains String

user_id

Contains Unsigned 64 bit integer

code

Contains Unsigned 64 bit integer

class PlayerDestroyed:

PlayerDestroyed(*args, **kwargs)

guild_id

Contains Unsigned 64 bit integer

player_destroyed_type

Contains String

cleanup

Contains bool

Contains String

user_id

Contains Unsigned 64 bit integer

class NoSessionPresent(builtins.Exception):

Common base class for all non-exit exceptions.

Inherited Members

builtins.Exception: Exception
builtins.BaseException: with_traceback; args

class NetworkError(builtins.Exception):

Common base class for all non-exit exceptions.

Inherited Members

builtins.Exception: Exception
builtins.BaseException: with_traceback; args