Sign Up

ComputerUseService

class ComputerUseService()

Synchronous ComputerUseService.

ComputerUseService.__init__

def __init__(impl: AsyncComputerUseService, bridge: SyncBridge) -> None

ComputerUseService.service

@property
def service() -> AddonProcessesService

ComputerUseService.mouse

@property
def mouse() -> MouseService

ComputerUseService.keyboard

@property
def keyboard() -> KeyboardService

ComputerUseService.screen

@property
def screen() -> ScreenService

ComputerUseService.display

@property
def display() -> DisplayService

ComputerUseService.a11y

@property
def a11y() -> A11yService

ComputerUseService.recording

@property
def recording() -> RecordingService

ComputerUseService.restart

def restart() -> ComputerUseRestartResponse

ComputerUseService.start

def start() -> ComputerUseLifecycleResult

ComputerUseService.status

def status() -> ComputerUseStatusResponse

ComputerUseService.stop

def stop() -> ComputerUseLifecycleResult

AsyncComputerUseService

class AsyncComputerUseService()

AsyncComputerUseService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncComputerUseService.status

async def status() -> ComputerUseStatusResponse

AsyncComputerUseService.start

async def start() -> ComputerUseLifecycleResult

AsyncComputerUseService.stop

async def stop() -> ComputerUseLifecycleResult

AsyncComputerUseService.restart

async def restart() -> ComputerUseRestartResponse

A11yService

class A11yService()

Synchronous A11yService.

A11yService.__init__

def __init__(impl: AsyncA11yService, bridge: SyncBridge) -> None

A11yService.find

def find(*,
         scope: ComputerUseA11yScope,
         pid: int | None = None,
         role: str | None = None,
         name: str | None = None,
         name_match: ComputerUseA11yNameMatch | None = None,
         states: Sequence[str] | None = None,
         limit: int | None = None) -> ComputerUseA11yFindResult

A11yService.focus

def focus(*, id: str) -> None

A11yService.invoke

def invoke(*, id: str, action: str | None = None) -> None

A11yService.set_value

def set_value(*, id: str, value: str) -> None

A11yService.tree

def tree(*,
         scope: ComputerUseA11yScope,
         pid: int | None = None,
         max_depth: int | None = None) -> ComputerUseA11yTree

AsyncA11yService

class AsyncA11yService()

AsyncA11yService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncA11yService.tree

async def tree(*,
               scope: ComputerUseA11yScope,
               pid: int | None = None,
               max_depth: int | None = None) -> ComputerUseA11yTree

AsyncA11yService.find

async def find(*,
               scope: ComputerUseA11yScope,
               pid: int | None = None,
               role: str | None = None,
               name: str | None = None,
               name_match: ComputerUseA11yNameMatch | None = None,
               states: Sequence[str] | None = None,
               limit: int | None = None) -> ComputerUseA11yFindResult

AsyncA11yService.focus

async def focus(*, id: str) -> None

AsyncA11yService.invoke

async def invoke(*, id: str, action: str | None = None) -> None

AsyncA11yService.set_value

async def set_value(*, id: str, value: str) -> None

AddonProcessesService

class AddonProcessesService()

Synchronous AddonProcessesService.

AddonProcessesService.__init__

def __init__(impl: AsyncAddonProcessesService, bridge: SyncBridge) -> None

AddonProcessesService.errors

def errors(name: str) -> ComputerUseProcessErrors

AddonProcessesService.logs

def logs(name: str) -> ComputerUseProcessLogs

AddonProcessesService.restart

def restart(name: str) -> ComputerUseProcessRestartResult

AddonProcessesService.status

@overload
def status() -> dict[str, ComputerUseProcessStatus]

AddonProcessesService.status

@overload
def status(name: str) -> ComputerUseProcessRunningStatus

AsyncAddonProcessesService

class AsyncAddonProcessesService()

AsyncAddonProcessesService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncAddonProcessesService.status

@overload
async def status() -> dict[str, ComputerUseProcessStatus]

AsyncAddonProcessesService.status

@overload
async def status(name: str) -> ComputerUseProcessRunningStatus

AsyncAddonProcessesService.restart

async def restart(name: str) -> ComputerUseProcessRestartResult

AsyncAddonProcessesService.logs

async def logs(name: str) -> ComputerUseProcessLogs

AsyncAddonProcessesService.errors

async def errors(name: str) -> ComputerUseProcessErrors

DisplayService

class DisplayService()

Synchronous DisplayService.

DisplayService.__init__

def __init__(impl: AsyncDisplayService, bridge: SyncBridge) -> None

DisplayService.info

def info() -> ComputerUseDisplayInfo

DisplayService.windows

def windows() -> ComputerUseDisplayWindows

AsyncDisplayService

class AsyncDisplayService()

AsyncDisplayService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncDisplayService.info

async def info() -> ComputerUseDisplayInfo

AsyncDisplayService.windows

async def windows() -> ComputerUseDisplayWindows

KeyboardService

class KeyboardService()

Synchronous KeyboardService.

KeyboardService.__init__

def __init__(impl: AsyncKeyboardService, bridge: SyncBridge) -> None

KeyboardService.hotkey

def hotkey(*, keys: str) -> None

KeyboardService.key

def key(*,
        key: str,
        modifiers: Sequence[ComputerUseKeyboardModifier] | None = None) -> None

KeyboardService.type

def type(*, text: str, delay: int | None = None) -> None

AsyncKeyboardService

class AsyncKeyboardService()

AsyncKeyboardService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncKeyboardService.type

async def type(*, text: str, delay: int | None = None) -> None

AsyncKeyboardService.key

async def key(*,
              key: str,
              modifiers: Sequence[ComputerUseKeyboardModifier] | None = None) -> None

AsyncKeyboardService.hotkey

async def hotkey(*, keys: str) -> None

MouseService

class MouseService()

Synchronous MouseService.

MouseService.__init__

def __init__(impl: AsyncMouseService, bridge: SyncBridge) -> None

MouseService.click

def click(*,
          x: int,
          y: int,
          button: ComputerUseMouseButton | None = None,
          double: bool | None = None) -> ComputerUsePoint

MouseService.drag

def drag(*,
         start_x: int,
         start_y: int,
         end_x: int,
         end_y: int,
         button: ComputerUseMouseButton | None = None) -> ComputerUsePoint

MouseService.move

def move(*, x: int, y: int) -> ComputerUsePoint

MouseService.position

def position() -> ComputerUsePoint

MouseService.scroll

def scroll(*,
           x: int,
           y: int,
           direction: ComputerUseScrollDirection,
           amount: int | None = None) -> ComputerUseScrollResult

AsyncMouseService

class AsyncMouseService()

AsyncMouseService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncMouseService.position

async def position() -> ComputerUsePoint

AsyncMouseService.move

async def move(*, x: int, y: int) -> ComputerUsePoint

AsyncMouseService.click

async def click(*,
                x: int,
                y: int,
                button: ComputerUseMouseButton | None = None,
                double: bool | None = None) -> ComputerUsePoint

AsyncMouseService.drag

async def drag(*,
               start_x: int,
               start_y: int,
               end_x: int,
               end_y: int,
               button: ComputerUseMouseButton | None = None) -> ComputerUsePoint

AsyncMouseService.scroll

async def scroll(*,
                 x: int,
                 y: int,
                 direction: ComputerUseScrollDirection,
                 amount: int | None = None) -> ComputerUseScrollResult

RecordingService

class RecordingService()

Synchronous RecordingService.

RecordingService.__init__

def __init__(impl: AsyncRecordingService, bridge: SyncBridge) -> None

RecordingService.delete

def delete(id: str) -> None

RecordingService.download

def download(id: str) -> bytes

RecordingService.get

def get(id: str) -> ComputerUseRecording

RecordingService.list

def list() -> ComputerUseRecordingList

RecordingService.start

def start(*, label: str | None = None) -> ComputerUseRecording

RecordingService.stop

def stop(*, id: str) -> ComputerUseRecording

AsyncRecordingService

class AsyncRecordingService()

AsyncRecordingService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncRecordingService.start

async def start(*, label: str | None = None) -> ComputerUseRecording

AsyncRecordingService.stop

async def stop(*, id: str) -> ComputerUseRecording

AsyncRecordingService.list

async def list() -> ComputerUseRecordingList

AsyncRecordingService.get

async def get(id: str) -> ComputerUseRecording

AsyncRecordingService.download

async def download(id: str) -> bytes

AsyncRecordingService.delete

async def delete(id: str) -> None

ScreenService

class ScreenService()

Synchronous ScreenService.

ScreenService.__init__

def __init__(impl: AsyncScreenService, bridge: SyncBridge) -> None

ScreenService.capture

def capture(*, show_cursor: bool | None = None) -> ComputerUseScreenshot

ScreenService.capture_compressed

def capture_compressed(*,
                       format: ComputerUseScreenshotFormat | None = None,
                       quality: int | None = None,
                       scale: float | None = None,
                       show_cursor: bool | None = None) -> ComputerUseScreenshot

ScreenService.region

def region(*,
           x: int,
           y: int,
           width: int,
           height: int,
           show_cursor: bool | None = None) -> ComputerUseScreenshot

ScreenService.region_compressed

def region_compressed(*,
                      x: int,
                      y: int,
                      width: int,
                      height: int,
                      format: ComputerUseScreenshotFormat | None = None,
                      quality: int | None = None,
                      scale: float | None = None,
                      show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService

class AsyncScreenService()

AsyncScreenService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncScreenService.capture

async def capture(*, show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService.region

async def region(*,
                 x: int,
                 y: int,
                 width: int,
                 height: int,
                 show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService.capture_compressed

async def capture_compressed(*,
                             format: ComputerUseScreenshotFormat | None = None,
                             quality: int | None = None,
                             scale: float | None = None,
                             show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService.region_compressed

async def region_compressed(*,
                            x: int,
                            y: int,
                            width: int,
                            height: int,
                            format: ComputerUseScreenshotFormat | None = None,
                            quality: int | None = None,
                            scale: float | None = None,
                            show_cursor: bool | None = None) -> ComputerUseScreenshot

ComputerUseDesktopFailure

@dataclass(frozen=True, slots=True)
class ComputerUseDesktopFailure()

Attributes:

  • code ComputerUseDesktopFailureCode
  • message str
  • extra_fields Optional[Dict[str, JsonValue]] = None
  • raw_code Optional[str] = None

ComputerUseNotStartedStatus

@dataclass(frozen=True, slots=True)
class ComputerUseNotStartedStatus()

Attributes:

  • status Literal['inactive'] = 'inactive'
  • desktop Literal['not_started'] = 'not_started'
  • cause None = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseStartingStatus

@dataclass(frozen=True, slots=True)
class ComputerUseStartingStatus()

Attributes:

  • status Literal['inactive'] = 'inactive'
  • desktop Literal['starting'] = 'starting'
  • cause None = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseReadyStatus

@dataclass(frozen=True, slots=True)
class ComputerUseReadyStatus()

Attributes:

  • status Literal['active'] = 'active'
  • desktop Literal['ready'] = 'ready'
  • cause None = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseFailedStatus

@dataclass(frozen=True, slots=True)
class ComputerUseFailedStatus()

Attributes:

  • cause ComputerUseDesktopFailure
  • status Literal['inactive'] = 'inactive'
  • desktop Literal['failed'] = 'failed'
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseUnknownStatus

@dataclass(frozen=True, slots=True)
class ComputerUseUnknownStatus()

A (status, desktop) pair this SDK release does not recognize, because a newer daemon added a value or a combination. raw_status / raw_desktop carry what the daemon sent; the recognized variants need no raw sibling, since their typed values are the wire values. cause is the failure the daemon attached to the unrecognized state, when it sent one.

Attributes:

  • raw_status str
  • raw_desktop str
  • status Literal['unknown'] = 'unknown'
  • desktop Literal['unknown'] = 'unknown'
  • cause Optional[ComputerUseDesktopFailure] = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseRestartResponse

@dataclass(frozen=True, slots=True)
class ComputerUseRestartResponse()

Attributes:

  • message str
  • status Literal['active'] = 'active'
  • desktop Literal['ready'] = 'ready'
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseProcessStatus

@dataclass(frozen=True, slots=True)
class ComputerUseProcessStatus()

Attributes:

  • running Optional[bool] = None
  • priority Optional[int] = None
  • auto_restart Optional[bool] = None
  • pid Optional[int] = None
  • failed Optional[bool] = None
  • restart_attempts Optional[int] = None
  • restart_backoff_ms Optional[int] = None
  • status Optional[str] = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseProcessRunningStatus

@dataclass(frozen=True, slots=True)
class ComputerUseProcessRunningStatus()

Attributes:

  • process_name str
  • running bool

ComputerUsePoint

@dataclass(frozen=True, slots=True)
class ComputerUsePoint()

Attributes:

  • x int
  • y int

ComputerUseDisplay

@dataclass(frozen=True, slots=True)
class ComputerUseDisplay()

Attributes:

  • id int
  • x int
  • y int
  • width int
  • height int
  • is_active bool

ComputerUseWindow

@dataclass(frozen=True, slots=True)
class ComputerUseWindow()

Attributes:

  • id int
  • title str
  • x int
  • y int
  • width int
  • height int
  • is_active bool

ComputerUseAccessibilityBounds

@dataclass(frozen=True, slots=True)
class ComputerUseAccessibilityBounds()

Attributes:

  • x int
  • y int
  • width int
  • height int

ComputerUseAccessibilityNode

@dataclass(frozen=True, slots=True)
class ComputerUseAccessibilityNode()

Attributes:

  • id str
  • role str
  • name str
  • bounds ComputerUseAccessibilityBounds
  • states List[str]
  • description Optional[str] = None
  • actions Optional[List[str]] = None
  • children Optional[List[ComputerUseAccessibilityNode]] = None
  • value Optional[str] = None
  • value_truncated bool = False

ComputerUseRecording

@dataclass(frozen=True, slots=True)
class ComputerUseRecording()

Attributes:

  • id str
  • file_name str
  • file_path str
  • start_time str
  • status str
  • end_time Optional[str] = None
  • duration_seconds Optional[float] = None
  • size_bytes Optional[int] = None

ComputerUseMouseButton

ComputerUseMouseButton = Literal['left', 'right', 'middle']

ComputerUseScrollDirection

ComputerUseScrollDirection = Literal['up', 'down']

ComputerUseScreenshotFormat

ComputerUseScreenshotFormat = Literal['png', 'jpeg']

ComputerUseKeyboardModifier

ComputerUseKeyboardModifier = Literal['ctrl', 'alt', 'shift', 'cmd']

ComputerUseA11yScope

ComputerUseA11yScope = Literal['focused', 'pid', 'all']

ComputerUseA11yNameMatch

ComputerUseA11yNameMatch = Literal['exact', 'substring', 'regex']

ComputerUseActivityStatus

ComputerUseActivityStatus = Literal['active', 'inactive', 'unknown']

ComputerUseDesktopState

ComputerUseDesktopState = Literal['not_started', 'starting', 'ready', 'failed', 'unknown']

ComputerUseDesktopFailureCode

ComputerUseDesktopFailureCode = Literal['desktop_exited', 'addon_crashed', 'start_failed', 'start_interrupted', 'session_ended', 'session_replaced', 'state_corrupt', 'state_persistence_failed', 'unknown']

ComputerUseStatusResponse

ComputerUseStatusResponse = Union[ComputerUseNotStartedStatus, ComputerUseStartingStatus, ComputerUseReadyStatus, ComputerUseFailedStatus, ComputerUseUnknownStatus]

ComputerUseLifecycleResponse

ComputerUseLifecycleResponse = ComputerUseLifecycleResult

ComputerUseProcessRestartResponse

ComputerUseProcessRestartResponse = ComputerUseProcessRestartResult

ComputerUseProcessLogsResponse

ComputerUseProcessLogsResponse = ComputerUseProcessLogs

ComputerUseProcessErrorsResponse

ComputerUseProcessErrorsResponse = ComputerUseProcessErrors

ComputerUseScreenshotResponse

ComputerUseScreenshotResponse = ComputerUseScreenshot

ComputerUseScrollResponse

ComputerUseScrollResponse = ComputerUseScrollResult

ComputerUseDisplayInfoResponse

ComputerUseDisplayInfoResponse = ComputerUseDisplayInfo

ComputerUseDisplayWindowsResponse

ComputerUseDisplayWindowsResponse = ComputerUseDisplayWindows

ComputerUseA11yTreeResponse

ComputerUseA11yTreeResponse = ComputerUseA11yTree

ComputerUseA11yFindResponse

ComputerUseA11yFindResponse = ComputerUseA11yFindResult

ComputerUseRecordingsResponse

ComputerUseRecordingsResponse = ComputerUseRecordingList

On this page

ComputerUseServiceComputerUseService.__init__ComputerUseService.serviceComputerUseService.mouseComputerUseService.keyboardComputerUseService.screenComputerUseService.displayComputerUseService.a11yComputerUseService.recordingComputerUseService.restartComputerUseService.startComputerUseService.statusComputerUseService.stopAsyncComputerUseServiceAsyncComputerUseService.__init__AsyncComputerUseService.statusAsyncComputerUseService.startAsyncComputerUseService.stopAsyncComputerUseService.restartA11yServiceA11yService.__init__A11yService.findA11yService.focusA11yService.invokeA11yService.set_valueA11yService.treeAsyncA11yServiceAsyncA11yService.__init__AsyncA11yService.treeAsyncA11yService.findAsyncA11yService.focusAsyncA11yService.invokeAsyncA11yService.set_valueAddonProcessesServiceAddonProcessesService.__init__AddonProcessesService.errorsAddonProcessesService.logsAddonProcessesService.restartAddonProcessesService.statusAddonProcessesService.statusAsyncAddonProcessesServiceAsyncAddonProcessesService.__init__AsyncAddonProcessesService.statusAsyncAddonProcessesService.statusAsyncAddonProcessesService.restartAsyncAddonProcessesService.logsAsyncAddonProcessesService.errorsDisplayServiceDisplayService.__init__DisplayService.infoDisplayService.windowsAsyncDisplayServiceAsyncDisplayService.__init__AsyncDisplayService.infoAsyncDisplayService.windowsKeyboardServiceKeyboardService.__init__KeyboardService.hotkeyKeyboardService.keyKeyboardService.typeAsyncKeyboardServiceAsyncKeyboardService.__init__AsyncKeyboardService.typeAsyncKeyboardService.keyAsyncKeyboardService.hotkeyMouseServiceMouseService.__init__MouseService.clickMouseService.dragMouseService.moveMouseService.positionMouseService.scrollAsyncMouseServiceAsyncMouseService.__init__AsyncMouseService.positionAsyncMouseService.moveAsyncMouseService.clickAsyncMouseService.dragAsyncMouseService.scrollRecordingServiceRecordingService.__init__RecordingService.deleteRecordingService.downloadRecordingService.getRecordingService.listRecordingService.startRecordingService.stopAsyncRecordingServiceAsyncRecordingService.__init__AsyncRecordingService.startAsyncRecordingService.stopAsyncRecordingService.listAsyncRecordingService.getAsyncRecordingService.downloadAsyncRecordingService.deleteScreenServiceScreenService.__init__ScreenService.captureScreenService.capture_compressedScreenService.regionScreenService.region_compressedAsyncScreenServiceAsyncScreenService.__init__AsyncScreenService.captureAsyncScreenService.regionAsyncScreenService.capture_compressedAsyncScreenService.region_compressedComputerUseDesktopFailureComputerUseNotStartedStatusComputerUseStartingStatusComputerUseReadyStatusComputerUseFailedStatusComputerUseUnknownStatusComputerUseRestartResponseComputerUseProcessStatusComputerUseProcessRunningStatusComputerUsePointComputerUseDisplayComputerUseWindowComputerUseAccessibilityBoundsComputerUseAccessibilityNodeComputerUseRecordingComputerUseMouseButtonComputerUseScrollDirectionComputerUseScreenshotFormatComputerUseKeyboardModifierComputerUseA11yScopeComputerUseA11yNameMatchComputerUseActivityStatusComputerUseDesktopStateComputerUseDesktopFailureCodeComputerUseStatusResponseComputerUseLifecycleResponseComputerUseProcessRestartResponseComputerUseProcessLogsResponseComputerUseProcessErrorsResponseComputerUseScreenshotResponseComputerUseScrollResponseComputerUseDisplayInfoResponseComputerUseDisplayWindowsResponseComputerUseA11yTreeResponseComputerUseA11yFindResponseComputerUseRecordingsResponse