onyx_online/obsws-cli
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/obsws-cli.git synced 2025-08-03 10:31:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: 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
...
compare: 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

19 Commits
105aaf29b7 ... 3b184c6531

Author SHA1 Message Date
onyx-and-iris
3b184c6531 upd dependencies 2025-07-24 04:21:58 +01:00
onyx-and-iris
8c37ce1fc0 remove typer import 2025-07-24 04:21:48 +01:00
onyx-and-iris
436e4d5345 remove alias, settings 2025-07-24 04:21:40 +01:00
onyx-and-iris
2ef89be184 convert virtualcam commands 2025-07-24 04:09:49 +01:00
onyx-and-iris
506aff833c convert text commands 2025-07-24 04:08:07 +01:00
onyx-and-iris
eb939b735c convert studiomode commands 2025-07-24 04:05:01 +01:00
onyx-and-iris
bb7a468dd5 convert stream commands 2025-07-24 03:59:37 +01:00
onyx-and-iris
e77627b845 convert screenshot commands 2025-07-24 03:52:50 +01:00
onyx-and-iris
93b066090b fix aliases 2025-07-24 03:49:31 +01:00
onyx-and-iris
1ce832dfde convert sceneitem commands 2025-07-24 03:46:11 +01:00
onyx-and-iris
e8664f0117 convert scenecollection commands 2025-07-24 02:34:15 +01:00
onyx-and-iris
a3dff0f739 convert replaybuffer commands 2025-07-24 02:29:58 +01:00
onyx-and-iris
6da9df5ceb convert record commands 2025-07-24 02:26:18 +01:00
onyx-and-iris
75fc18273e convert projector commands 2025-07-24 02:20:17 +01:00
onyx-and-iris
e658819719 convert profile commands 2025-07-24 02:14:38 +01:00
onyx-and-iris
4451fbf22c conver input commands 2025-07-24 02:06:05 +01:00
onyx-and-iris
132b283347 convert hotkey commands 2025-07-24 01:48:55 +01:00
onyx-and-iris
ae8ff20cf4 convert group commands 2025-07-24 01:39:02 +01:00
onyx-and-iris
de1c604c46 update the --help message 
add descriptions for filter + scene command groups

Usage now after main CLI description
 2025-07-24 01:38:42 +01:00
21 changed files with 704 additions and 785 deletions
Show Stats Expand all files Collapse all files

73
obsws_cli/alias.py
View File

@ -1,73 +0,0 @@
"""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,11 +19,26 @@ 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('Session Parameters', sort_key=0)
app.meta.group_parameters = Group('Options', 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)
@ -74,7 +89,7 @@ def launcher(
Parameter(validator=setup_logging),
] = False,
):
"""Initialize the OBS WebSocket client and return the context."""
"""Command line interface for the OBS WebSocket API."""
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')
app = App(name='filter', help='Commands for managing filters in OBS sources')
@app.command(name=['list', 'ls'])

180
obsws_cli/group.py
View File

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

56
obsws_cli/hotkey.py
View File

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

106
obsws_cli/input.py
View File

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

97
obsws_cli/profile.py
View File

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

59
obsws_cli/projector.py
View File

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

150
obsws_cli/record.py
View File

@ -3,67 +3,75 @@
from pathlib import Path
from typing import Annotated, Optional
import typer
from cyclopts import App, Argument, Parameter
from . import console
from .alias import SubTyperAliasGroup
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
app = typer.Typer(cls=SubTyperAliasGroup)
app = App(name='record', help='Commands for controlling OBS recording functionality.')
@app.callback()
def main():
"""Control OBS recording functionality."""
def _get_recording_status(ctx: typer.Context) -> tuple:
def _get_recording_status(ctx: Context) -> tuple:
"""Get recording status."""
resp = ctx.obj['obsws'].get_record_status()
resp = ctx.client.get_record_status()
return resp.output_active, resp.output_paused
@app.command('start | s')
def start(ctx: typer.Context):
@app.command(name=['start', 's'])
def start(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""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)
console.err.print(err_msg)
raise typer.Exit(1)
ctx.obj['obsws'].start_record()
ctx.client.start_record()
console.out.print('Recording started successfully.')
@app.command('stop | st')
def stop(ctx: typer.Context):
@app.command(name=['stop', 'st'])
def stop(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Stop recording."""
active, _ = _get_recording_status(ctx)
if not active:
console.err.print('Recording is not in progress, cannot stop.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is not in progress, cannot stop.', ExitCode.ERROR
)
resp = ctx.obj['obsws'].stop_record()
resp = ctx.client.stop_record()
console.out.print(
f'Recording stopped successfully. Saved to: {console.highlight(ctx, resp.output_path)}'
)
@app.command('toggle | tg')
def toggle(ctx: typer.Context):
@app.command(name=['toggle', 'tg'])
def toggle(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Toggle recording."""
resp = ctx.obj['obsws'].toggle_record()
resp = ctx.client.toggle_record()
if resp.output_active:
console.out.print('Recording started successfully.')
else:
console.out.print('Recording stopped successfully.')
@app.command('status | ss')
def status(ctx: typer.Context):
@app.command(name=['status', 'ss'])
def status(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Get recording status."""
active, paused = _get_recording_status(ctx)
if active:
@ -75,98 +83,114 @@ def status(ctx: typer.Context):
console.out.print('Recording is not in progress.')
@app.command('resume | r')
def resume(ctx: typer.Context):
@app.command(name=['resume', 'r'])
def resume(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Resume recording."""
active, paused = _get_recording_status(ctx)
if not active:
console.err.print('Recording is not in progress, cannot resume.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is not in progress, cannot resume.', ExitCode.ERROR
)
if not paused:
console.err.print('Recording is in progress but not paused, cannot resume.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is in progress but not paused, cannot resume.', ExitCode.ERROR
)
ctx.obj['obsws'].resume_record()
ctx.client.resume_record()
console.out.print('Recording resumed successfully.')
@app.command('pause | p')
def pause(ctx: typer.Context):
@app.command(name=['pause', 'p'])
def pause(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Pause recording."""
active, paused = _get_recording_status(ctx)
if not active:
console.err.print('Recording is not in progress, cannot pause.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is not in progress, cannot pause.', ExitCode.ERROR
)
if paused:
console.err.print('Recording is in progress but already paused, cannot pause.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is in progress but already paused, cannot pause.', ExitCode.ERROR
)
ctx.obj['obsws'].pause_record()
ctx.client.pause_record()
console.out.print('Recording paused successfully.')
@app.command('directory | d')
@app.command(name=['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.
typer.Argument(
file_okay=False,
dir_okay=True,
help='Directory to set for recording.',
Argument(
hint='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.obj['obsws'].set_record_directory(str(record_directory))
ctx.client.set_record_directory(str(record_directory))
console.out.print(
f'Recording directory updated to: {console.highlight(ctx, record_directory)}'
)
else:
resp = ctx.obj['obsws'].get_record_directory()
resp = ctx.client.get_record_directory()
console.out.print(
f'Recording directory: {console.highlight(ctx, resp.record_directory)}'
)
@app.command('split | sp')
def split(ctx: typer.Context):
@app.command(name=['split', 'sp'])
def split(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Split the current recording."""
active, paused = _get_recording_status(ctx)
if not active:
console.err.print('Recording is not in progress, cannot split.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is not in progress, cannot split.', ExitCode.ERROR
)
if paused:
console.err.print('Recording is paused, cannot split.')
raise typer.Exit(1)
raise OBSWSCLIError('Recording is paused, cannot split.', ExitCode.ERROR)
ctx.obj['obsws'].split_record_file()
ctx.client.split_record_file()
console.out.print('Recording split successfully.')
@app.command('chapter | ch')
@app.command(name=['chapter', 'ch'])
def chapter(
ctx: typer.Context,
chapter_name: Annotated[
Optional[str],
typer.Argument(
help='Name of the chapter to create.',
Argument(
hint='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:
console.err.print('Recording is not in progress, cannot create chapter.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is not in progress, cannot create chapter.', ExitCode.ERROR
)
if paused:
console.err.print('Recording is paused, cannot create chapter.')
raise typer.Exit(1)
raise OBSWSCLIError(
'Recording is paused, cannot create chapter.', ExitCode.ERROR
)
ctx.obj['obsws'].create_record_chapter(chapter_name)
ctx.client.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,64 +1,78 @@
"""module containing commands for manipulating the replay buffer in OBS."""
import typer
from typing import Annotated
from cyclopts import App, Parameter
from . import console
from .alias import SubTyperAliasGroup
from .context import Context
from .enum import ExitCode
from .error import OBSWSCLIError
app = typer.Typer(cls=SubTyperAliasGroup)
app = App(
name='replaybuffer', help='Commands for controlling the replay buffer in OBS.'
)
@app.callback()
def main():
"""Control profiles in OBS."""
@app.command('start | s')
def start(ctx: typer.Context):
@app.command(name=['start', 's'])
def start(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Start the replay buffer."""
resp = ctx.obj['obsws'].get_replay_buffer_status()
resp = ctx.client.get_replay_buffer_status()
if resp.output_active:
console.err.print('Replay buffer is already active.')
raise typer.Exit(1)
raise OBSWSCLIError('Replay buffer is already active.', ExitCode.ERROR)
ctx.obj['obsws'].start_replay_buffer()
ctx.client.start_replay_buffer()
console.out.print('Replay buffer started.')
@app.command('stop | st')
def stop(ctx: typer.Context):
@app.command(name=['stop', 'st'])
def stop(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Stop the replay buffer."""
resp = ctx.obj['obsws'].get_replay_buffer_status()
resp = ctx.client.get_replay_buffer_status()
if not resp.output_active:
console.err.print('Replay buffer is not active.')
raise typer.Exit(1)
raise OBSWSCLIError('Replay buffer is not active.', ExitCode.ERROR)
ctx.obj['obsws'].stop_replay_buffer()
ctx.client.stop_replay_buffer()
console.out.print('Replay buffer stopped.')
@app.command('toggle | tg')
def toggle(ctx: typer.Context):
@app.command(name=['toggle', 'tg'])
def toggle(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Toggle the replay buffer."""
resp = ctx.obj['obsws'].toggle_replay_buffer()
resp = ctx.client.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('status | ss')
def status(ctx: typer.Context):
@app.command(name=['status', 'ss'])
def status(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Get the status of the replay buffer."""
resp = ctx.obj['obsws'].get_replay_buffer_status()
resp = ctx.client.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('save | sv')
def save(ctx: typer.Context):
@app.command(name=['save', 'sv'])
def save(
*,
ctx: Annotated[Context, Parameter(parse=False)],
):
"""Save the replay buffer."""
ctx.obj['obsws'].save_replay_buffer()
ctx.client.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')
app = App(name='scene', help='Commands for managing OBS scenes')
@app.command(name=['list', 'ls'])

79
obsws_cli/scenecollection.py
View File

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

218
obsws_cli/sceneitem.py
View File

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

53
obsws_cli/screenshot.py
View File

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

80
obsws_cli/settings.py
View File

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

51
obsws_cli/studiomode.py
View File

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

70
obsws_cli/text.py
View File

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

5
obsws_cli/validate.py
View File

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

7
pyproject.toml
View File

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