2026-01-24 16:17:47 +01:00
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
< meta name = "viewport" content = "width=device-width, initial-scale=1.0" >
< title > API Examples - DWN Documentation</ title >
< link rel = "stylesheet" href = "css/style.css" >
</ head >
< body >
< button class = "mobile-menu-btn" > Menu</ button >
< div class = "layout" >
< aside class = "sidebar" >
< div class = "sidebar-header" >
< h1 > DWN</ h1 >
2026-02-07 13:04:52 +01:00
< span class = "version" > v2.0.0</ span >
2026-01-24 16:17:47 +01:00
</ div >
< div class = "search-box" >
< input type = "text" class = "search-input" placeholder = "Search docs..." >
</ div >
< nav class = "sidebar-nav" >
< div class = "nav-section" >
< div class = "nav-section-title" > Getting Started</ div >
< a href = "index.html" class = "nav-link" > Introduction</ a >
< a href = "installation.html" class = "nav-link" > Installation</ a >
< a href = "quickstart.html" class = "nav-link" > Quick Start</ a >
</ div >
< div class = "nav-section" >
< div class = "nav-section-title" > User Guide</ div >
< a href = "features.html" class = "nav-link" > Features</ a >
< a href = "shortcuts.html" class = "nav-link" > Keyboard Shortcuts</ a >
< a href = "configuration.html" class = "nav-link" > Configuration</ a >
< a href = "layouts.html" class = "nav-link" > Layouts</ a >
< a href = "ai-features.html" class = "nav-link" > AI Integration</ a >
</ div >
< div class = "nav-section" >
< div class = "nav-section-title" > API Reference</ div >
< a href = "api-overview.html" class = "nav-link" > API Overview</ a >
< a href = "api-reference.html" class = "nav-link" > API Reference</ a >
< a href = "api-examples.html" class = "nav-link active" > API Examples</ a >
</ div >
< div class = "nav-section" >
< div class = "nav-section-title" > Advanced</ div >
< a href = "architecture.html" class = "nav-link" > Architecture</ a >
2026-02-07 13:04:52 +01:00
< a href = "abstraction-layer.html" class = "nav-link" > Abstraction Layer</ a >
< a href = "plugin-development.html" class = "nav-link" > Plugin Development</ a >
2026-01-24 16:17:47 +01:00
< a href = "building.html" class = "nav-link" > Building from Source</ a >
</ div >
</ nav >
</ aside >
< main class = "main-content" >
< div class = "content" >
< div class = "page-header" >
< h1 > API Examples</ h1 >
< p class = "lead" > Code examples for common automation tasks</ p >
</ div >
< div class = "toc" >
< div class = "toc-title" > On this page</ div >
< ul class = "toc-list" >
< li >< a href = "#python" > Python Examples</ a ></ li >
< li >< a href = "#javascript" > JavaScript Examples</ a ></ li >
< li >< a href = "#bash" > Bash Examples</ a ></ li >
2026-02-07 13:04:52 +01:00
< li >< a href = "#fade-control" > Fade Effect Control</ a ></ li >
2026-01-24 16:17:47 +01:00
< li >< a href = "#events" > Event Subscription</ a ></ li >
< li >< a href = "#automation" > Automation Recipes</ a ></ li >
< li >< a href = "#browser-ocr" > Browser Automation with OCR</ a ></ li >
</ ul >
</ div >
< h2 id = "python" > Python Examples</ h2 >
< h3 > Basic Connection</ h3 >
< div class = "code-block" >
< pre >< code > import json
import websocket
2026-02-07 13:04:52 +01:00
ws = websocket.create_connection("ws://localhost:8777/ws")
2026-01-24 16:17:47 +01:00
def send_command(command, **params):
request = {"command": command, **params}
ws.send(json.dumps(request))
return json.loads(ws.recv())
2026-02-07 13:04:52 +01:00
# List all clients
result = send_command("get_clients")
for client in result["clients"]:
print(f"{client['title']} ({client['class']})")
2026-01-24 16:17:47 +01:00
ws.close()</ code ></ pre >
</ div >
< h3 > Using the Client Library</ h3 >
< div class = "code-block" >
< pre >< code > from dwn_api_client import DWNClient
client = DWNClient()
client.connect()
2026-02-07 13:04:52 +01:00
# Get all clients
clients = client.get_clients()
print(f"Found {len(clients)} clients")
2026-01-24 16:17:47 +01:00
2026-02-07 13:04:52 +01:00
# Focus client by title
for c in clients:
if "Firefox" in c["title"]:
client.focus_client(c["window"])
2026-01-24 16:17:47 +01:00
break
# Switch to workspace 3
client.switch_workspace(2)
# Type some text
2026-02-07 13:04:52 +01:00
client.key_type("Hello from Python!")
2026-01-24 16:17:47 +01:00
client.disconnect()</ code ></ pre >
</ div >
< h3 > Screenshot and OCR</ h3 >
< div class = "code-block" >
< pre >< code > import base64
from dwn_api_client import DWNClient
client = DWNClient()
client.connect()
# Take fullscreen screenshot
result = client.screenshot("fullscreen")
# Save to file
png_data = base64.b64decode(result["data"])
with open("screenshot.png", "wb") as f:
f.write(png_data)
print(f"Saved {result['width']}x{result['height']} screenshot")
# Extract text with OCR
ocr_result = client.ocr(result["data"])
print(f"Extracted text (confidence: {ocr_result['confidence']:.0%}):")
print(ocr_result["text"])
client.disconnect()</ code ></ pre >
</ div >
2026-02-07 13:04:52 +01:00
< h3 > Client Arrangement Script</ h3 >
2026-01-24 16:17:47 +01:00
< div class = "code-block" >
< pre >< code > from dwn_api_client import DWNClient
def arrange_coding_setup(client):
2026-02-07 13:04:52 +01:00
"""Arrange clients for coding: editor left, terminal right"""
clients = client.get_clients()
2026-01-24 16:17:47 +01:00
# Find VS Code and terminal
vscode = None
terminal = None
2026-02-07 13:04:52 +01:00
for c in clients:
if "code" in c["class"].lower():
vscode = c
elif "terminal" in c["class"].lower():
terminal = c
2026-01-24 16:17:47 +01:00
if vscode:
2026-02-07 13:04:52 +01:00
client.move_client(vscode["window"], 0, 32)
client.resize_client(vscode["window"], 960, 1048)
2026-01-24 16:17:47 +01:00
if terminal:
2026-02-07 13:04:52 +01:00
client.move_client(terminal["window"], 960, 32)
client.resize_client(terminal["window"], 960, 1048)
2026-01-24 16:17:47 +01:00
client = DWNClient()
client.connect()
arrange_coding_setup(client)
client.disconnect()</ code ></ pre >
</ div >
< h3 > Async Client</ h3 >
< div class = "code-block" >
< pre >< code > import asyncio
import json
import websockets
async def main():
2026-02-07 13:04:52 +01:00
async with websockets.connect("ws://localhost:8777/ws") as ws:
2026-01-24 16:17:47 +01:00
# Send command
2026-02-07 13:04:52 +01:00
await ws.send(json.dumps({"command": "get_clients"}))
2026-01-24 16:17:47 +01:00
# Receive response
response = json.loads(await ws.recv())
2026-02-07 13:04:52 +01:00
for client in response["clients"]:
print(f"Client: {client['title']}")
2026-01-24 16:17:47 +01:00
asyncio.run(main())</ code ></ pre >
</ div >
< h2 id = "javascript" > JavaScript Examples</ h2 >
< h3 > Browser WebSocket</ h3 >
< div class = "code-block" >
< pre >< code > class DWNClient {
2026-02-07 13:04:52 +01:00
constructor(url = 'ws://localhost:8777/ws') {
2026-01-24 16:17:47 +01:00
this.url = url;
this.ws = null;
this.pending = new Map();
this.requestId = 0;
}
connect() {
return new Promise((resolve, reject) => {
this.ws = new WebSocket(this.url);
this.ws.onopen = () => resolve();
this.ws.onerror = (e) => reject(e);
this.ws.onmessage = (e) => this.handleMessage(e);
});
}
handleMessage(event) {
const response = JSON.parse(event.data);
// Handle response
console.log('Received:', response);
}
send(command, params = {}) {
const request = { command, ...params };
this.ws.send(JSON.stringify(request));
}
2026-02-07 13:04:52 +01:00
async getClients() {
this.send('get_clients');
2026-01-24 16:17:47 +01:00
}
2026-02-07 13:04:52 +01:00
async focusClient(windowId) {
this.send('focus_client', { window: windowId });
2026-01-24 16:17:47 +01:00
}
2026-02-07 13:04:52 +01:00
async keyType(text) {
this.send('key_type', { text });
2026-01-24 16:17:47 +01:00
}
async screenshot(mode = 'fullscreen') {
this.send('screenshot', { mode });
}
}
// Usage
const client = new DWNClient();
await client.connect();
2026-02-07 13:04:52 +01:00
await client.getClients();</ code ></ pre >
2026-01-24 16:17:47 +01:00
</ div >
< h3 > Node.js Client</ h3 >
< div class = "code-block" >
< pre >< code > const WebSocket = require('ws');
2026-02-07 13:04:52 +01:00
const ws = new WebSocket('ws://localhost:8777/ws');
2026-01-24 16:17:47 +01:00
ws.on('open', () => {
console.log('Connected to DWN');
2026-02-07 13:04:52 +01:00
// List clients
ws.send(JSON.stringify({ command: 'get_clients' }));
2026-01-24 16:17:47 +01:00
});
ws.on('message', (data) => {
const response = JSON.parse(data);
2026-02-07 13:04:52 +01:00
if (response.clients) {
response.clients.forEach(c => {
console.log(`${c.title} - ${c.class}`);
2026-01-24 16:17:47 +01:00
});
}
ws.close();
});
ws.on('error', (err) => {
console.error('Error:', err.message);
});</ code ></ pre >
</ div >
< h3 > Screenshot to Canvas</ h3 >
< div class = "code-block" >
< pre >< code > async function captureToCanvas(client, canvasId) {
return new Promise((resolve) => {
client.ws.onmessage = (event) => {
const response = JSON.parse(event.data);
if (response.data) {
const img = new Image();
img.onload = () => {
const canvas = document.getElementById(canvasId);
const ctx = canvas.getContext('2d');
canvas.width = response.width;
canvas.height = response.height;
ctx.drawImage(img, 0, 0);
resolve();
};
img.src = 'data:image/png;base64,' + response.data;
}
};
client.send('screenshot', { mode: 'fullscreen' });
});
}</ code ></ pre >
</ div >
< h2 id = "bash" > Bash Examples</ h2 >
< h3 > Using websocat</ h3 >
< div class = "code-block" >
< pre >< code > #!/bin/bash
2026-02-07 13:04:52 +01:00
# List clients
echo '{"command": "get_clients"}' | websocat ws://localhost:8777/ws
2026-01-24 16:17:47 +01:00
2026-02-07 13:04:52 +01:00
# Focus client by ID
echo '{"command": "focus_client", "window": 12345678}' | websocat ws://localhost:8777/ws
2026-01-24 16:17:47 +01:00
# Switch workspace
2026-02-07 13:04:52 +01:00
echo '{"command": "switch_workspace", "workspace": 2}' | websocat ws://localhost:8777/ws
2026-01-24 16:17:47 +01:00
# Take screenshot and save
echo '{"command": "screenshot", "mode": "fullscreen"}' | \
2026-02-07 13:04:52 +01:00
websocat ws://localhost:8777/ws | \
2026-01-24 16:17:47 +01:00
jq -r '.data' | \
base64 -d > screenshot.png</ code ></ pre >
</ div >
< h3 > Using wscat</ h3 >
< div class = "code-block" >
< pre >< code > #!/bin/bash
# One-liner command
2026-02-07 13:04:52 +01:00
echo '{"command": "get_clients"}' | wscat -c ws://localhost:8777/ws -w 1
2026-01-24 16:17:47 +01:00
# Interactive session
2026-02-07 13:04:52 +01:00
wscat -c ws://localhost:8777/ws
2026-01-24 16:17:47 +01:00
# Then type commands manually</ code ></ pre >
</ div >
< h3 > Using curl with websocat</ h3 >
< div class = "code-block" >
< pre >< code > #!/bin/bash
dwn_command() {
2026-02-07 13:04:52 +01:00
echo "$1" | websocat -n1 ws://localhost:8777/ws
2026-01-24 16:17:47 +01:00
}
2026-02-07 13:04:52 +01:00
# Get focused client
dwn_command '{"command": "get_focused_client"}' | jq '.client.title'
2026-01-24 16:17:47 +01:00
# Type text
2026-02-07 13:04:52 +01:00
dwn_command '{"command": "key_type", "text": "Hello!"}'
2026-01-24 16:17:47 +01:00
# Launch application
2026-02-07 13:04:52 +01:00
dwn_command '{"command": "run_command", "exec": "firefox"}'</ code ></ pre >
</ div >
< h3 > Fade Effect Control</ h3 >
< p > Control DWN's fade animation effects via API:</ p >
< div class = "code-block" >
< pre >< code > import json
import websocket
ws = websocket.create_connection("ws://localhost:8777/ws")
# Get current fade settings
ws.send(json.dumps({"command": "get_fade_settings"}))
response = json.loads(ws.recv())
print(f"Speed: {response['fade_speed']}, Intensity: {response['fade_intensity']}")
# Set fade animation speed (0.1 - 3.0)
ws.send(json.dumps({"command": "set_fade_speed", "speed": 1.5}))
# Set fade glow intensity (0.0 - 1.0)
ws.send(json.dumps({"command": "set_fade_intensity", "intensity": 0.8}))
# Subscribe to fade change events
ws.send(json.dumps({
"command": "subscribe",
"events": ["fade_speed_changed", "fade_intensity_changed"]
}))
# Listen for events
while True:
event = json.loads(ws.recv())
if event.get("type") == "event":
print(f"Event: {event['event']}")
print(f"Data: {event['data']}")</ code ></ pre >
</ div >
< p > Using the provided fade control demo script:</ p >
< div class = "code-block" >
< pre >< code > # Get current fade settings
python3 examples/fade_control_demo.py
# Set fade speed
python3 examples/fade_control_demo.py --speed 1.5
# Set fade intensity
python3 examples/fade_control_demo.py --intensity 0.8
# Listen for fade events
python3 examples/fade_control_demo.py --listen --duration 30</ code ></ pre >
2026-01-24 16:17:47 +01:00
</ div >
< h2 id = "events" > Event Subscription</ h2 >
< h3 > Using dwn_automation_demo.py</ h3 >
< p > The included automation demo script provides ready-to-use event monitoring:</ p >
< div class = "code-block" >
< pre >< code > # List available events
python3 examples/dwn_automation_demo.py events --list
# Monitor all events (Ctrl+C to stop)
python3 examples/dwn_automation_demo.py events --monitor
# Monitor specific events
python3 examples/dwn_automation_demo.py events -e window_focused -e workspace_switched
# Run event demo (10 seconds)
python3 examples/dwn_automation_demo.py demo events
# Full event stream demo with summary
python3 examples/dwn_automation_demo.py demo events-all</ code ></ pre >
</ div >
< h3 > Python Event Listener</ h3 >
< div class = "code-block" >
< pre >< code > from dwn_api_client import DWNClient
def on_event(event):
event_name = event.get("event", "unknown")
data = event.get("data", {})
if event_name == "window_focused":
print(f"Focus: {data.get('title')}")
elif event_name == "workspace_switched":
print(f"Workspace: {data.get('new_workspace') + 1}")
elif event_name == "shortcut_triggered":
print(f"Shortcut: {data.get('description')}")
return True # Continue listening
client = DWNClient()
client.connect()
# Subscribe and listen
client.listen_events(on_event, events=[
"window_focused",
"workspace_switched",
"shortcut_triggered"
])</ code ></ pre >
</ div >
< h3 > Window Activity Logger</ h3 >
< div class = "code-block" >
< pre >< code > import json
from datetime import datetime
from dwn_api_client import DWNClient
def activity_logger():
client = DWNClient()
client.connect()
client.subscribe(events=[
"window_focused",
"window_created",
"window_destroyed"
])
print("Logging window activity (Ctrl+C to stop)...")
try:
with open("activity.log", "a") as f:
while True:
event = client.receive_event(timeout=1.0)
if event and event.get("type") == "event":
timestamp = datetime.now().isoformat()
ev_name = event.get("event")
data = event.get("data", {})
log_entry = {
"time": timestamp,
"event": ev_name,
"data": data
}
f.write(json.dumps(log_entry) + "\\n")
f.flush()
print(f"[{timestamp}] {ev_name}")
except KeyboardInterrupt:
print("\\nStopped logging")
finally:
client.disconnect()
activity_logger()</ code ></ pre >
</ div >
< h3 > JavaScript Event Listener</ h3 >
< div class = "code-block" >
2026-02-07 13:04:52 +01:00
< pre >< code > const ws = new WebSocket('ws://localhost:8777/ws');
2026-01-24 16:17:47 +01:00
ws.onopen = () => {
console.log('Connected to DWN');
// Subscribe to events
ws.send(JSON.stringify({
command: 'subscribe',
events: ['window_focused', 'workspace_switched']
}));
};
ws.onmessage = (event) => {
const msg = JSON.parse(event.data);
if (msg.type === 'event') {
console.log(`Event: ${msg.event}`, msg.data);
// Handle specific events
switch (msg.event) {
case 'window_focused':
document.title = msg.data.title || 'DWN';
break;
case 'workspace_switched':
updateWorkspaceIndicator(msg.data.new_workspace);
break;
}
}
};
ws.onerror = (err) => {
console.error('WebSocket error:', err);
};
ws.onclose = () => {
console.log('Disconnected from DWN');
};</ code ></ pre >
</ div >
2026-02-07 13:04:52 +01:00
< h3 > Reactive Client Arrangement</ h3 >
2026-01-24 16:17:47 +01:00
< div class = "code-block" >
< pre >< code > from dwn_api_client import DWNClient
RULES = {
"code": {"floating": False, "workspace": 0},
"firefox": {"floating": False, "workspace": 1},
"slack": {"floating": True, "workspace": 2},
"telegram": {"floating": True, "workspace": 2},
}
def auto_arrange():
client = DWNClient()
client.connect()
client.subscribe(events=["window_created"])
2026-02-07 13:04:52 +01:00
print("Auto-arranging clients...")
2026-01-24 16:17:47 +01:00
try:
while True:
event = client.receive_event(timeout=1.0)
if event and event.get("event") == "window_created":
data = event.get("data", {})
window_id = data.get("window")
wm_class = data.get("class", "").lower()
for pattern, rules in RULES.items():
if pattern in wm_class:
print(f"Applying rules to {wm_class}")
if "workspace" in rules:
client.move_client_to_workspace(
window_id, rules["workspace"]
)
if "floating" in rules:
client.float_client(
window_id, rules["floating"]
)
break
except KeyboardInterrupt:
pass
finally:
client.disconnect()
auto_arrange()</ code ></ pre >
</ div >
< h2 id = "automation" > Automation Recipes</ h2 >
2026-02-07 13:04:52 +01:00
< h3 > Auto-Arrange Clients by Class</ h3 >
2026-01-24 16:17:47 +01:00
< div class = "code-block" >
< pre >< code > from dwn_api_client import DWNClient
LAYOUT_RULES = {
"code": {"workspace": 0, "floating": False},
"firefox": {"workspace": 1, "floating": False},
"telegram": {"workspace": 2, "floating": True},
"slack": {"workspace": 2, "floating": True},
}
def auto_arrange():
client = DWNClient()
client.connect()
2026-02-07 13:04:52 +01:00
clients = client.get_clients()
for c in clients:
wm_class = c["class"].lower()
2026-01-24 16:17:47 +01:00
for pattern, rules in LAYOUT_RULES.items():
2026-02-07 13:04:52 +01:00
if pattern in wm_class:
if c["workspace"] != rules["workspace"]:
client.move_client_to_workspace(
c["window"], rules["workspace"]
2026-01-24 16:17:47 +01:00
)
2026-02-07 13:04:52 +01:00
if c["floating"] != rules["floating"]:
client.float_client(c["window"], rules["floating"])
2026-01-24 16:17:47 +01:00
break
client.disconnect()
auto_arrange()</ code ></ pre >
</ div >
< h3 > Screenshot Monitor</ h3 >
< div class = "code-block" >
< pre >< code > import time
import base64
from datetime import datetime
from dwn_api_client import DWNClient
def screenshot_monitor(interval=60, output_dir="screenshots"):
"""Take periodic screenshots"""
import os
os.makedirs(output_dir, exist_ok=True)
client = DWNClient()
client.connect()
try:
while True:
result = client.screenshot("fullscreen")
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"{output_dir}/screen_{timestamp}.png"
with open(filename, "wb") as f:
f.write(base64.b64decode(result["data"]))
print(f"Saved: {filename}")
time.sleep(interval)
except KeyboardInterrupt:
print("Stopped")
finally:
client.disconnect()
screenshot_monitor(interval=300) # Every 5 minutes</ code ></ pre >
</ div >
2026-02-07 13:04:52 +01:00
< h3 > Client Focus Logger</ h3 >
2026-01-24 16:17:47 +01:00
< div class = "code-block" >
< pre >< code > import time
from datetime import datetime
from dwn_api_client import DWNClient
def focus_logger(log_file="focus_log.txt"):
2026-02-07 13:04:52 +01:00
"""Log client focus changes"""
2026-01-24 16:17:47 +01:00
client = DWNClient()
client.connect()
last_focused = None
try:
with open(log_file, "a") as f:
while True:
2026-02-07 13:04:52 +01:00
clients = client.get_clients()
focused = next((c for c in clients if c["focused"]), None)
2026-01-24 16:17:47 +01:00
2026-02-07 13:04:52 +01:00
if focused and focused["window"] != last_focused:
2026-01-24 16:17:47 +01:00
timestamp = datetime.now().isoformat()
entry = f"{timestamp} | {focused['title']} ({focused['class']})\n"
f.write(entry)
f.flush()
print(entry.strip())
2026-02-07 13:04:52 +01:00
last_focused = focused["window"]
2026-01-24 16:17:47 +01:00
time.sleep(1)
except KeyboardInterrupt:
print("Stopped")
finally:
client.disconnect()
focus_logger()</ code ></ pre >
</ div >
< h3 > Keyboard Macro</ h3 >
< div class = "code-block" >
< pre >< code > from dwn_api_client import DWNClient
import time
def run_macro(client, actions, delay=0.1):
"""Execute a sequence of actions"""
for action in actions:
if action["type"] == "key":
client.key_press(action["key"], action.get("modifiers", []))
elif action["type"] == "type":
client.type_text(action["text"])
elif action["type"] == "click":
client.mouse_click(action.get("button", 1),
action.get("x"), action.get("y"))
elif action["type"] == "wait":
time.sleep(action["seconds"])
time.sleep(delay)
# Example: Open terminal and run command
macro = [
{"type": "key", "key": "t", "modifiers": ["ctrl", "alt"]},
{"type": "wait", "seconds": 1},
{"type": "type", "text": "ls -la"},
{"type": "key", "key": "Return"},
]
client = DWNClient()
client.connect()
run_macro(client, macro)
client.disconnect()</ code ></ pre >
</ div >
< h3 > OCR Screen Reader</ h3 >
< div class = "code-block" >
< pre >< code > from dwn_api_client import DWNClient
2026-02-07 13:04:52 +01:00
def read_active_client():
"""Extract and print text from active client"""
2026-01-24 16:17:47 +01:00
client = DWNClient()
client.connect()
2026-02-07 13:04:52 +01:00
# Capture active client
2026-01-24 16:17:47 +01:00
screenshot = client.screenshot("active")
# Extract text
ocr_result = client.ocr(screenshot["data"])
2026-02-07 13:04:52 +01:00
print(f"Text from active client (confidence: {ocr_result['confidence']:.0%}):")
2026-01-24 16:17:47 +01:00
print("-" * 40)
print(ocr_result["text"])
client.disconnect()
2026-02-07 13:04:52 +01:00
read_active_client()</ code ></ pre >
2026-01-24 16:17:47 +01:00
</ div >
< h3 id = "browser-ocr" > Browser Automation with OCR</ h3 >
< p > Complete example that opens a browser, performs a Google search, scrolls through results, and extracts text using OCR. See < code > examples/browser_ocr_demo.py</ code > for the full script.</ p >
< div class = "code-block" >
< pre >< code > #!/usr/bin/env python3
import asyncio
import json
import sys
import base64
from typing import List
class DWNAutomation:
def __init__(self, host: str = "localhost", port: int = 8777):
self.uri = f"ws://{host}:{port}/ws"
self.ws = None
async def connect(self):
import websockets
self.ws = await websockets.connect(self.uri)
async def disconnect(self):
if self.ws:
await self.ws.close()
async def send_command(self, command: dict) -> dict:
await self.ws.send(json.dumps(command))
return json.loads(await self.ws.recv())
async def run_command(self, exec_cmd: str) -> dict:
return await self.send_command({"command": "run_command", "exec": exec_cmd})
async def get_focused_client(self) -> dict:
return await self.send_command({"command": "get_focused_client"})
async def focus_client(self, window_id: int) -> dict:
return await self.send_command({"command": "focus_client", "window": window_id})
async def key_tap(self, keysym: str, modifiers: List[str] = None) -> dict:
cmd = {"command": "key_tap", "keysym": keysym}
if modifiers:
cmd["modifiers"] = modifiers
return await self.send_command(cmd)
async def key_type(self, text: str) -> dict:
return await self.send_command({"command": "key_type", "text": text})
async def mouse_scroll(self, direction: str, amount: int = 1) -> dict:
return await self.send_command({
"command": "mouse_scroll", "direction": direction, "amount": amount
})
async def screenshot(self, mode: str = "active") -> dict:
return await self.send_command({"command": "screenshot", "mode": mode})
async def ocr(self, image_base64: str) -> dict:
return await self.send_command({"command": "ocr", "image": image_base64})
async def main():
automation = DWNAutomation()
await automation.connect()
# Open default browser with Google
await automation.run_command("xdg-open https://www.google.nl")
await asyncio.sleep(5.0)
# Get focused browser window
result = await automation.get_focused_client()
window_id = int(result.get("client", {}).get("window", 0))
# Search for something
await automation.key_type("ponies")
await automation.key_tap("Return")
await asyncio.sleep(4.0)
# Scroll and collect OCR text from multiple pages
all_text = []
for i in range(4):
# Take screenshot and run OCR
screenshot = await automation.screenshot("active")
image_data = screenshot.get("data", "")
# Save screenshot
with open(f"screenshot_{i+1}.png", "wb") as f:
f.write(base64.b64decode(image_data))
# Extract text
ocr_result = await automation.ocr(image_data)
text = ocr_result.get("text", "").strip()
if text:
all_text.append(f"--- Page {i+1} ---\n{text}")
# Scroll down for next page
if i < 3:
await automation . mouse_scroll (" down ", 5 )
await asyncio . sleep ( 1 . 5 )
# Print combined results
print (" EXTRACTED TEXT: ")
print ("\ n \ n ". join ( all_text ))
await automation . disconnect ()
asyncio . run ( main ())</ code ></ pre >
</ div >
< p > Run the included demo script:</ p >
< div class = "code-block" >
< pre >< code > # Install dependency
pip install websockets
# Run the demo
python3 examples/browser_ocr_demo.py</ code ></ pre >
</ div >
< footer >
< p > DWN Window Manager - retoor < retoor@molodetz.nl> </ p >
</ footer >
</ div >
</ main >
</ div >
< script src = "js/main.js" ></ script >
</ body >
</ html >
