onyx_online/obsws-cli
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/obsws-cli.git synced 2025-08-06 20:01:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: onyx_online:3b184c653171e34de112dad8dc19b96050925b7e
Branches Tags
onyx_online:main
onyx_online:switch-to-cyclopts
onyx_online:add-record-split-chapter
onyx_online:add-styles
onyx_online:add-filter-subtyper
onyx_online:v0.20.2
onyx_online:v0.20.1
onyx_online:v0.20.0
..
compare: onyx_online:105aaf29b7a35615b4d709bfad17e319389ba81b
Branches Tags
onyx_online:main
onyx_online:switch-to-cyclopts
onyx_online:add-record-split-chapter
onyx_online:add-styles
onyx_online:add-filter-subtyper
onyx_online:v0.20.2
onyx_online:v0.20.1
onyx_online:v0.20.0

No commits in common. "3b184c653171e34de112dad8dc19b96050925b7e" and "105aaf29b7a35615b4d709bfad17e319389ba81b" have entirely different histories.
3b184c6531 ... 105aaf29b7

21 changed files with 771 additions and 690 deletions
Show Stats Expand all files Collapse all files

73
obsws_cli/alias.py Normal file
View File

@ -0,0 +1,73 @@
"""module defining a custom group class for handling command name aliases."""
import re
import typer
class RootTyperAliasGroup(typer.core.TyperGroup):
"""A custom group class to handle command name aliases for the root typer."""
def __init__(self, *args, **kwargs):
"""Initialize the AliasGroup."""
super().__init__(*args, **kwargs)
self.no_args_is_help = True
def get_command(self, ctx, cmd_name):
"""Get a command by name."""
match cmd_name:
case 'f':
cmd_name = 'filter'
case 'g':
cmd_name = 'group'
case 'hk':
cmd_name = 'hotkey'
case 'i':
cmd_name = 'input'
case 'prf':
cmd_name = 'profile'
case 'prj':
cmd_name = 'projector'
case 'rc':
cmd_name = 'record'
case 'rb':
cmd_name = 'replaybuffer'
case 'sc':
cmd_name = 'scene'
case 'scc':
cmd_name = 'scenecollection'
case 'si':
cmd_name = 'sceneitem'
case 'ss':
cmd_name = 'screenshot'
case 'st':
cmd_name = 'stream'
case 'sm':
cmd_name = 'studiomode'
case 't':
cmd_name = 'text'
case 'vc':
cmd_name = 'virtualcam'
return super().get_command(ctx, cmd_name)
class SubTyperAliasGroup(typer.core.TyperGroup):
"""A custom group class to handle command name aliases for sub typers."""
_CMD_SPLIT_P = re.compile(r' ?[,|] ?')
def __init__(self, *args, **kwargs):
"""Initialize the AliasGroup."""
super().__init__(*args, **kwargs)
self.no_args_is_help = True
def get_command(self, ctx, cmd_name):
"""Get a command by name."""
cmd_name = self._group_cmd_name(cmd_name)
return super().get_command(ctx, cmd_name)
def _group_cmd_name(self, default_name):
for cmd in self.commands.values():
if cmd.name and default_name in self._CMD_SPLIT_P.split(cmd.name):
return cmd.name
return default_name

19
obsws_cli/app.py
View File

@ -19,26 +19,11 @@ app = App(
'OBS_'
), # Environment variable prefix for configuration parameters
version=version,
usage='[bold][yellow]Usage:[/yellow] [white]obsws-cli [OPTIONS] COMMAND [ARGS]...[/white][/bold]',
)
app.meta.group_parameters = Group('Options', sort_key=0)
app.meta.group_parameters = Group('Session Parameters', sort_key=0)
for sub_app in (
'filter',
'group',
'hotkey',
'input',
'profile',
'projector',
'record',
'replaybuffer',
'scene',
'scenecollection',
'sceneitem',
'screenshot',
'stream',
'studiomode',
'text',
'virtualcam',
):
module = importlib.import_module(f'.{sub_app}', package=__package__)
app.command(module.app)
@ -89,7 +74,7 @@ def launcher(
Parameter(validator=setup_logging),
] = False,
):
"""Command line interface for the OBS WebSocket API."""
"""Initialize the OBS WebSocket client and return the context."""
with obsws.ReqClient(
host=obs_config.host,
port=obs_config.port,

2
obsws_cli/filter.py
View File

@ -12,7 +12,7 @@ from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
app = App(name='filter', help='Commands for managing filters in OBS sources')
app = App(name='filter')
@app.command(name=['list', 'ls'])

164
obsws_cli/group.py
View File

@ -2,42 +2,42 @@
from typing import Annotated, Optional
from cyclopts import App, Argument, Parameter
import typer
from rich.table import Table
from rich.text import Text
from . import console, util, validate
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
from .protocols import DataclassProtocol
app = App(name='group', help='Commands for managing groups in OBS scenes')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['list', 'ls'])
@app.callback()
def main():
"""Control groups in OBS scenes."""
@app.command('list | ls')
def list_(
ctx: typer.Context,
scene_name: Annotated[
Optional[str],
Argument(
hint='Scene name to list groups for',
typer.Argument(
show_default='The current scene',
help='Scene name to list groups for',
),
] = None,
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""List groups in a scene."""
if not scene_name:
scene_name = ctx.client.get_current_program_scene().scene_name
scene_name = ctx.obj['obsws'].get_current_program_scene().scene_name
if not validate.scene_in_scenes(ctx, scene_name):
raise OBSWSCLIError(
f'Scene [yellow]{scene_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f"Scene '{scene_name}' not found.")
raise typer.Exit(1)
resp = ctx.client.get_scene_item_list(scene_name)
resp = ctx.obj['obsws'].get_scene_item_list(scene_name)
groups = [
(item.get('sceneItemId'), item.get('sourceName'), item.get('sceneItemEnabled'))
for item in resp.scene_items
@ -45,20 +45,20 @@ def list_(
]
if not groups:
raise OBSWSCLIError(
f'No groups found in scene {console.highlight(ctx, scene_name)}.',
code=ExitCode.SUCCESS,
console.out.print(
f'No groups found in scene {console.highlight(ctx, scene_name)}.'
)
raise typer.Exit()
table = Table(
title=f'Groups in Scene: {scene_name}',
padding=(0, 2),
border_style=ctx.style.border,
border_style=ctx.obj['style'].border,
)
columns = [
(Text('ID', justify='center'), 'center', ctx.style.column),
(Text('Group Name', justify='center'), 'left', ctx.style.column),
(Text('ID', justify='center'), 'center', ctx.obj['style'].column),
(Text('Group Name', justify='center'), 'left', ctx.obj['style'].column),
(Text('Enabled', justify='center'), 'center', None),
]
for heading, justify, style in columns:
@ -87,32 +87,30 @@ def _get_group(group_name: str, resp: DataclassProtocol) -> dict | None:
return group
@app.command(name=['show', 'sh'])
@app.command('show | sh')
def show(
ctx: typer.Context,
scene_name: Annotated[
str,
Argument(hint='Scene name the group is in'),
typer.Argument(..., show_default=False, help='Scene name the group is in'),
],
group_name: Annotated[
str, typer.Argument(..., show_default=False, help='Group name to show')
],
group_name: Annotated[str, Argument(hint='Group name to show')],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Show a group in a scene."""
if not validate.scene_in_scenes(ctx, scene_name):
raise OBSWSCLIError(
f'Scene [yellow]{scene_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f"Scene '{scene_name}' not found.")
raise typer.Exit(1)
resp = ctx.client.get_scene_item_list(scene_name)
resp = ctx.obj['obsws'].get_scene_item_list(scene_name)
if (group := _get_group(group_name, resp)) is None:
raise OBSWSCLIError(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].',
code=ExitCode.ERROR,
console.err.print(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].'
)
raise typer.Exit(1)
ctx.client.set_scene_item_enabled(
ctx.obj['obsws'].set_scene_item_enabled(
scene_name=scene_name,
item_id=int(group.get('sceneItemId')),
enabled=True,
@ -121,29 +119,29 @@ def show(
console.out.print(f'Group {console.highlight(ctx, group_name)} is now visible.')
@app.command(name=['hide', 'h'])
@app.command('hide | h')
def hide(
scene_name: Annotated[str, Argument(hint='Scene name the group is in')],
group_name: Annotated[str, Argument(hint='Group name to hide')],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the group is in')
],
group_name: Annotated[
str, typer.Argument(..., show_default=False, help='Group name to hide')
],
):
"""Hide a group in a scene."""
if not validate.scene_in_scenes(ctx, scene_name):
raise OBSWSCLIError(
f'Scene [yellow]{scene_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f'Scene [yellow]{scene_name}[/yellow] not found.')
raise typer.Exit(1)
resp = ctx.client.get_scene_item_list(scene_name)
resp = ctx.obj['obsws'].get_scene_item_list(scene_name)
if (group := _get_group(group_name, resp)) is None:
raise OBSWSCLIError(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].',
code=ExitCode.ERROR,
console.err.print(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].'
)
raise typer.Exit(1)
ctx.client.set_scene_item_enabled(
ctx.obj['obsws'].set_scene_item_enabled(
scene_name=scene_name,
item_id=int(group.get('sceneItemId')),
enabled=False,
@ -152,30 +150,30 @@ def hide(
console.out.print(f'Group {console.highlight(ctx, group_name)} is now hidden.')
@app.command(name=['toggle', 'tg'])
@app.command('toggle | tg')
def toggle(
scene_name: Annotated[str, Argument(hint='Scene name the group is in')],
group_name: Annotated[str, Argument(hint='Group name to toggle')],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the group is in')
],
group_name: Annotated[
str, typer.Argument(..., show_default=False, help='Group name to toggle')
],
):
"""Toggle a group in a scene."""
if not validate.scene_in_scenes(ctx, scene_name):
raise OBSWSCLIError(
f'Scene [yellow]{scene_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f'Scene [yellow]{scene_name}[/yellow] not found.')
raise typer.Exit(1)
resp = ctx.client.get_scene_item_list(scene_name)
resp = ctx.obj['obsws'].get_scene_item_list(scene_name)
if (group := _get_group(group_name, resp)) is None:
raise OBSWSCLIError(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].',
code=ExitCode.ERROR,
console.err.print(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].'
)
raise typer.Exit(1)
new_state = not group.get('sceneItemEnabled')
ctx.client.set_scene_item_enabled(
ctx.obj['obsws'].set_scene_item_enabled(
scene_name=scene_name,
item_id=int(group.get('sceneItemId')),
enabled=new_state,
@ -187,29 +185,29 @@ def toggle(
console.out.print(f'Group {console.highlight(ctx, group_name)} is now hidden.')
@app.command(name=['status', 'ss'])
@app.command('status | ss')
def status(
scene_name: Annotated[str, Argument(hint='Scene name the group is in')],
group_name: Annotated[str, Argument(hint='Group name to check status')],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the group is in')
],
group_name: Annotated[
str, typer.Argument(..., show_default=False, help='Group name to check status')
],
):
"""Get the status of a group in a scene."""
if not validate.scene_in_scenes(ctx, scene_name):
raise OBSWSCLIError(
f'Scene [yellow]{scene_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f'Scene [yellow]{scene_name}[/yellow] not found.')
raise typer.Exit(1)
resp = ctx.client.get_scene_item_list(scene_name)
resp = ctx.obj['obsws'].get_scene_item_list(scene_name)
if (group := _get_group(group_name, resp)) is None:
raise OBSWSCLIError(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].',
code=ExitCode.ERROR,
console.err.print(
f'Group [yellow]{group_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow].'
)
raise typer.Exit(1)
enabled = ctx.client.get_scene_item_enabled(
enabled = ctx.obj['obsws'].get_scene_item_enabled(
scene_name=scene_name,
item_id=int(group.get('sceneItemId')),
)

56
obsws_cli/hotkey.py
View File

@ -2,33 +2,37 @@
from typing import Annotated
from cyclopts import App, Argument, Parameter
import typer
from rich.table import Table
from rich.text import Text
from . import console
from .context import Context
from .alias import SubTyperAliasGroup
app = App(name='hotkey', help='Commands for managing hotkeys in OBS')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['list', 'ls'])
@app.callback()
def main():
"""Control hotkeys in OBS."""
@app.command('list | ls')
def list_(
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
):
"""List all hotkeys."""
resp = ctx.client.get_hotkey_list()
resp = ctx.obj['obsws'].get_hotkey_list()
table = Table(
title='Hotkeys',
padding=(0, 2),
border_style=ctx.style.border,
border_style=ctx.obj['style'].border,
)
table.add_column(
Text('Hotkey Name', justify='center'),
justify='left',
style=ctx.style.column,
style=ctx.obj['style'].column,
)
for i, hotkey in enumerate(resp.hotkeys):
@ -37,40 +41,40 @@ def list_(
console.out.print(table)
@app.command(name=['trigger', 'tr'])
@app.command('trigger | tr')
def trigger(
hotkey: Annotated[str, Argument(hint='The hotkey to trigger')],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
hotkey: Annotated[
str, typer.Argument(..., show_default=False, help='The hotkey to trigger')
],
):
"""Trigger a hotkey by name."""
ctx.client.trigger_hotkey_by_name(hotkey)
ctx.obj['obsws'].trigger_hotkey_by_name(hotkey)
@app.command(name=['trigger-sequence', 'trs'])
@app.command('trigger-sequence | trs')
def trigger_sequence(
ctx: typer.Context,
key_id: Annotated[
str,
Argument(
hint='The OBS key ID to trigger, see https://github.com/onyx-and-iris/obsws-cli?tab=readme-ov-file#hotkey for more info',
typer.Argument(
...,
show_default=False,
help='The OBS key ID to trigger, see https://github.com/onyx-and-iris/obsws-cli?tab=readme-ov-file#hotkey for more info',
),
],
/,
shift: Annotated[
bool, Parameter(help='Press shift when triggering the hotkey')
bool, typer.Option(..., help='Press shift when triggering the hotkey')
] = False,
ctrl: Annotated[
bool, Parameter(help='Press control when triggering the hotkey')
bool, typer.Option(..., help='Press control when triggering the hotkey')
] = False,
alt: Annotated[
bool, Parameter(help='Press alt when triggering the hotkey')
bool, typer.Option(..., help='Press alt when triggering the hotkey')
] = False,
cmd: Annotated[
bool, Parameter(help='Press cmd when triggering the hotkey')
bool, typer.Option(..., help='Press cmd when triggering the hotkey')
] = False,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Trigger a hotkey by sequence."""
ctx.client.trigger_hotkey_by_key_sequence(key_id, shift, ctrl, alt, cmd)
ctx.obj['obsws'].trigger_hotkey_by_key_sequence(key_id, shift, ctrl, alt, cmd)

106
obsws_cli/input.py
View File

@ -3,31 +3,33 @@
from typing import Annotated
import obsws_python as obsws
from cyclopts import App, Argument, Parameter
import typer
from rich.table import Table
from rich.text import Text
from . import console, util, validate
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='input', help='Commands for managing inputs in OBS')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['list', 'ls'])
@app.callback()
def main():
"""Control inputs in OBS."""
@app.command('list | ls')
def list_(
input: Annotated[bool, Parameter(help='Filter by input type.')] = False,
output: Annotated[bool, Parameter(help='Filter by output type.')] = False,
colour: Annotated[bool, Parameter(help='Filter by colour source type.')] = False,
ffmpeg: Annotated[bool, Parameter(help='Filter by ffmpeg source type.')] = False,
vlc: Annotated[bool, Parameter(help='Filter by VLC source type.')] = False,
uuid: Annotated[bool, Parameter(help='Show UUIDs of inputs.')] = False,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
input: Annotated[bool, typer.Option(help='Filter by input type.')] = False,
output: Annotated[bool, typer.Option(help='Filter by output type.')] = False,
colour: Annotated[bool, typer.Option(help='Filter by colour source type.')] = False,
ffmpeg: Annotated[bool, typer.Option(help='Filter by ffmpeg source type.')] = False,
vlc: Annotated[bool, typer.Option(help='Filter by VLC source type.')] = False,
uuid: Annotated[bool, typer.Option(help='Show UUIDs of inputs.')] = False,
):
"""List all inputs."""
resp = ctx.client.get_input_list()
resp = ctx.obj['obsws'].get_input_list()
kinds = []
if input:
@ -41,7 +43,7 @@ def list_(
if vlc:
kinds.append('vlc')
if not any([input, output, colour, ffmpeg, vlc]):
kinds = ctx.client.get_input_kind_list(False).input_kinds
kinds = ctx.obj['obsws'].get_input_kind_list(False).input_kinds
inputs = sorted(
(
@ -55,20 +57,21 @@ def list_(
)
if not inputs:
raise OBSWSCLIError('No inputs found.', code=ExitCode.SUCCESS)
console.out.print('No inputs found.')
raise typer.Exit()
table = Table(title='Inputs', padding=(0, 2), border_style=ctx.style.border)
table = Table(title='Inputs', padding=(0, 2), border_style=ctx.obj['style'].border)
if uuid:
columns = [
(Text('Input Name', justify='center'), 'left', ctx.style.column),
(Text('Kind', justify='center'), 'center', ctx.style.column),
(Text('Input Name', justify='center'), 'left', ctx.obj['style'].column),
(Text('Kind', justify='center'), 'center', ctx.obj['style'].column),
(Text('Muted', justify='center'), 'center', None),
(Text('UUID', justify='center'), 'left', ctx.style.column),
(Text('UUID', justify='center'), 'left', ctx.obj['style'].column),
]
else:
columns = [
(Text('Input Name', justify='center'), 'left', ctx.style.column),
(Text('Kind', justify='center'), 'center', ctx.style.column),
(Text('Input Name', justify='center'), 'left', ctx.obj['style'].column),
(Text('Kind', justify='center'), 'center', ctx.obj['style'].column),
(Text('Muted', justify='center'), 'center', None),
]
for heading, justify, style in columns:
@ -77,7 +80,7 @@ def list_(
for input_name, input_kind, input_uuid in inputs:
input_mark = ''
try:
input_muted = ctx.client.get_input_mute(name=input_name).input_muted
input_muted = ctx.obj['obsws'].get_input_mute(name=input_name).input_muted
input_mark = util.check_mark(input_muted)
except obsws.error.OBSSDKRequestError as e:
if e.code == 604: # Input does not support audio
@ -102,21 +105,19 @@ def list_(
console.out.print(table)
@app.command(name=['mute', 'm'])
@app.command('mute | m')
def mute(
input_name: Annotated[str, Argument(hint='Name of the input to mute.')],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
input_name: Annotated[
str, typer.Argument(..., show_default=False, help='Name of the input to mute.')
],
):
"""Mute an input."""
if not validate.input_in_inputs(ctx, input_name):
raise OBSWSCLIError(
f'Input [yellow]{input_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f'Input [yellow]{input_name}[/yellow] not found.')
raise typer.Exit(1)
ctx.client.set_input_mute(
ctx.obj['obsws'].set_input_mute(
name=input_name,
muted=True,
)
@ -124,21 +125,20 @@ def mute(
console.out.print(f'Input {console.highlight(ctx, input_name)} muted.')
@app.command(name=['unmute', 'um'])
@app.command('unmute | um')
def unmute(
input_name: Annotated[str, Argument(hint='Name of the input to unmute.')],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
input_name: Annotated[
str,
typer.Argument(..., show_default=False, help='Name of the input to unmute.'),
],
):
"""Unmute an input."""
if not validate.input_in_inputs(ctx, input_name):
raise OBSWSCLIError(
f'Input [yellow]{input_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f'Input [yellow]{input_name}[/yellow] not found.')
raise typer.Exit(1)
ctx.client.set_input_mute(
ctx.obj['obsws'].set_input_mute(
name=input_name,
muted=False,
)
@ -146,27 +146,23 @@ def unmute(
console.out.print(f'Input {console.highlight(ctx, input_name)} unmuted.')
@app.command(name=['toggle', 'tg'])
@app.command('toggle | tg')
def toggle(
ctx: typer.Context,
input_name: Annotated[
str,
Argument(hint='Name of the input to toggle.'),
typer.Argument(..., show_default=False, help='Name of the input to toggle.'),
],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Toggle an input."""
if not validate.input_in_inputs(ctx, input_name):
raise OBSWSCLIError(
f'Input [yellow]{input_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
console.err.print(f'Input [yellow]{input_name}[/yellow] not found.')
raise typer.Exit(1)
resp = ctx.client.get_input_mute(name=input_name)
resp = ctx.obj['obsws'].get_input_mute(name=input_name)
new_state = not resp.input_muted
ctx.client.set_input_mute(
ctx.obj['obsws'].set_input_mute(
name=input_name,
muted=new_state,
)

93
obsws_cli/profile.py
View File

@ -2,29 +2,31 @@
from typing import Annotated
from cyclopts import App, Argument, Parameter
import typer
from rich.table import Table
from rich.text import Text
from . import console, util, validate
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='profile', help='Commands for managing profiles in OBS')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['list', 'ls'])
def list_(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.callback()
def main():
"""Control profiles in OBS."""
@app.command('list | ls')
def list_(ctx: typer.Context):
"""List profiles."""
resp = ctx.client.get_profile_list()
resp = ctx.obj['obsws'].get_profile_list()
table = Table(title='Profiles', padding=(0, 2), border_style=ctx.style.border)
table = Table(
title='Profiles', padding=(0, 2), border_style=ctx.obj['style'].border
)
columns = [
(Text('Profile Name', justify='center'), 'left', ctx.style.column),
(Text('Profile Name', justify='center'), 'left', ctx.obj['style'].column),
(Text('Current', justify='center'), 'center', None),
]
for heading, justify, style in columns:
@ -41,85 +43,70 @@ def list_(
console.out.print(table)
@app.command(name=['current', 'get'])
def current(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('current | get')
def current(ctx: typer.Context):
"""Get the current profile."""
resp = ctx.client.get_profile_list()
resp = ctx.obj['obsws'].get_profile_list()
console.out.print(
f'Current profile: {console.highlight(ctx, resp.current_profile_name)}'
)
@app.command(name=['switch', 'set'])
@app.command('switch | set')
def switch(
ctx: typer.Context,
profile_name: Annotated[
str,
Argument(hint='Name of the profile to switch to'),
typer.Argument(
..., show_default=False, help='Name of the profile to switch to'
),
],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Switch to a profile."""
if not validate.profile_exists(ctx, profile_name):
console.err.print(f'Profile [yellow]{profile_name}[/yellow] not found.')
raise OBSWSCLIError(
f'Profile [yellow]{profile_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
raise typer.Exit(1)
resp = ctx.client.get_profile_list()
resp = ctx.obj['obsws'].get_profile_list()
if resp.current_profile_name == profile_name:
raise OBSWSCLIError(
f'Profile [yellow]{profile_name}[/yellow] is already the current profile.',
code=ExitCode.ERROR,
console.err.print(
f'Profile [yellow]{profile_name}[/yellow] is already the current profile.'
)
raise typer.Exit(1)
ctx.client.set_current_profile(profile_name)
ctx.obj['obsws'].set_current_profile(profile_name)
console.out.print(f'Switched to profile {console.highlight(ctx, profile_name)}.')
@app.command(name=['create', 'new'])
@app.command('create | new')
def create(
ctx: typer.Context,
profile_name: Annotated[
str,
Argument(hint='Name of the profile to create.'),
typer.Argument(..., show_default=False, help='Name of the profile to create.'),
],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Create a new profile."""
if validate.profile_exists(ctx, profile_name):
raise OBSWSCLIError(
f'Profile [yellow]{profile_name}[/yellow] already exists.',
code=ExitCode.ERROR,
)
console.err.print(f'Profile [yellow]{profile_name}[/yellow] already exists.')
raise typer.Exit(1)
ctx.client.create_profile(profile_name)
ctx.obj['obsws'].create_profile(profile_name)
console.out.print(f'Created profile {console.highlight(ctx, profile_name)}.')
@app.command(name=['remove', 'rm'])
@app.command('remove | rm')
def remove(
ctx: typer.Context,
profile_name: Annotated[
str,
Argument(hint='Name of the profile to remove.'),
typer.Argument(..., show_default=False, help='Name of the profile to remove.'),
],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Remove a profile."""
if not validate.profile_exists(ctx, profile_name):
console.err.print(f'Profile [yellow]{profile_name}[/yellow] not found.')
raise OBSWSCLIError(
f'Profile [yellow]{profile_name}[/yellow] not found.',
code=ExitCode.ERROR,
)
raise typer.Exit(1)
ctx.client.remove_profile(profile_name)
ctx.obj['obsws'].remove_profile(profile_name)
console.out.print(f'Removed profile {console.highlight(ctx, profile_name)}.')

61
obsws_cli/projector.py
View File

@ -2,25 +2,25 @@
from typing import Annotated
from cyclopts import App, Argument, Parameter
import typer
from rich.table import Table
from rich.text import Text
from . import console
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='projector', help='Commands for managing projectors in OBS')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['list-monitors', 'ls-m'])
def list_monitors(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.callback()
def main():
"""Control projectors in OBS."""
@app.command('list-monitors | ls-m')
def list_monitors(ctx: typer.Context):
"""List available monitors."""
resp = ctx.client.get_monitor_list()
resp = ctx.obj['obsws'].get_monitor_list()
if not resp.monitors:
console.out.print('No monitors found.')
@ -34,13 +34,13 @@ def list_monitors(
table = Table(
title='Available Monitors',
padding=(0, 2),
border_style=ctx.style.border,
border_style=ctx.obj['style'].border,
)
table.add_column(
Text('Index', justify='center'), justify='center', style=ctx.style.column
Text('Index', justify='center'), justify='center', style=ctx.obj['style'].column
)
table.add_column(
Text('Name', justify='center'), justify='left', style=ctx.style.column
Text('Name', justify='center'), justify='left', style=ctx.obj['style'].column
)
for index, monitor in monitors:
@ -49,30 +49,29 @@ def list_monitors(
console.out.print(table)
@app.command(name=['open', 'o'])
@app.command('open | o')
def open(
source_name: Annotated[
str,
Argument(
hint='Name of the source to project.',
),
] = '',
/,
ctx: typer.Context,
monitor_index: Annotated[
int,
Parameter(help='Index of the monitor to open the projector on.'),
typer.Option(help='Index of the monitor to open the projector on.'),
] = 0,
*,
ctx: Annotated[Context, Parameter(parse=False)],
source_name: Annotated[
str,
typer.Argument(
show_default='The current scene',
help='Name of the source to project.',
),
] = '',
):
"""Open a fullscreen projector for a source on a specific monitor."""
if not source_name:
source_name = ctx.client.get_current_program_scene().scene_name
source_name = ctx.obj['obsws'].get_current_program_scene().scene_name
monitors = ctx.client.get_monitor_list().monitors
monitors = ctx.obj['obsws'].get_monitor_list().monitors
for monitor in monitors:
if monitor['monitorIndex'] == monitor_index:
ctx.client.open_source_projector(
ctx.obj['obsws'].open_source_projector(
source_name=source_name,
monitor_index=monitor_index,
)
@ -83,8 +82,8 @@ def open(
break
else:
raise OBSWSCLIError(
console.err.print(
f'Monitor with index [yellow]{monitor_index}[/yellow] not found. '
f'Use [yellow]obsws-cli projector ls-m[/yellow] to see available monitors.',
ExitCode.ERROR,
f'Use [yellow]obsws-cli projector ls-m[/yellow] to see available monitors.'
)
raise typer.Exit(code=1)

150
obsws_cli/record.py
View File

@ -3,75 +3,67 @@
from pathlib import Path
from typing import Annotated, Optional
from cyclopts import App, Argument, Parameter
import typer
from . import console
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='record', help='Commands for controlling OBS recording functionality.')
app = typer.Typer(cls=SubTyperAliasGroup)
def _get_recording_status(ctx: Context) -> tuple:
@app.callback()
def main():
"""Control OBS recording functionality."""
def _get_recording_status(ctx: typer.Context) -> tuple:
"""Get recording status."""
resp = ctx.client.get_record_status()
resp = ctx.obj['obsws'].get_record_status()
return resp.output_active, resp.output_paused
@app.command(name=['start', 's'])
def start(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('start | s')
def start(ctx: typer.Context):
"""Start recording."""
active, paused = _get_recording_status(ctx)
if active:
err_msg = 'Recording is already in progress, cannot start.'
if paused:
err_msg += ' Try resuming it.'
raise OBSWSCLIError(err_msg, ExitCode.ERROR)
ctx.client.start_record()
console.err.print(err_msg)
raise typer.Exit(1)
ctx.obj['obsws'].start_record()
console.out.print('Recording started successfully.')
@app.command(name=['stop', 'st'])
def stop(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('stop | st')
def stop(ctx: typer.Context):
"""Stop recording."""
active, _ = _get_recording_status(ctx)
if not active:
raise OBSWSCLIError(
'Recording is not in progress, cannot stop.', ExitCode.ERROR
)
console.err.print('Recording is not in progress, cannot stop.')
raise typer.Exit(1)
resp = ctx.client.stop_record()
resp = ctx.obj['obsws'].stop_record()
console.out.print(
f'Recording stopped successfully. Saved to: {console.highlight(ctx, resp.output_path)}'
)
@app.command(name=['toggle', 'tg'])
def toggle(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('toggle | tg')
def toggle(ctx: typer.Context):
"""Toggle recording."""
resp = ctx.client.toggle_record()
resp = ctx.obj['obsws'].toggle_record()
if resp.output_active:
console.out.print('Recording started successfully.')
else:
console.out.print('Recording stopped successfully.')
@app.command(name=['status', 'ss'])
def status(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('status | ss')
def status(ctx: typer.Context):
"""Get recording status."""
active, paused = _get_recording_status(ctx)
if active:
@ -83,114 +75,98 @@ def status(
console.out.print('Recording is not in progress.')
@app.command(name=['resume', 'r'])
def resume(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('resume | r')
def resume(ctx: typer.Context):
"""Resume recording."""
active, paused = _get_recording_status(ctx)
if not active:
raise OBSWSCLIError(
'Recording is not in progress, cannot resume.', ExitCode.ERROR
)
console.err.print('Recording is not in progress, cannot resume.')
raise typer.Exit(1)
if not paused:
raise OBSWSCLIError(
'Recording is in progress but not paused, cannot resume.', ExitCode.ERROR
)
console.err.print('Recording is in progress but not paused, cannot resume.')
raise typer.Exit(1)
ctx.client.resume_record()
ctx.obj['obsws'].resume_record()
console.out.print('Recording resumed successfully.')
@app.command(name=['pause', 'p'])
def pause(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('pause | p')
def pause(ctx: typer.Context):
"""Pause recording."""
active, paused = _get_recording_status(ctx)
if not active:
raise OBSWSCLIError(
'Recording is not in progress, cannot pause.', ExitCode.ERROR
)
console.err.print('Recording is not in progress, cannot pause.')
raise typer.Exit(1)
if paused:
raise OBSWSCLIError(
'Recording is in progress but already paused, cannot pause.', ExitCode.ERROR
)
console.err.print('Recording is in progress but already paused, cannot pause.')
raise typer.Exit(1)
ctx.client.pause_record()
ctx.obj['obsws'].pause_record()
console.out.print('Recording paused successfully.')
@app.command(name=['directory', 'd'])
@app.command('directory | d')
def directory(
ctx: typer.Context,
record_directory: Annotated[
Optional[Path],
# Since the CLI and OBS may be running on different platforms,
# we won't validate the path here.
Argument(
hint='Directory to set for recording.',
typer.Argument(
file_okay=False,
dir_okay=True,
help='Directory to set for recording.',
),
] = None,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Get or set the recording directory."""
if record_directory is not None:
ctx.client.set_record_directory(str(record_directory))
ctx.obj['obsws'].set_record_directory(str(record_directory))
console.out.print(
f'Recording directory updated to: {console.highlight(ctx, record_directory)}'
)
else:
resp = ctx.client.get_record_directory()
resp = ctx.obj['obsws'].get_record_directory()
console.out.print(
f'Recording directory: {console.highlight(ctx, resp.record_directory)}'
)
@app.command(name=['split', 'sp'])
def split(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('split | sp')
def split(ctx: typer.Context):
"""Split the current recording."""
active, paused = _get_recording_status(ctx)
if not active:
console.err.print('Recording is not in progress, cannot split.')
raise OBSWSCLIError(
'Recording is not in progress, cannot split.', ExitCode.ERROR
)
raise typer.Exit(1)
if paused:
raise OBSWSCLIError('Recording is paused, cannot split.', ExitCode.ERROR)
console.err.print('Recording is paused, cannot split.')
raise typer.Exit(1)
ctx.client.split_record_file()
ctx.obj['obsws'].split_record_file()
console.out.print('Recording split successfully.')
@app.command(name=['chapter', 'ch'])
@app.command('chapter | ch')
def chapter(
ctx: typer.Context,
chapter_name: Annotated[
Optional[str],
Argument(
hint='Name of the chapter to create.',
typer.Argument(
help='Name of the chapter to create.',
),
] = None,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Create a chapter in the current recording."""
active, paused = _get_recording_status(ctx)
if not active:
raise OBSWSCLIError(
'Recording is not in progress, cannot create chapter.', ExitCode.ERROR
)
console.err.print('Recording is not in progress, cannot create chapter.')
raise typer.Exit(1)
if paused:
raise OBSWSCLIError(
'Recording is paused, cannot create chapter.', ExitCode.ERROR
)
console.err.print('Recording is paused, cannot create chapter.')
raise typer.Exit(1)
ctx.client.create_record_chapter(chapter_name)
ctx.obj['obsws'].create_record_chapter(chapter_name)
console.out.print(
f'Chapter {console.highlight(ctx, chapter_name or "unnamed")} created successfully.'
)

72
obsws_cli/replaybuffer.py
View File

@ -1,78 +1,64 @@
"""module containing commands for manipulating the replay buffer in OBS."""
from typing import Annotated
from cyclopts import App, Parameter
import typer
from . import console
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(
name='replaybuffer', help='Commands for controlling the replay buffer in OBS.'
)
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['start', 's'])
def start(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.callback()
def main():
"""Control profiles in OBS."""
@app.command('start | s')
def start(ctx: typer.Context):
"""Start the replay buffer."""
resp = ctx.client.get_replay_buffer_status()
resp = ctx.obj['obsws'].get_replay_buffer_status()
if resp.output_active:
raise OBSWSCLIError('Replay buffer is already active.', ExitCode.ERROR)
console.err.print('Replay buffer is already active.')
raise typer.Exit(1)
ctx.client.start_replay_buffer()
ctx.obj['obsws'].start_replay_buffer()
console.out.print('Replay buffer started.')
@app.command(name=['stop', 'st'])
def stop(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('stop | st')
def stop(ctx: typer.Context):
"""Stop the replay buffer."""
resp = ctx.client.get_replay_buffer_status()
resp = ctx.obj['obsws'].get_replay_buffer_status()
if not resp.output_active:
raise OBSWSCLIError('Replay buffer is not active.', ExitCode.ERROR)
console.err.print('Replay buffer is not active.')
raise typer.Exit(1)
ctx.client.stop_replay_buffer()
ctx.obj['obsws'].stop_replay_buffer()
console.out.print('Replay buffer stopped.')
@app.command(name=['toggle', 'tg'])
def toggle(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('toggle | tg')
def toggle(ctx: typer.Context):
"""Toggle the replay buffer."""
resp = ctx.client.toggle_replay_buffer()
resp = ctx.obj['obsws'].toggle_replay_buffer()
if resp.output_active:
console.out.print('Replay buffer is active.')
else:
console.out.print('Replay buffer is not active.')
@app.command(name=['status', 'ss'])
def status(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('status | ss')
def status(ctx: typer.Context):
"""Get the status of the replay buffer."""
resp = ctx.client.get_replay_buffer_status()
resp = ctx.obj['obsws'].get_replay_buffer_status()
if resp.output_active:
console.out.print('Replay buffer is active.')
else:
console.out.print('Replay buffer is not active.')
@app.command(name=['save', 'sv'])
def save(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('save | sv')
def save(ctx: typer.Context):
"""Save the replay buffer."""
ctx.client.save_replay_buffer()
ctx.obj['obsws'].save_replay_buffer()
console.out.print('Replay buffer saved.')

2
obsws_cli/scene.py
View File

@ -11,7 +11,7 @@ from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
app = App(name='scene', help='Commands for managing OBS scenes')
app = App(name='scene')
@app.command(name=['list', 'ls'])

79
obsws_cli/scenecollection.py
View File

@ -2,33 +2,33 @@
from typing import Annotated
from cyclopts import App, Argument, Parameter
import typer
from rich.table import Table
from . import console, validate
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(
name='scenecollection', help='Commands for controlling scene collections in OBS.'
)
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['list', 'ls'])
def list_(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.callback()
def main():
"""Control scene collections in OBS."""
@app.command('list | ls')
def list_(ctx: typer.Context):
"""List all scene collections."""
resp = ctx.client.get_scene_collection_list()
resp = ctx.obj['obsws'].get_scene_collection_list()
table = Table(
title='Scene Collections',
padding=(0, 2),
border_style=ctx.style.border,
border_style=ctx.obj['style'].border,
)
table.add_column(
'Scene Collection Name', justify='left', style=ctx.obj['style'].column
)
table.add_column('Scene Collection Name', justify='left', style=ctx.style.column)
for scene_collection_name in resp.scene_collections:
table.add_row(scene_collection_name)
@ -36,66 +36,59 @@ def list_(
console.out.print(table)
@app.command(name=['current', 'get'])
def current(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('current | get')
def current(ctx: typer.Context):
"""Get the current scene collection."""
resp = ctx.client.get_scene_collection_list()
resp = ctx.obj['obsws'].get_scene_collection_list()
console.out.print(
f'Current scene collection: {console.highlight(ctx, resp.current_scene_collection_name)}'
)
@app.command(name=['switch', 'set'])
@app.command('switch | set')
def switch(
ctx: typer.Context,
scene_collection_name: Annotated[
str, Argument(hint='Name of the scene collection to switch to')
str, typer.Argument(..., help='Name of the scene collection to switch to')
],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Switch to a scene collection."""
if not validate.scene_collection_in_scene_collections(ctx, scene_collection_name):
raise OBSWSCLIError(
f'Scene collection [yellow]{scene_collection_name}[/yellow] not found.',
exit_code=ExitCode.ERROR,
console.err.print(
f'Scene collection [yellow]{scene_collection_name}[/yellow] not found.'
)
raise typer.Exit(1)
current_scene_collection = (
ctx.client.get_scene_collection_list().current_scene_collection_name
ctx.obj['obsws'].get_scene_collection_list().current_scene_collection_name
)
if scene_collection_name == current_scene_collection:
raise OBSWSCLIError(
f'Scene collection [yellow]{scene_collection_name}[/yellow] is already active.',
exit_code=ExitCode.ERROR,
console.err.print(
f'Scene collection [yellow]{scene_collection_name}[/yellow] is already active.'
)
raise typer.Exit(1)
ctx.client.set_current_scene_collection(scene_collection_name)
ctx.obj['obsws'].set_current_scene_collection(scene_collection_name)
console.out.print(
f'Switched to scene collection {console.highlight(ctx, scene_collection_name)}.'
)
@app.command(name=['create', 'new'])
@app.command('create | new')
def create(
ctx: typer.Context,
scene_collection_name: Annotated[
str, Argument(hint='Name of the scene collection to create')
str, typer.Argument(..., help='Name of the scene collection to create')
],
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Create a new scene collection."""
if validate.scene_collection_in_scene_collections(ctx, scene_collection_name):
raise OBSWSCLIError(
f'Scene collection [yellow]{scene_collection_name}[/yellow] already exists.',
exit_code=ExitCode.ERROR,
console.err.print(
f'Scene collection [yellow]{scene_collection_name}[/yellow] already exists.'
)
raise typer.Exit(1)
ctx.client.create_scene_collection(scene_collection_name)
ctx.obj['obsws'].create_scene_collection(scene_collection_name)
console.out.print(
f'Created scene collection {console.highlight(ctx, scene_collection_name)}.'
)

220
obsws_cli/sceneitem.py
View File

@ -2,42 +2,41 @@
from typing import Annotated, Optional
from cyclopts import App, Argument, Parameter
import typer
from rich.table import Table
from . import console, util, validate
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='sceneitem', help='Commands for controlling scene items in OBS.')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['list', 'ls'])
@app.callback()
def main():
"""Control items in OBS scenes."""
@app.command('list | ls')
def list_(
ctx: typer.Context,
scene_name: Annotated[
Optional[str],
Argument(
hint='Scene name to list items for',
typer.Argument(
show_default='The current scene',
help='Scene name to list items for',
),
] = None,
/,
uuid: Annotated[bool, Parameter(help='Show UUIDs of scene items')] = False,
*,
ctx: Annotated[Context, Parameter(parse=False)],
uuid: Annotated[bool, typer.Option(help='Show UUIDs of scene items')] = False,
):
"""List all items in a scene."""
if not scene_name:
scene_name = ctx.client.get_current_program_scene().scene_name
scene_name = ctx.obj['obsws'].get_current_program_scene().scene_name
if not validate.scene_in_scenes(ctx, scene_name):
console.err.print(f'Scene [yellow]{scene_name}[/yellow] not found.')
raise OBSWSCLIError(
f'Scene [yellow]{scene_name}[/yellow] not found.',
exit_code=ExitCode.ERROR,
)
raise typer.Exit(1)
resp = ctx.client.get_scene_item_list(scene_name)
resp = ctx.obj['obsws'].get_scene_item_list(scene_name)
items = sorted(
(
(
@ -53,10 +52,10 @@ def list_(
)
if not items:
raise OBSWSCLIError(
f'No items found in scene [yellow]{scene_name}[/yellow].',
exit_code=ExitCode.SUCCESS,
console.out.print(
f'No items found in scene {console.highlight(ctx, scene_name)}.'
)
raise typer.Exit()
table = Table(
title=f'Items in Scene: {scene_name}',
@ -139,39 +138,36 @@ def list_(
def _validate_sources(
ctx: Context,
ctx: typer.Context,
scene_name: str,
item_name: str,
group: Optional[str] = None,
):
) -> bool:
"""Validate the scene name and item name."""
if not validate.scene_in_scenes(ctx, scene_name):
raise OBSWSCLIError(
f'Scene [yellow]{scene_name}[/yellow] not found.',
exit_code=ExitCode.ERROR,
)
console.err.print(f'Scene [yellow]{scene_name}[/yellow] not found.')
return False
if group:
if not validate.item_in_scene_item_list(ctx, scene_name, group):
raise OBSWSCLIError(
f'Group [yellow]{group}[/yellow] not found in scene [yellow]{scene_name}[/yellow].',
exit_code=ExitCode.ERROR,
console.err.print(
f'Group [yellow]{group}[/yellow] not found in scene [yellow]{scene_name}[/yellow].'
)
return False
else:
if not validate.item_in_scene_item_list(ctx, scene_name, item_name):
raise OBSWSCLIError(
console.err.print(
f'Item [yellow]{item_name}[/yellow] not found in scene [yellow]{scene_name}[/yellow]. Is the item in a group? '
f'If so use the [yellow]--group[/yellow] option to specify the parent group.\n'
'Use [yellow]obsws-cli sceneitem ls[/yellow] for a list of items in the scene.',
exit_code=ExitCode.ERROR,
'Use [yellow]obsws-cli sceneitem ls[/yellow] for a list of items in the scene.'
)
return False
return True
def _get_scene_name_and_item_id(
ctx: Context,
scene_name: str,
item_name: str,
group: Optional[str] = None,
ctx: typer.Context, scene_name: str, item_name: str, group: Optional[str] = None
):
"""Get the scene name and item ID for the given scene and item name."""
if group:
@ -182,10 +178,10 @@ def _get_scene_name_and_item_id(
scene_item_id = item.get('sceneItemId')
break
else:
raise OBSWSCLIError(
f'Item [yellow]{item_name}[/yellow] not found in group [yellow]{group}[/yellow].',
exit_code=ExitCode.ERROR,
console.err.print(
f'Item [yellow]{item_name}[/yellow] not found in group [yellow]{group}[/yellow].'
)
raise typer.Exit(1)
else:
resp = ctx.obj['obsws'].get_scene_item_id(scene_name, item_name)
scene_item_id = resp.scene_item_id
@ -193,20 +189,21 @@ def _get_scene_name_and_item_id(
return scene_name, scene_item_id
@app.command(name=['show', 'sh'])
@app.command('show | sh')
def show(
scene_name: Annotated[str, Argument(hint='Scene name the item is in')],
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the item is in')
],
item_name: Annotated[
str,
Argument(hint='Item name to show in the scene'),
typer.Argument(..., show_default=False, help='Item name to show in the scene'),
],
/,
group: Annotated[Optional[str], Parameter(help='Parent group name')] = None,
*,
ctx: Annotated[Context, Parameter(parse=False)],
group: Annotated[Optional[str], typer.Option(help='Parent group name')] = None,
):
"""Show an item in a scene."""
_validate_sources(ctx, scene_name, item_name, group)
if not _validate_sources(ctx, scene_name, item_name, group):
raise typer.Exit(1)
old_scene_name = scene_name
scene_name, scene_item_id = _get_scene_name_and_item_id(
@ -234,20 +231,21 @@ def show(
)
@app.command(name=['hide', 'h'])
@app.command('hide | h')
def hide(
scene_name: Annotated[str, Argument(hint='Scene name the item is in')],
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the item is in')
],
item_name: Annotated[
str,
Argument(hint='Item name to hide in the scene'),
typer.Argument(..., show_default=False, help='Item name to hide in the scene'),
],
/,
group: Annotated[Optional[str], Parameter(help='Parent group name')] = None,
*,
ctx: Annotated[Context, Parameter(parse=False)],
group: Annotated[Optional[str], typer.Option(help='Parent group name')] = None,
):
"""Hide an item in a scene."""
_validate_sources(ctx, scene_name, item_name, group)
if not _validate_sources(ctx, scene_name, item_name, group):
raise typer.Exit(1)
old_scene_name = scene_name
scene_name, scene_item_id = _get_scene_name_and_item_id(
@ -274,30 +272,36 @@ def hide(
)
@app.command(name=['toggle', 'tg'])
@app.command('toggle | tg')
def toggle(
scene_name: Annotated[str, Argument(hint='Scene name the item is in')],
item_name: Annotated[str, Argument(hint='Item name to toggle in the scene')],
/,
group: Annotated[Optional[str], Parameter(help='Parent group name')] = None,
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the item is in')
],
item_name: Annotated[
str,
typer.Argument(
..., show_default=False, help='Item name to toggle in the scene'
),
],
group: Annotated[Optional[str], typer.Option(help='Parent group name')] = None,
):
"""Toggle an item in a scene."""
_validate_sources(ctx, scene_name, item_name, group)
if not _validate_sources(ctx, scene_name, item_name, group):
raise typer.Exit(1)
old_scene_name = scene_name
scene_name, scene_item_id = _get_scene_name_and_item_id(
ctx, scene_name, item_name, group
)
enabled = ctx.client.get_scene_item_enabled(
enabled = ctx.obj['obsws'].get_scene_item_enabled(
scene_name=scene_name,
item_id=int(scene_item_id),
)
new_state = not enabled.scene_item_enabled
ctx.client.set_scene_item_enabled(
ctx.obj['obsws'].set_scene_item_enabled(
scene_name=scene_name,
item_id=int(scene_item_id),
enabled=new_state,
@ -329,26 +333,30 @@ def toggle(
)
@app.command(name=['visible', 'v'])
@app.command('visible | v')
def visible(
scene_name: Annotated[str, Argument(hint='Scene name the item is in')],
item_name: Annotated[
str, Argument(hint='Item name to check visibility in the scene')
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the item is in')
],
/,
group: Annotated[Optional[str], Parameter(help='Parent group name')] = None,
*,
ctx: Annotated[Context, Parameter(parse=False)],
item_name: Annotated[
str,
typer.Argument(
..., show_default=False, help='Item name to check visibility in the scene'
),
],
group: Annotated[Optional[str], typer.Option(help='Parent group name')] = None,
):
"""Check if an item in a scene is visible."""
_validate_sources(ctx, scene_name, item_name, group)
if not _validate_sources(ctx, scene_name, item_name, group):
raise typer.Exit(1)
old_scene_name = scene_name
scene_name, scene_item_id = _get_scene_name_and_item_id(
ctx, scene_name, item_name, group
)
enabled = ctx.client.get_scene_item_enabled(
enabled = ctx.obj['obsws'].get_scene_item_enabled(
scene_name=scene_name,
item_id=int(scene_item_id),
)
@ -369,62 +377,68 @@ def visible(
)
@app.command(name=['transform', 't'])
@app.command('transform | t')
def transform(
scene_name: Annotated[str, Argument(hint='Scene name the item is in')],
item_name: Annotated[str, Argument(hint='Item name to transform in the scene')],
/,
group: Annotated[Optional[str], Parameter(help='Parent group name')] = None,
ctx: typer.Context,
scene_name: Annotated[
str, typer.Argument(..., show_default=False, help='Scene name the item is in')
],
item_name: Annotated[
str,
typer.Argument(
..., show_default=False, help='Item name to transform in the scene'
),
],
group: Annotated[Optional[str], typer.Option(help='Parent group name')] = None,
alignment: Annotated[
Optional[int], Parameter(help='Alignment of the item in the scene')
Optional[int], typer.Option(help='Alignment of the item in the scene')
] = None,
bounds_alignment: Annotated[
Optional[int], Parameter(help='Bounds alignment of the item in the scene')
Optional[int], typer.Option(help='Bounds alignment of the item in the scene')
] = None,
bounds_height: Annotated[
Optional[float], Parameter(help='Height of the item in the scene')
Optional[float], typer.Option(help='Height of the item in the scene')
] = None,
bounds_type: Annotated[
Optional[str], Parameter(help='Type of bounds for the item in the scene')
Optional[str], typer.Option(help='Type of bounds for the item in the scene')
] = None,
bounds_width: Annotated[
Optional[float], Parameter(help='Width of the item in the scene')
Optional[float], typer.Option(help='Width of the item in the scene')
] = None,
crop_to_bounds: Annotated[
Optional[bool], Parameter(help='Crop the item to the bounds')
Optional[bool], typer.Option(help='Crop the item to the bounds')
] = None,
crop_bottom: Annotated[
Optional[float], Parameter(help='Bottom crop of the item in the scene')
Optional[float], typer.Option(help='Bottom crop of the item in the scene')
] = None,
crop_left: Annotated[
Optional[float], Parameter(help='Left crop of the item in the scene')
Optional[float], typer.Option(help='Left crop of the item in the scene')
] = None,
crop_right: Annotated[
Optional[float], Parameter(help='Right crop of the item in the scene')
Optional[float], typer.Option(help='Right crop of the item in the scene')
] = None,
crop_top: Annotated[
Optional[float], Parameter(help='Top crop of the item in the scene')
Optional[float], typer.Option(help='Top crop of the item in the scene')
] = None,
position_x: Annotated[
Optional[float], Parameter(help='X position of the item in the scene')
Optional[float], typer.Option(help='X position of the item in the scene')
] = None,
position_y: Annotated[
Optional[float], Parameter(help='Y position of the item in the scene')
Optional[float], typer.Option(help='Y position of the item in the scene')
] = None,
rotation: Annotated[
Optional[float], Parameter(help='Rotation of the item in the scene')
Optional[float], typer.Option(help='Rotation of the item in the scene')
] = None,
scale_x: Annotated[
Optional[float], Parameter(help='X scale of the item in the scene')
Optional[float], typer.Option(help='X scale of the item in the scene')
] = None,
scale_y: Annotated[
Optional[float], Parameter(help='Y scale of the item in the scene')
Optional[float], typer.Option(help='Y scale of the item in the scene')
] = None,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Set the transform of an item in a scene."""
_validate_sources(ctx, scene_name, item_name, group)
if not _validate_sources(ctx, scene_name, item_name, group):
raise typer.Exit(1)
old_scene_name = scene_name
scene_name, scene_item_id = _get_scene_name_and_item_id(
@ -464,12 +478,10 @@ def transform(
transform['scaleY'] = scale_y
if not transform:
raise OBSWSCLIError(
'No transform options provided. Use at least one of the transform options.',
exit_code=ExitCode.ERROR,
)
console.err.print('No transform options provided.')
raise typer.Exit(1)
transform = ctx.client.set_scene_item_transform(
transform = ctx.obj['obsws'].set_scene_item_transform(
scene_name=scene_name,
item_id=int(scene_item_id),
transform=transform,

53
obsws_cli/screenshot.py
View File

@ -4,57 +4,66 @@ from pathlib import Path
from typing import Annotated
import obsws_python as obsws
from cyclopts import App, Argument, Parameter
import typer
from . import console
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='screenshot', help='Commands for taking screenshots using OBS.')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['save', 'sv'])
@app.callback()
def main():
"""Take screenshots using OBS."""
@app.command('save | sv')
def save(
ctx: typer.Context,
source_name: Annotated[
str,
Argument(
hint='Name of the source to take a screenshot of.',
typer.Argument(
...,
show_default=False,
help='Name of the source to take a screenshot of.',
),
],
output_path: Annotated[
Path,
# Since the CLI and OBS may be running on different platforms,
# we won't validate the path here.
Argument(
hint='Path to save the screenshot (must include file name and extension).',
typer.Argument(
...,
show_default=False,
file_okay=True,
dir_okay=False,
help='Path to save the screenshot (must include file name and extension).',
),
],
/,
width: Annotated[
float,
Parameter(
typer.Option(
help='Width of the screenshot.',
),
] = 1920,
height: Annotated[
float,
Parameter(
typer.Option(
help='Height of the screenshot.',
),
] = 1080,
quality: Annotated[
float,
Parameter(
typer.Option(
min=-1,
max=100,
help='Quality of the screenshot.',
),
] = -1,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Take a screenshot and save it to a file."""
try:
ctx.client.save_source_screenshot(
ctx.obj['obsws'].save_source_screenshot(
name=source_name,
img_format=output_path.suffix.lstrip('.').lower(),
file_path=str(output_path),
@ -65,16 +74,16 @@ def save(
except obsws.error.OBSSDKRequestError as e:
match e.code:
case 403:
raise OBSWSCLIError(
console.err.print(
'The [yellow]image format[/yellow] (file extension) must be included in the file name, '
"for example: '/path/to/screenshot.png'.",
code=ExitCode.ERROR,
)
raise typer.Exit(1)
case 600:
raise OBSWSCLIError(
'No source was found by the name of [yellow]{source_name}[/yellow]',
code=ExitCode.ERROR,
console.err.print(
f'No source was found by the name of [yellow]{source_name}[/yellow]'
)
raise typer.Exit(1)
case _:
raise

80
obsws_cli/settings.py Normal file
View File

@ -0,0 +1,80 @@
"""module for settings management for obsws-cli."""
from collections import UserDict
from pathlib import Path
from dotenv import dotenv_values
SettingsValue = str | int
class Settings(UserDict):
"""A class to manage settings for obsws-cli.
This class extends UserDict to provide a dictionary-like interface for settings.
It loads settings from environment variables and .env files.
The settings are expected to be in uppercase and should start with 'OBS_'.
Example:
-------
settings = Settings()
host = settings['OBS_HOST']
settings['OBS_PORT'] = 4455
"""
PREFIX = 'OBS_'
def __init__(self, *args, **kwargs):
"""Initialize the Settings object."""
kwargs.update(
{
**dotenv_values('.env'),
**dotenv_values(Path.home() / '.config' / 'obsws-cli' / 'obsws.env'),
}
)
super().__init__(*args, **kwargs)
def __getitem__(self, key: str) -> SettingsValue:
"""Get a setting value by key."""
key = key.upper()
if not key.startswith(Settings.PREFIX):
key = f'{Settings.PREFIX}{key}'
return self.data[key]
def __setitem__(self, key: str, value: SettingsValue):
"""Set a setting value by key."""
key = key.upper()
if not key.startswith(Settings.PREFIX):
key = f'{Settings.PREFIX}{key}'
self.data[key] = value
_settings = Settings(
OBS_HOST='localhost',
OBS_PORT=4455,
OBS_PASSWORD='',
OBS_TIMEOUT=5,
OBS_DEBUG=False,
OBS_STYLE='disabled',
OBS_STYLE_NO_BORDER=False,
)
def get(key: str) -> SettingsValue:
"""Get a setting value by key.
Args:
----
key (str): The key of the setting to retrieve.
Returns:
-------
The value of the setting.
Raises:
------
KeyError: If the key does not exist in the settings.
"""
return _settings[key]

65
obsws_cli/stream.py
View File

@ -1,75 +1,60 @@
"""module for controlling OBS stream functionality."""
from typing import Annotated
from cyclopts import App, Parameter
import typer
from . import console
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='stream', help='Commands for controlling OBS stream functionality.')
app = typer.Typer(cls=SubTyperAliasGroup)
def _get_streaming_status(ctx: Context) -> tuple:
@app.callback()
def main():
"""Control OBS stream functionality."""
def _get_streaming_status(ctx: typer.Context) -> tuple:
"""Get streaming status."""
resp = ctx.client.get_stream_status()
resp = ctx.obj['obsws'].get_stream_status()
return resp.output_active, resp.output_duration
@app.command(name=['start', 's'])
def start(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('start | s')
def start(ctx: typer.Context):
"""Start streaming."""
active, _ = _get_streaming_status(ctx)
if active:
raise OBSWSCLIError(
'Streaming is already in progress, cannot start.',
code=ExitCode.ERROR,
)
console.err.print('Streaming is already in progress, cannot start.')
raise typer.Exit(1)
ctx.client.start_stream()
ctx.obj['obsws'].start_stream()
console.out.print('Streaming started successfully.')
@app.command(name=['stop', 'st'])
def stop(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('stop | st')
def stop(ctx: typer.Context):
"""Stop streaming."""
active, _ = _get_streaming_status(ctx)
if not active:
raise OBSWSCLIError(
'Streaming is not in progress, cannot stop.',
code=ExitCode.ERROR,
)
console.err.print('Streaming is not in progress, cannot stop.')
raise typer.Exit(1)
ctx.client.stop_stream()
ctx.obj['obsws'].stop_stream()
console.out.print('Streaming stopped successfully.')
@app.command(name=['toggle', 'tg'])
def toggle(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('toggle | tg')
def toggle(ctx: typer.Context):
"""Toggle streaming."""
resp = ctx.client.toggle_stream()
resp = ctx.obj['obsws'].toggle_stream()
if resp.output_active:
console.out.print('Streaming started successfully.')
else:
console.out.print('Streaming stopped successfully.')
@app.command(name=['status', 'ss'])
def status(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('status | ss')
def status(ctx: typer.Context):
"""Get streaming status."""
active, duration = _get_streaming_status(ctx)
if active:

51
obsws_cli/studiomode.py
View File

@ -1,57 +1,48 @@
"""module containing commands for manipulating studio mode in OBS."""
from typing import Annotated
from cyclopts import App, Parameter
import typer
from . import console
from .context import Context
from .alias import SubTyperAliasGroup
app = App(name='studiomode', help='Commands for controlling studio mode in OBS.')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['enable', 'on'])
def enable(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.callback()
def main():
"""Control studio mode in OBS."""
@app.command('enable | on')
def enable(ctx: typer.Context):
"""Enable studio mode."""
ctx.obj['obsws'].set_studio_mode_enabled(True)
console.out.print('Studio mode has been enabled.')
@app.command(name=['disable', 'off'])
def disable(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('disable | off')
def disable(ctx: typer.Context):
"""Disable studio mode."""
ctx.client.set_studio_mode_enabled(False)
ctx.obj['obsws'].set_studio_mode_enabled(False)
console.out.print('Studio mode has been disabled.')
@app.command(name=['toggle', 'tg'])
def toggle(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('toggle | tg')
def toggle(ctx: typer.Context):
"""Toggle studio mode."""
resp = ctx.client.get_studio_mode_enabled()
resp = ctx.obj['obsws'].get_studio_mode_enabled()
if resp.studio_mode_enabled:
ctx.client.set_studio_mode_enabled(False)
ctx.obj['obsws'].set_studio_mode_enabled(False)
console.out.print('Studio mode is now disabled.')
else:
ctx.client.set_studio_mode_enabled(True)
ctx.obj['obsws'].set_studio_mode_enabled(True)
console.out.print('Studio mode is now enabled.')
@app.command(name=['status', 'ss'])
def status(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('status | ss')
def status(ctx: typer.Context):
"""Get the status of studio mode."""
resp = ctx.client.get_studio_mode_enabled()
resp = ctx.obj['obsws'].get_studio_mode_enabled()
if resp.studio_mode_enabled:
console.out.print('Studio mode is enabled.')
else:

58
obsws_cli/text.py
View File

@ -2,34 +2,35 @@
from typing import Annotated, Optional
from cyclopts import App, Argument, Parameter
import typer
from . import console, validate
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
from .alias import SubTyperAliasGroup
app = App(name='text', help='Commands for controlling text inputs in OBS.')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['current', 'get'])
@app.callback()
def main():
"""Control text inputs in OBS."""
@app.command('current | get')
def current(
input_name: Annotated[str, Argument(hint='Name of the text input to get.')],
*,
ctx: Annotated[Context, Parameter(parse=False)],
ctx: typer.Context,
input_name: Annotated[str, typer.Argument(help='Name of the text input to get.')],
):
"""Get the current text for a text input."""
if not validate.input_in_inputs(ctx, input_name):
raise OBSWSCLIError(
f'Input [yellow]{input_name}[/yellow] not found.', code=ExitCode.ERROR
)
console.err.print(f'Input [yellow]{input_name}[/yellow] not found.')
raise typer.Exit(1)
resp = ctx.client.get_input_settings(name=input_name)
resp = ctx.obj['obsws'].get_input_settings(name=input_name)
if not resp.input_kind.startswith('text_'):
raise OBSWSCLIError(
console.err.print(
f'Input [yellow]{input_name}[/yellow] is not a text input.',
code=ExitCode.ERROR,
)
raise typer.Exit(1)
current_text = resp.input_settings.get('text', '')
if not current_text:
@ -39,31 +40,32 @@ def current(
)
@app.command(name=['update', 'set'])
@app.command('update | set')
def update(
input_name: Annotated[str, Argument(hint='Name of the text input to update.')],
ctx: typer.Context,
input_name: Annotated[
str, typer.Argument(help='Name of the text input to update.')
],
new_text: Annotated[
Optional[str],
Argument(hint='The new text to set for the input.'),
typer.Argument(
help='The new text to set for the input.',
),
] = None,
/,
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Update the text of a text input."""
if not validate.input_in_inputs(ctx, input_name):
raise OBSWSCLIError(
f'Input [yellow]{input_name}[/yellow] not found.', code=ExitCode.ERROR
)
console.err.print(f'Input [yellow]{input_name}[/yellow] not found.')
raise typer.Exit(1)
resp = ctx.client.get_input_settings(name=input_name)
resp = ctx.obj['obsws'].get_input_settings(name=input_name)
if not resp.input_kind.startswith('text_'):
raise OBSWSCLIError(
console.err.print(
f'Input [yellow]{input_name}[/yellow] is not a text input.',
code=ExitCode.ERROR,
)
raise typer.Exit(1)
ctx.client.set_input_settings(
ctx.obj['obsws'].set_input_settings(
name=input_name,
settings={'text': new_text},
overlay=True,

5
obsws_cli/validate.py
View File

@ -1,7 +1,12 @@
"""module containing validation functions."""
import typer
from .context import Context
# type alias for an option that is skipped when the command is run
skipped_option = typer.Option(parser=lambda _: _, hidden=True, expose_value=False)
def input_in_inputs(ctx: Context, input_name: str) -> bool:
"""Check if an input is in the input list."""

45
obsws_cli/virtualcam.py
View File

@ -1,51 +1,46 @@
"""module containing commands for manipulating virtual camera in OBS."""
from typing import Annotated
from cyclopts import App, Parameter
import typer
from . import console
from .context import Context
from .alias import SubTyperAliasGroup
app = App(name='virtualcam', help='Commands for controlling the virtual camera in OBS.')
app = typer.Typer(cls=SubTyperAliasGroup)
@app.command(name=['start', 's'])
def start(
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.callback()
def main():
"""Control virtual camera in OBS."""
@app.command('start | s')
def start(ctx: typer.Context):
"""Start the virtual camera."""
ctx.client.start_virtual_cam()
ctx.obj['obsws'].start_virtual_cam()
console.out.print('Virtual camera started.')
@app.command(name=['stop', 'p'])
def stop(
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('stop | p')
def stop(ctx: typer.Context):
"""Stop the virtual camera."""
ctx.client.stop_virtual_cam()
ctx.obj['obsws'].stop_virtual_cam()
console.out.print('Virtual camera stopped.')
@app.command(name=['toggle', 'tg'])
def toggle(
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('toggle | tg')
def toggle(ctx: typer.Context):
"""Toggle the virtual camera."""
resp = ctx.client.toggle_virtual_cam()
resp = ctx.obj['obsws'].toggle_virtual_cam()
if resp.output_active:
console.out.print('Virtual camera is enabled.')
else:
console.out.print('Virtual camera is disabled.')
@app.command(name=['status', 'ss'])
def status(
ctx: Annotated[Context, Parameter(parse=False)],
):
@app.command('status | ss')
def status(ctx: typer.Context):
"""Get the status of the virtual camera."""
resp = ctx.client.get_virtual_cam_status()
resp = ctx.obj['obsws'].get_virtual_cam_status()
if resp.output_active:
console.out.print('Virtual camera is enabled.')
else:

7
pyproject.toml
View File

@ -21,7 +21,12 @@ classifiers = [
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
]
dependencies = ["cyclopts>=3.22.2", "obsws-python>=1.8.0"]
dependencies = [
"cyclopts>=3.22.2",
"typer>=0.16.0",
"obsws-python>=1.8.0",
"python-dotenv>=1.1.0",
]
[project.urls]