### Install Ongaku using pip

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/index.md

This command installs the hikari-ongaku library using Python's package installer, pip. Ensure you have Python and pip installed.

```shell
pip install hikari-ongaku
```

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

### Install hikari-lightbulb for Lightbulb Example

Source: https://github.com/hikari-ongaku/ongaku/blob/main/examples/README.md

Details the dependency for the 'lightbulb' example, requiring version '~= 2.3' of hikari-lightbulb. This version ensures proper integration.

```python
hikari-lightbulb ~= 2.3
```

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

### Install hikari-crescent for Crescent Example

Source: https://github.com/hikari-ongaku/ongaku/blob/main/examples/README.md

Specifies the dependency for the 'crescent' example, needing version '~= 0.6' of hikari-crescent. This version is crucial for the example's functionality.

```python
hikari-crescent ~= 0.6
```

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

### Install hikari-tanjun for Tanjun Example

Source: https://github.com/hikari-ongaku/ongaku/blob/main/examples/README.md

Specifies the dependency for the 'tanjun' example, needing version '~= 2.17' of hikari-tanjun. This version is critical for the example's operation.

```python
hikari-tanjun ~= 2.17
```

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

### Install hikari-ongaku 0.6.0

Source: https://github.com/hikari-ongaku/ongaku/blob/main/examples/README.md

Specifies the base requirement for all examples, ensuring compatibility with version 0.6.0 of hikari-ongaku.

```python
hikari-ongaku == 0.6.0
```

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

### Install hikari-arc for Arc Example

Source: https://github.com/hikari-ongaku/ongaku/blob/main/examples/README.md

Details the dependency for the 'arc' example, requiring version '~= 1.3' of hikari-arc. This ensures compatibility with the specific features used in that example.

```python
hikari-arc ~= 1.3
```

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

### Install and Run Ongaku

Source: https://github.com/hikari-ongaku/ongaku/blob/main/README.md

Commands to install the hikari-ongaku library using pip and to verify the installation by running the library's module.

```sh
pip install -U hikari-ongaku
```

```sh
python3 -m ongaku
# On Windows you may need to run:
py -m ongaku
```

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

### Hikari Example Requirements

Source: https://github.com/hikari-ongaku/ongaku/blob/main/examples/README.md

The 'hikari' example in the project has no additional dependencies beyond the base hikari-ongaku requirement.

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

### Ongaku Client with Crescent

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/client.md

Sets up Ongaku's client with the Crescent framework using data classes for dependency management. This method ensures the client is available through Crescent's context.

```python
@dataclasses.dataclass
class MyModel:
    ongaku: ongaku.Client

bot = hikari.GatewayBot(...)
client = ongaku.Client(bot)

crescent_client = crescent.Client(bot, MyModel(client))

client.model.ongaku.create_session(...)
```

```python
@crescent.command("name", "description")
class SomeCommand:
    async def callback(self, ctx: crescent.Context) -> None:
        player = await ctx.client.model.ongaku.fetch_player(...)

        await player.play(...)
```

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

### Create Ongaku Client with Tanjun

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/injection.md

Illustrates the setup of an Ongaku client compatible with the Tanjun command handler.

```python
import hikari
import tanjun
import alluka
import ongaku

bot = hikari.GatewayBot(...) # Replace with your bot setup
client = tanjun.Client.from_gateway_bot(bot)
ongaku_client = ongaku.Client.from_tanjun(client)
```

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

### Basic Playback with Hikari-Ongaku

Source: https://github.com/hikari-ongaku/ongaku/blob/main/README.md

Example of setting up a Hikari GatewayBot, initializing the Ongaku client, and handling a message event to play a song from YouTube using a provided query. It includes checks for user voice channel presence and handles track loading and playback.

```python
import typing
import hikari
import ongaku

# Create a GatewayBot (RESTBot's are not supported.)
bot = hikari.GatewayBot(token="...")

# Give ongaku the bot.
client = ongaku.Client(bot)

@bot.listen()
async def message_event(
    event: hikari.GuildMessageCreateEvent
) -> None:
   # Ignore anything that has no content, is not a human, or is not in a guild.
   if not event.content or not event.is_human or not event.guild_id:
      return

   # Ignore anything that is not the play command.
   if not event.content.startswith("!play"):
      return

   # Get the query from play "command".
   query = event.content.strip("!play ")

   # Make sure the user is in a valid voice channel.
   voice_state = bot.cache.get_voice_state(event.guild_id, event.author.id)
   if not voice_state or not voice_state.channel_id:
      await bot.rest.create_message(event.channel_id, "you are not in a voice channel.", reply=event.message)
      return

   # Fetch the track from the query string. (This searches just Youtube.)
   result = await client.rest.load_track(f"ytsearch:{query}")

   # If the song is `None` let them know it failed.
   if result is None:
      await bot.rest.create_message(event.channel_id, "No songs were found.", reply=event.message)
      return

   # Create a player (or if it already exists, grab that one!)
   player = client.create_player(event.guild_id)

   # Add the playlist, track or search result to the player.
   if isinstance(result, typing.Sequence):
      player.add(result[0])
   else:
      player.add(result)

   # Tell the player to start playing the song!
   await player.play()

   await bot.rest.create_message(event.channel_id, f"Playing {player.queue[0].info.title}", reply=event.message)

```

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

### Ongaku Client with Lightbulb

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/client.md

Configures Ongaku's client using Lightbulb's datastore for easy access within bot commands. The client is stored as a bot attribute for straightforward retrieval.

```python
bot = lightbulb.BotApp(...)

bot.d.ongaku = ongaku.Client(bot)

bot.d.ongaku.create_session(...)
```

```python
@lightbulb.command("name", "description", auto_defer=False)
@lightbulb.implements(lightbulb.SlashCommand)
async def some_command(ctx: lightbulb.SlashContext) -> None:
    player = await ctx.bot.d.ongaku.fetch_player(...)

    await player.play(...)
```

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

### Getting Tracks

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Provides information on how to load tracks using various search methods and how to decode track data.

```APIDOC
## Getting Tracks

This section covers methods for loading and decoding tracks.

### Searching for Tracks

#### Description
Allows searching for tracks on platforms like YouTube and SoundCloud.

#### Method
`client.rest.load_track(...)
`

#### Endpoint
Not applicable, this is a client-side library function.

#### Parameters
- **query** (string) - The search query or URL. Prefixes like `ytsearch:`, `ytmsearch:`, `scsearch:` can be used.

#### Request Example
```python
track = await client.rest.load_track("ytsearch:Imagine Dragons - Radioactive")
```

### Decoding a Track

#### Description
Decodes a track from its encoded state.

#### Method
`client.rest.decode_track(...)
`

#### Endpoint
Not applicable, this is a client-side library function.

#### Parameters
- **encoded_track** (string) - The encoded track string, typically obtained from `track.encoded`.

#### Request Example
```python
track = await client.rest.decode_track(encoded_track_string)
```

### Response
#### Success Response (200)
Returns a track object.

#### Response Example
```json
{
  "track_data": "..."
}
```
```

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

### Create Player (Tanjun)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Provides an example of creating a player with the Tanjun framework, including error handling for failed creation. It utilizes dependency injection for the client.

```python
import tanjun
import alluka
import lightbulb

@tanjun.as_slash_command("name", "description")
async def some_command(ctx: tanjun.abc.SlashContext, client: ongaku.Client = alluka.inject()) -> None:
    @bot.command()
    @lightbulb.command("name", "description", auto_defer=False)
    @lightbulb.implements(lightbulb.SlashCommand)
    async def some_command(ctx: lightbulb.SlashContext) -> None:
        try:
            player = client.create_player(...)
        except:
            await ctx.create_initial_response("The player could not be created.")
            return
            # Or possibly raise an error when it fails to fetch the player.

        # Do stuff with the player.
```

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

### Ongaku Client with Tanjun

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/client.md

Connects Ongaku's client with the Tanjun command handler, leveraging automatic dependency injection via `alluka`. This simplifies accessing the client within Tanjun commands.

```python
bot = hikari.GatewayBot(...)
tanjun_client = tanjun.Client.from_gateway_bot(bot)

client = ongaku.Client.from_tanjun(tanjun_client)

client.create_session(...)
```

```python
@tanjun.as_slash_command("name", "description")
async def some_command(ctx: tanjun.abc.SlashContext, client: ongaku.Client = alluka.inject()) -> None:
    player = await client.fetch_player(...)

    await player.play(...)
```

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

### Ongaku Client with Arc

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/client.md

Integrates Ongaku's client with the Arc command handler for automatic dependency injection. This allows the client to be accessed directly within command functions.

```python
bot = hikari.GatewayBot(...)
arc_client = arc.GatewayClient(bot)

client = ongaku.Client.from_arc(arc_client)

client.create_session(...)
```

```python
@arc.slash_command("name", "description")
async def some_command(ctx: arc.GatewayContext, client: ongaku.Client = arc.inject()) -> None:
    player = await client.fetch_player(...)

    await player.play(...)
```

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

### Inject Ongaku Player (Optional) into Arc Command

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/injection.md

Shows how to inject an optional Ongaku player into an Arc command. Requires `ongaku[arc]` installation.

```python
import arc
import ongaku

@arc.slash_command("example", "This is an example command")
async def example_command(
    ctx: arc.GatewayContext,
    player: ongaku.Player | None = arc.Inject()
) -> None:
    ...
```

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

### Inject Ongaku Client into Tanjun Command

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/injection.md

Provides an example of injecting the Ongaku client into a Tanjun slash command using Alluka's dependency injection.

```python
import tanjun
import alluka
import ongaku

@tanjun.as_slash_command("name", "description")
async def some_command(
    ctx: tanjun.abc.SlashContext,
    ongaku_client: ongaku.Client = alluka.inject()
) -> None:
    ...
```

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

### Inject Ongaku Player (Required) into Arc Command

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/injection.md

Demonstrates injecting a required Ongaku player into an Arc command using a hook. Requires `ongaku[arc]` installation.

```python
from ongaku.ext import injection
import arc
import ongaku

@arc.with_hook(injection.arc_ensure_player)
@arc.slash_command("example", "This is an example command")
async def example_command(
    ctx: arc.GatewayContext,
    player: ongaku.Player = arc.Inject()
) -> None:
    ...
```

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

### Player Creation and Fetching

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

This section details how to create or fetch a player instance using different framework integrations.

```APIDOC
## Player Creation and Fetching

This section explains how to create or fetch a player instance.

### Method
This concept applies to various framework integrations like Arc, Crescent, Lightbulb, and Tanjun.

### Endpoint
Not applicable directly, as this is a client-side library function.

### Parameters
- **client** (ongaku.Client) - Injected client instance.
- **...
** - Placeholder for arguments required by `create_player`.

### Request Example
```python
# Example using Tanjun integration
@tanjun.as_slash_command("name", "description")
async def some_command(ctx: tanjun.abc.SlashContext, client: ongaku.Client = alluka.inject()) -> None:
    try:
        player = client.create_player(...)
    except:
        await ctx.create_initial_response("The player could not be created.")
        return
    # Do stuff with the player.
```

### Response
#### Success Response (200)
A player object is created or fetched.

#### Response Example
```json
{
  "player_info": "..."
}
```
```

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

### Create Player (Lightbulb)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Illustrates creating a player using the Lightbulb framework. Error handling is included for when player creation fails. This command requires the 'client' to be accessible.

```python
import lightbulb

@lightbulb.command("name", "description", auto_defer=False)
@lightbulb.implements(lightbulb.SlashCommand)
async def some_command(ctx: lightbulb.SlashContext) -> None:
    try:
        player = client.create_player(...)
    except:
        await ctx.respond("The player could not be created.")
        return
        # Or possibly raise an error when it fails to fetch the player.

    # Do stuff with the player.
```

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

### Create Player (Crescent)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Shows how to create a player within the Crescent framework. It includes basic error handling for the creation process. The 'client' object is expected to be available.

```python
import crescent

@crescent.command("name", "description")
class SomeCommand:
    async def callback(self, ctx: crescent.Context) -> None:
        try:
            player = client.create_player(...)
        except:
            await ctx.respond("The player could not be created.")
            return
            # Or possibly raise an error when it fails to fetch the player.

        # Do stuff with the player.
```

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

### Create Ongaku Client with Arc

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/injection.md

Demonstrates the creation of an Ongaku client integrated with the Arc command handler.

```python
import hikari
import arc
import ongaku

bot = hikari.GatewayBot(...) # Replace with your bot setup
client = arc.GatewayClient(bot)
ongaku_client = ongaku.Client.from_arc(client)
```

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

### Search for a Track

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Loads a track by searching on a platform using a provided query. Supports YouTube, YouTube Music, and SoundCloud searches. Requires a link or a search query with a prefix.

```python
track = await client.rest.load_track(...) # Replace '...' with a link or a search query like 'ytsearch:query'
```

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

### Create Player (Arc)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Demonstrates how to create a player using the Arc framework. It includes error handling for player creation failures. This function assumes the 'client' is injected.

```python
import arc
import ongaku

@arc.slash_command("name", "description")
async def some_command(ctx: arc.GatewayContext, client: ongaku.Client = arc.inject()) -> None:
    try:
        player = client.create_player(...)
    except:
        await ctx.respond("The player could not be created.")
        return
        # Or possibly raise an error when it fails to fetch the player.

    # Do stuff with the player.
```

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

### Create Filter from Player - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Shows how to initialize a filter object by copying the current filter settings from an existing player object. This is useful for modifying filters without overriding existing configurations.

```python
filters = ongaku.Filters.from_filter(player.filters)
```

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

### Connect to Voice Channel with Mute/Deafen Options (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Connects the bot to a specified voice channel, with options to mute or deafen the bot upon connection. The `mute` parameter defaults to `False` and the `deaf` parameter defaults to `True`. Replace `channel_id` with the actual channel ID.

```python
await player.connect(channel_id)

```

```python
await player.connect(channel_id, mute=True)

```

```python
await player.connect(channel_id, deaf=False)

```

```python
await player.connect(channel_id, mute=True, deaf=False)

```

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

### Add Tracks to Queue (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Adds one or more tracks or a playlist to the player's queue without immediately playing them. Replace `...` with the track, tracks, or playlist information.

```python
player.add(...)

```

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

### Play Tracks with/without Adding to Queue (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Allows playing music. It can be used to play the current queue after adding tracks or to play a specific track directly. Note that `.play()` does not support multiple tracks, so `.add()` should be used for queues.

```python
# Add track(s) to your player.
await player.add(...)

# Leave .play() empty, to play the current queue.
await player.play()

```

```python
await player.play(...)

```

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

### Inject Ongaku Client into Arc Command

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/injection.md

Shows how to inject the Ongaku client directly into an Arc command handler using dependency injection.

```python
import arc
import ongaku

@arc.slash_command("example", "This is an example command")
async def example_command(
    ctx: arc.GatewayContext,
    ongaku_client: ongaku.Client = arc.Inject()
) -> None:
    ...
```

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

### Create New Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Demonstrates creating a new, independent filter object using the ongaku.Filters() constructor. This method will override any existing filter settings on the player.

```python
filters = ongaku.Filters()
```

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

### Filters Management for Ongaku Player

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Methods to set a new filter or clear all existing filters for the Ongaku player. Refer to the filters.md document for more details on available filters.

```python
await player.set_filters(filters)
```

```python
await player.set_filters()
```

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

### Set Playback Position for Ongaku Player

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Allows setting the current playback position of the track in milliseconds. Errors occur if the position is out of bounds or no track is playing.

```python
await player.set_position(40000)
```

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

### Add New Lavalink Session to Ongaku Client

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/session.md

Creates a new session to a Lavalink server for the Ongaku client. This involves specifying connection details like SSL status, host, port, and password.

```python
client.create_session(
    ssl=False,
    host="127.0.0.1",
    port=2333,
    password="youshallnotpass"
)
```

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

### Manage Equalizer Bands - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Provides methods to manipulate equalizer bands. `add_equalizer` adds or modifies a specific frequency band with a given gain, `remove_equalizer` deletes a band, and `clear_equalizer` removes all custom equalizer settings.

```python
filters.add_equalizer(BandType.HZ100, 0.3)
```

```python
filters.remove_equalizer(BandType.HZ100)
```

```python
filters.clear_equalizer()
```

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

### Looping Controls for Ongaku Player

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Methods to force loop, force disable looping, or toggle the loop state of the Ongaku player.

```python
player.set_loop(False)
```

```python
player.set_loop(True)
```

```python
player.set_loop()
```

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

### Clear Queue and Stop Player (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Removes all tracks from the queue and stops the player.

```python
await player.clear()

```

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

### Manage Autoplay (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Controls the autoplay feature, which plays the next track when the current one ends. Autoplay can be forced on, forced off, or toggled.

```python
player.set_autoplay(True)

```

```python
player.set_autoplay(False)

```

```python
player.set_autoplay()

```

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

### Set Karaoke Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Configures the karaoke effect, allowing adjustments to vocal removal levels. The `set_karaoke` method takes parameters for `level`, `mono_level`, `filter_band`, and `filter_width`.

```python
filters.set_karaoke(
    level=1,
    mono_level=0,
    filter_band=0.5,
    filter_width=None
)
```

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

### Shuffle Queue (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Shuffles the order of tracks in the current queue. The currently playing track is not affected.

```python
player.shuffle()

```

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

### Set Timescale Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Adjusts the playback speed and pitch of the audio. The `set_timescale` method allows modification of `speed`, `pitch`, and `rate`.

```python
filters.set_timescale(
    speed=10,
    pitch=1.5,
    rate=None
)
```

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

### Skip Tracks (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Skips the current track or multiple tracks in the queue. Calling `skip()` without arguments skips one track. Providing an integer skips that many tracks.

```python
await player.skip()

```

```python
# This will skip 3 songs in the queue, starting from the first, playing track.
await player.skip(3)

```

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

### Set Vibrato Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Applies a vibrato effect, which modulates the pitch of the audio at a specified frequency and depth. Use `set_vibrato` with `frequency` and `depth` parameters.

```python
filters.set_vibrato(
    frequency=2,
    depth=1
)
```

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

### Pause/Resume Player (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Controls the playback state of the player. It can force playing, force pausing, or toggle between the two states.

```python
await player.pause(False)

```

```python
await player.pause(True)

```

```python
await player.pause()

```

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

### Set Volume Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Sets the volume level for the audio player. The `set_volume` method takes a numerical value representing the desired volume multiplier.

```python
filters.set_volume(200)
```

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

### Set Distortion Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Applies a distortion effect to the audio, altering its waveform for a distorted sound. The `set_distortion` method offers numerous parameters for fine-tuning the effect.

```python
filters.set_distortion(
    sin_offset=0.3,
    sin_scale=1,
    cos_offset=4,
    cos_scale=-3,
    tan_offset=4,
    tan_scale=9,
    offset=6.66,
    scale=-1.5,
)
```

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

### Set Channel Mix Filter

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Sets the channel mix filter values for audio processing. This function takes four float arguments representing the mix ratios between left and right audio channels.

```python
filters.set_channel_mix(
    left_to_left=0.39,
    left_to_right=1,
    right_to_left=0,
    right_to_right=0.8
)
```

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

### Set Tremolo Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Applies a tremolo effect, which modulates the volume of the audio at a specified frequency and depth. Use `set_tremolo` with `frequency` and `depth` parameters.

```python
filters.set_tremolo(
    frequency=2,
    depth=1
)
```

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

### Set Rotation Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Applies a stereo rotation effect to the audio, shifting the sound between stereo channels at a given frequency. Use `set_rotation` with the `rotation_hz` parameter.

```python
filters.set_rotation(
    rotation_hz=8
)
```

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

### Volume Control for Ongaku Player

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Methods to change the player's volume to a specific level or reset it to the default value (100). Values above 100 may cause distortion.

```python
# The following sets the volume to half of its original.
await player.set_volume(50)
```

```python
await player.set_volume()
```

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

### Set Low Pass Filter

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Sets the low pass filter values for audio processing. Similar to channel mix, it accepts four float arguments to configure the filter's behavior.

```python
filters.set_low_pass(
    left_to_left=0.39,
    left_to_right=1,
    right_to_left=0,
    right_to_right=0.8
)
```

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

### Decode a Track

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Decodes a track from its encoded string representation. The encoded state is available on existing track objects via the 'encoded' attribute.

```python
track = await client.rest.decode_track(...)
```

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

### Stop Player (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Stops the currently playing track without affecting the queue.

```python
await player.stop()

```

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

### Clear Channel Mix Filter

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Clears the currently set channel mix filter values, reverting audio processing to its default state. This function takes no arguments.

```python
filters.clear_channel_mix()
```

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

### Clear Timescale Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Resets the timescale filter to its default values, returning the audio playback to its original speed and pitch.

```python
filters.clear_timescale()
```

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

### Clear Karaoke Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Removes all applied karaoke filter settings, reverting the audio to its state before the karaoke effect was applied.

```python
filters.clear_karaoke()
```

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

### Clear Rotation Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Removes the stereo rotation effect, returning the audio to its standard stereo presentation.

```python
filters.clear_rotation()
```

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

### Clear Distortion Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Removes the distortion audio effect, restoring the original audio signal.

```python
filters.clear_distortion()
```

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

### Remove Tracks from Queue (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Removes tracks from the queue either by track object, position, or encoded value. Removing the first track does not stop playback.

```python
player.remove(track)

```

```python
player.remove(3)

```

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

### Disconnect from Voice Channel (Python)

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/player.md

Disconnects the bot from the current voice channel and stops the player.

```python
await player.disconnect()

```

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

### Clear Vibrato Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Removes the vibrato audio effect, restoring the original pitch characteristics of the audio.

```python
filters.clear_vibrato()
```

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

### Clear Tremolo Filter - Python

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Removes the tremolo audio effect, restoring the original volume characteristics of the audio.

```python
filters.clear_tremolo()
```

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

### Clear Low Pass Filter

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/filters.md

Clears the currently set low pass filter values, reverting audio processing to its default state. This function requires no arguments.

```python
filters.clear_low_pass()
```

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

### Change Ongaku Client's Default Session Handler

Source: https://github.com/hikari-ongaku/ongaku/blob/main/docs/gs/session.md

Modifies the default session handler used by the Ongaku client. This is typically set during the client's initialization.

```python
client = ongaku.Client(
    bot,
    session_handler=ongaku.BasicSessionHandler
)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.