sticklink 0.1.1__py3-none-any.whl

sticklink/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.1'

sticklink/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

sticklink/analysis.py

@@ -0,0 +1,152 @@
+"""check-log: judge whether a recorded session is good enough data."""
+from .sources.replay import read_log
+
+STICKS = ('roll', 'pitch', 'yaw', 'throttle')
+CHANNELS = STICKS + ('arm', 'crash')
+
+
+def percentile(sorted_values, q):
+    if not sorted_values:
+        return None
+    return sorted_values[min(len(sorted_values)-1, int(q*len(sorted_values)))]
+
+
+def gap_stats(gaps_ms):
+    gaps = sorted(gaps_ms)
+    return dict(median=percentile(gaps, .5), p95=percentile(gaps, .95),
+                p99=percentile(gaps, .99), max=gaps[-1] if gaps else None)
+
+
+def analyze(path):
+    n = dict(records=0, samples=0, events=0, telemetry=0, connections=0, disconnects=0)
+    first_mono = last_mono = None
+    last_tick = last_seq = last_sample_tick = last_sample_mono = None
+    missing = resets = 0
+    tick_gaps, host_gaps = [], []
+    ranges = {}
+    sensors = {}
+    sessions = set()
+    notes = []
+    out_ranges = {}
+    for item in read_log(path):
+        mono = item['received_monotonic_ns']
+        first_mono = mono if first_mono is None else first_mono
+        last_mono = mono
+        sessions.add(item.get('session'))
+        if 'connection' in item:
+            n['connections'] += 1
+            n['disconnects'] += not item['connection']['connected']
+            last_tick = last_seq = last_sample_tick = last_sample_mono = None
+            continue
+        rec = item['record']
+        n['records'] += 1
+        tick = rec['tick']
+        if last_tick is not None and tick < last_tick:
+            resets += 1
+            last_seq = last_sample_tick = None
+        last_tick = tick
+        if rec['type'] == 'H':
+            if last_seq is not None:
+                resets += 1
+            last_seq = last_sample_tick = None
+            continue
+        step = None if last_seq is None else (rec['seq']-last_seq) % 65536
+        if step is not None and step >= 32768:
+            resets += 1
+            last_sample_tick = None
+        elif step:
+            missing += step-1
+        last_seq = rec['seq']
+        if rec['type'] == 'S':
+            n['samples'] += 1
+            if last_sample_tick is not None:
+                tick_gaps.append((tick-last_sample_tick)*10)  # ticks are 10 ms
+                host_gaps.append((mono-last_sample_mono)/1e6)
+            last_sample_tick, last_sample_mono = tick, mono
+            for name, value in rec['channels'].items():
+                lo, hi = ranges.get(name, (value, value))
+                ranges[name] = (min(lo, value), max(hi, value))
+        elif rec['type'] == 'E':
+            n['events'] += 1
+        elif rec['type'] == 'G':
+            n['gps'] = n.get('gps', 0) + 1
+        elif rec['type'] == 'D':
+            notes.append(rec['message'])
+        elif rec['type'] == 'C':
+            n['outputs'] = n.get('outputs', 0) + 1
+            for k, value in enumerate(rec['outputs']):
+                ch = rec['first'] + k
+                lo, hi = out_ranges.get(ch, (value, value))
+                out_ranges[ch] = (min(lo, value), max(hi, value))
+        else:
+            n['telemetry'] += 1
+            s = sensors.setdefault(rec['sensor'], dict(count=0, current=0,
+                first=mono, last=mono, lo=rec['value'], hi=rec['value']))
+            s['count'] += 1
+            s['current'] += rec['current']
+            s['last'] = mono
+            s['lo'], s['hi'] = min(s['lo'], rec['value']), max(s['hi'], rec['value'])
+    duration = 0 if first_mono is None else (last_mono-first_mono)/1e9
+    for s in sensors.values():
+        span = (s['last']-s['first'])/1e9
+        s['rate_hz'] = (s['count']-1)/span if span > 0 else None
+    result = dict(path=str(path), duration_s=duration, counts=n,
+        sample_rate_hz=(n['samples']-1)/duration if duration > 0 and n['samples'] > 1 else None,
+        radio_gap_ms=gap_stats(tick_gaps), host_gap_ms=gap_stats(host_gaps),
+        missing_seq=missing, resets=resets, sessions=len(sessions - {None}),
+        stick_range={k: ranges[k] for k in CHANNELS if k in ranges}, telemetry=sensors, radio_notes=notes, output_ranges=out_ranges)
+    result['warnings'] = warnings(result)
+    return result
+
+
+def warnings(r):
+    out = []
+    if r['counts']['samples'] < 2:
+        return ['no control samples recorded']
+    if r['sample_rate_hz'] is not None and r['sample_rate_hz'] < 15:  # None: too short (or too coarse a clock) to tell
+        out.append(f"average sample rate {r['sample_rate_hz']:.1f} Hz is low (EdgeTX runs the script every 50 ms, so about 20 Hz is normal)")
+    if r['radio_gap_ms']['p95'] and r['radio_gap_ms']['p95'] > 100:
+        out.append(f"95th percentile gap {r['radio_gap_ms']['p95']} ms: stalls in the Lua script")
+    if r['missing_seq']:
+        out.append(f"{r['missing_seq']} records missing (sequence gaps): serial data lost")
+    if r['resets']:
+        out.append(f"{r['resets']} radio session resets")
+    if not r['telemetry']:
+        out.append('no telemetry records: check sensor names in DDSTK.lua')
+    for name, (lo, hi) in r['stick_range'].items():
+        if lo == hi and name in STICKS:  # switches may legitimately stay put
+            out.append(f'{name} never changed ({lo}): wrong source or stick not moved')
+    return out
+
+
+def format_report(r):
+    def ms(v):
+        return '—' if v is None else f'{v:.1f} ms'
+    c = r['counts']
+    lines = [f"Log: {r['path']}",
+        f"Duration: {r['duration_s']:.1f} s   sessions: {r['sessions']}   "
+        f"resets: {r['resets']}   disconnects: {c['disconnects']}",
+        f"Records: {c['records']} (control {c['samples']}, events {c['events']}, "
+        f"telemetry {c['telemetry']})   missing seq: {r['missing_seq']}"]
+    if r['sample_rate_hz']:
+        lines.append(f"Control rate: {r['sample_rate_hz']:.1f} Hz")
+    for label, key in (('Radio-clock gaps', 'radio_gap_ms'), ('Host-clock gaps ', 'host_gap_ms')):
+        g = r[key]
+        lines.append(f"{label}: median {ms(g['median'])}, p95 {ms(g['p95'])}, "
+                     f"p99 {ms(g['p99'])}, max {ms(g['max'])}")
+    if c.get('gps'):
+        lines.append(f"GPS records: {c['gps']}")
+    lines.append('Channel ranges: ' + (', '.join(
+        f'{k} {lo}..{hi}' for k, (lo, hi) in r['stick_range'].items()) or '—'))
+    for name, s in sorted(r['telemetry'].items()):
+        rate = '—' if s['rate_hz'] is None else f"{s['rate_hz']:.1f} Hz"
+        lines.append(f"Telemetry {name}: {s['count']} records, {rate}, "
+                     f"range {s['lo']:g}..{s['hi']:g}, current {s['current']}/{s['count']}")
+    moved = {ch: rg for ch, rg in sorted(r['output_ranges'].items()) if rg[0] != rg[1]}
+    if r['output_ranges']:
+        lines.append('Output channels that moved: ' + (', '.join(f'CH{ch} {lo}..{hi}' for ch, (lo, hi) in moved.items()) or 'none'))
+    for note in r['radio_notes']:
+        lines.append(f'Radio note: {note}')
+    lines.append('')
+    lines += [f'WARNING: {w}' for w in r['warnings']] or ['OK: no problems found']
+    return '\n'.join(lines)

sticklink/api.py

@@ -0,0 +1,284 @@
+"""REST API handlers (see openapi.py for the contract; /docs for Swagger UI)."""
+import json
+import re
+import time
+
+from aiohttp import web
+
+from . import __version__
+from .analysis import analyze
+from .fxconfig import STYLE_INFO, validate
+from .openapi import build
+from .obs import ObsError
+from .recorder import RecorderError
+from .scenes import validate_modes, validate_obs
+
+SENSOR = re.compile(r'[A-Za-z0-9_%-]{1,24}')
+LOCAL_HOSTS = {'localhost', '127.0.0.1', '[::1]'}
+STATUS_FOR = dict(already_recording=409, not_recording=409, recording_active=409, invalid_label=400,
+                  invalid_name=400, not_found=404)
+
+
+def error(status, code, message):
+    return web.json_response(dict(error=dict(code=code, message=message)), status=status)
+
+
+@web.middleware
+async def guard(request, handler):
+    """Reject foreign Host headers (DNS rebinding) and give API errors a JSON body."""
+    host = request.host.rsplit(':', 1)[0] if not request.host.endswith(']') else request.host
+    if host not in LOCAL_HOSTS:
+        return error(403, 'forbidden_host', 'this server only answers to localhost')
+    try:
+        return await handler(request)
+    except web.HTTPException as exc:
+        if request.path.startswith('/api/') and not exc.empty_body:
+            reason = exc.reason.lower().replace(' ', '_')
+            return error(exc.status, reason, exc.text if exc.text and exc.text != f'{exc.status}: {exc.reason}' else exc.reason)
+        raise
+
+
+async def json_body(request, allow_empty=False):
+    # Always demand the JSON content type, even for an empty body: a cross-site HTML form cannot send it without a
+    # CORS pre-flight that this server never answers, so a web page you visit cannot trigger POST actions.
+    if request.content_type != 'application/json':
+        raise web.HTTPUnsupportedMediaType(text='send Content-Type: application/json')
+    if allow_empty and not request.can_read_body:
+        return {}
+    try:
+        data = await request.json()
+    except ValueError:
+        raise web.HTTPBadRequest(text='body is not valid JSON')
+    if not isinstance(data, dict):
+        raise web.HTTPBadRequest(text='body must be a JSON object')
+    return data
+
+
+def register(app, server):
+    pipe, fx, rec = server.pipeline, server.fx_config, server.recorder
+    started = time.monotonic()
+    snap = pipe.snapshot
+    ok = web.json_response
+
+    async def status(request):
+        s = snap()
+        st = pipe.state
+        return ok(dict(version=__version__, uptime_s=round(time.monotonic()-started, 1), source=server.source.label,
+                       radio=dict(status=s['status'], connected=st.connected, session=s['session'], age_ms=s['age_ms'],
+                                  error=s['error'], input=s['source'], notes=s['notes']),
+                       diagnostics=s['diagnostics'], websocket_clients=len(server.clients), recording=rec.status()))
+
+    async def state(request):
+        return ok(snap())
+
+    async def controls(request):
+        s = snap()
+        return ok({k: s[k] for k in ('status', 'source', 'controls', 'raw', 'commands', 'age_ms', 'tick', 'seq')})
+
+    async def telemetry(request):
+        return ok(dict(sensors=snap()['telemetry']))
+
+    async def sensor(request):
+        name = request.match_info['sensor']
+        if not SENSOR.fullmatch(name):
+            return error(400, 'invalid_sensor', 'sensor names are 1-24 characters of A-Z a-z 0-9 _ % -')
+        item = snap()['telemetry'].get(name)
+        if item is None:
+            return error(404, 'not_found', f'no sensor named {name}')
+        return ok(dict(name=name, **item))
+
+    async def gps(request):
+        return ok(snap()['gps'])
+
+    def track_body():
+        st = pipe.state
+        return dict(home=None if st.home is None else dict(lat=st.home[0], lon=st.home[1]),
+                    points=[[round(a, 6), round(b, 6)] for a, b in st.track])
+
+    async def gps_track(request):
+        return ok(track_body())
+
+    async def gps_track_clear(request):
+        pipe.state.reset_gps()
+        return ok(track_body())
+
+    # ------------------------------------------------------------ OBS scenes
+    obs, engine, scene_store = server.obs, server.scenes, server.scene_store
+
+    async def obs_status(request):
+        return ok(obs.snapshot())
+
+    async def obs_connection(request):
+        data = await json_body(request)
+        try:
+            settings = scene_store.save_obs(data)
+        except ValueError as exc:
+            return error(400, 'invalid_obs_settings', str(exc))
+        obs.configure(settings)
+        return ok(obs.snapshot())
+
+    async def obs_scene(request):
+        data = await json_body(request)
+        scene = data.get('scene')
+        if not isinstance(scene, str) or not scene or set(data) != {'scene'}:
+            return error(400, 'invalid_scene', 'send {"scene": "<name>"}')
+        try:
+            await obs.set_scene(scene)
+        except ObsError as exc:
+            if obs.status != 'connected':
+                return error(409, 'obs_not_connected', str(exc))
+            return error(400, 'scene_not_found' if exc.code == 600 else 'obs_error', str(exc))
+        return ok(dict(scene=scene))
+
+    async def modes(request):
+        return ok(engine.config)
+
+    async def modes_put(request):
+        data = await json_body(request)
+        try:
+            cfg = scene_store.save_modes(validate_modes(data))
+        except ValueError as exc:
+            return error(400, 'invalid_scene_modes', str(exc))
+        engine.configure(cfg)
+        return ok(cfg)
+
+    async def modes_state(request):
+        return ok(dict(engine.status(), obs=obs.status))
+
+    async def modes_apply(request):
+        await json_body(request, allow_empty=True)
+        if engine.blocked == 'obs_not_connected' or obs.status != 'connected':
+            return error(409, 'obs_not_connected', 'OBS is not connected')
+        try:
+            scene = engine.apply_now()
+        except ValueError as exc:
+            return error(409, 'nothing_to_apply', str(exc))
+        return ok(dict(scene=scene))
+
+    async def channels(request):
+        return ok(dict(channels=snap()['channels']))
+
+    async def channel(request):
+        try:
+            n = int(request.match_info['n'])
+        except ValueError:
+            n = 0
+        if not 1 <= n <= 16:
+            return error(400, 'invalid_channel', 'channel must be a number from 1 to 16')
+        values = snap()['channels']
+        return ok(dict(channel=n, value=None if values is None else values[n-1]))
+
+    async def styles(request):
+        return ok([dict(id=i, name=n, blurb=b) for i, n, b in STYLE_INFO])
+
+    async def settings(request):
+        return ok(fx.merged())
+
+    def settings_write(action):
+        async def handler(request):
+            data = await json_body(request)
+            try:
+                action(data)
+            except ValueError as exc:
+                return error(400, 'invalid_settings', str(exc))
+            return ok(fx.merged())
+        return handler
+
+    async def settings_reset(request):
+        fx.reset()
+        return ok(fx.merged())
+
+    async def mapping(request):
+        return ok(fx.merged()['mapping'])
+
+    async def mapping_put(request):
+        data = await json_body(request)
+        try:
+            fx.replace_mapping(data)
+        except ValueError as exc:
+            return error(400, 'invalid_mapping', str(exc))
+        return ok(fx.merged()['mapping'])
+
+    def recorder_call(fn, status_ok=200):
+        async def handler(request):
+            try:
+                return await fn(request, status_ok)
+            except RecorderError as exc:
+                return error(STATUS_FOR.get(exc.code, 400), exc.code, exc.message)
+        return handler
+
+    async def recording(request, _):
+        return ok(rec.status())
+
+    async def recording_start(request, code):
+        body = await json_body(request, allow_empty=True)
+        unknown = set(body) - {'label'}
+        if unknown:
+            raise RecorderError('invalid_label', 'unknown field: ' + ', '.join(sorted(unknown)))
+        label = body.get('label')
+        if label is not None and not isinstance(label, str):
+            raise RecorderError('invalid_label', 'label must be a string')
+        return ok(rec.start(label), status=code)
+
+    async def recording_stop(request, _):
+        return ok(rec.stop())
+
+    async def recordings(request, _):
+        return ok(rec.list())
+
+    async def recording_file(request, _):
+        path = rec.path_for(request.match_info['name'])
+        return web.FileResponse(path, headers={'Content-Type': 'application/x-ndjson',
+                                               'Content-Disposition': f'attachment; filename="{path.name}"'})
+
+    async def recording_delete(request, _):
+        rec.delete(request.match_info['name'])
+        return web.Response(status=204)
+
+    async def recording_report(request, _):
+        report = analyze(rec.path_for(request.match_info['name']))
+        return web.Response(text=json.dumps(report, allow_nan=False), content_type='application/json')
+
+    spec_json = json.dumps(build())
+
+    async def openapi(request):
+        return web.Response(text=spec_json, content_type='application/json')
+
+    v1 = '/api/v1'
+    routes = [
+        ('GET', '/status', status), ('GET', '/state', state), ('GET', '/controls', controls),
+        ('GET', '/telemetry', telemetry), ('GET', '/telemetry/{sensor}', sensor),
+        ('GET', '/gps', gps), ('GET', '/gps/track', gps_track), ('DELETE', '/gps/track', gps_track_clear),
+        ('GET', '/obs', obs_status), ('PATCH', '/obs/connection', obs_connection), ('POST', '/obs/scene', obs_scene),
+        ('GET', '/scene-modes', modes), ('PUT', '/scene-modes', modes_put), ('GET', '/scene-modes/state', modes_state),
+        ('POST', '/scene-modes/apply', modes_apply),
+        ('GET', '/channels', channels), ('GET', '/channels/{n}', channel), ('GET', '/styles', styles),
+        ('GET', '/settings', settings),
+        ('PUT', '/settings', settings_write(fx.replace)), ('PATCH', '/settings', settings_write(fx.save)),
+        ('DELETE', '/settings', settings_reset),
+        ('GET', '/settings/mapping', mapping), ('PUT', '/settings/mapping', mapping_put),
+        ('GET', '/recording', recorder_call(recording)), ('POST', '/recording', recorder_call(recording_start, 201)),
+        ('DELETE', '/recording', recorder_call(recording_stop)),
+        ('GET', '/recordings', recorder_call(recordings)),
+        ('GET', '/recordings/{name}', recorder_call(recording_file)),
+        ('DELETE', '/recordings/{name}', recorder_call(recording_delete)),
+        ('GET', '/recordings/{name}/report', recorder_call(recording_report)),
+        ('GET', '/openapi.json', openapi),
+    ]
+    for method, path, handler in routes:
+        app.router.add_route(method, v1 + path, handler)
+
+    # Legacy aliases used by the bundled pages.
+    async def legacy_get(request):
+        return ok(fx.load(), headers={'Cache-Control': 'no-store'})
+
+    async def legacy_post(request):
+        data = await json_body(request)
+        try:
+            return ok(fx.save(data))
+        except ValueError as exc:
+            return error(400, 'invalid_settings', str(exc))
+
+    app.router.add_get('/api/state', state)
+    app.router.add_get('/api/fx-config', legacy_get)
+    app.router.add_post('/api/fx-config', legacy_post)

sticklink/cli.py

@@ -0,0 +1,115 @@
+import argparse
+from pathlib import Path
+import math
+import shutil
+import sys
+
+from aiohttp import web
+
+from .analysis import analyze, format_report
+from .config import Config
+from .fxconfig import FxConfigStore
+from .pipeline import Pipeline
+from .server import OverlayServer
+from .recorder import Recorder
+from .scenes import SceneStore
+from .sources.demo import DemoSource
+from .sources.replay import ReplaySource
+from .sources.serial_port import SerialSource
+
+
+def parser():
+    p = argparse.ArgumentParser(prog='sticklink', description='Live stick and telemetry overlays for OBS, from an EdgeTX radio.')
+    sub = p.add_subparsers(dest='command', required=True)
+
+    def serving(sp):
+        sp.add_argument('--http-port', type=int, default=8765)
+        sp.add_argument('--stale-ms', type=int, default=500)
+        sp.add_argument('--scale', type=float, default=1024)
+        sp.add_argument('--arm-threshold', type=int, default=0)
+        sp.add_argument('--crash-threshold', type=int, default=0)
+        sp.add_argument('--input-label', choices=['sticks', 'outputs', 'unknown'],
+                        default='unknown')
+        sp.add_argument('--log', help='start recording a JSONL session log to this file right away')
+        sp.add_argument('--recordings-dir', help='folder for recordings made through the API (default ~/.local/share/sticklink/recordings)')
+        sp.add_argument('--fx-config', help='overlay settings file (default ~/.config/sticklink/fx.json)')
+        sp.add_argument('--scenes-config', help='OBS connection and scene-mode settings, incl. the OBS password (default ~/.config/sticklink/scenes.json)')
+
+    run = sub.add_parser('run', help='serve the overlay from a radio or the demo')
+    run.add_argument('--port', help='COM5, /dev/ttyACM0, /dev/cu.usbmodem…')
+    run.add_argument('--demo', action='store_true', help='synthetic data; no radio')
+    run.add_argument('--baud', type=int, default=115200)
+    serving(run)
+
+    replay = sub.add_parser('replay', help='serve a recorded log as if it were live')
+    replay.add_argument('file')
+    replay.add_argument('--speed', type=float, default=1.0)
+    replay.add_argument('--loop', action='store_true')
+    serving(replay)
+
+    check = sub.add_parser('check-log', help='report on the quality of a recorded log')
+    check.add_argument('file')
+
+    script = sub.add_parser('radio-script', help='copy the EdgeTX Lua script (DDSTK.lua) to a folder, e.g. the radio SD card')
+    script.add_argument('dest', nargs='?', default='.',
+                        help='folder to copy into (default: here). Use <SD card>/SCRIPTS/FUNCTIONS for the radio')
+
+    sub.add_parser('list-ports', help='list serial ports')
+    sub.add_parser('gui', help='a small window with Start / Stop, status and links (also what you get with no command)')
+    return p
+
+
+def main(argv=None):
+    p = parser()
+    argv = sys.argv[1:] if argv is None else argv
+    if not argv:
+        argv = ['gui']  # double-clicked program: open the window
+    args = p.parse_args(argv)
+    if args.command == 'gui':
+        try:
+            from . import gui
+        except ImportError:  # Python without tkinter (some Linux distributions package it separately)
+            p.error('the window needs tkinter (Linux: install python3-tk). The other commands work without it.')
+        return gui.main()
+    if args.command == 'list-ports':
+        from serial.tools.list_ports import comports
+        for port in comports():
+            print(f'{port.device}\t{port.description}')
+        return
+    if args.command == 'radio-script':
+        source = Path(__file__).resolve().parent/'radio'/'DDSTK.lua'
+        dest = Path(args.dest)
+        if not dest.is_dir():
+            p.error(f'{dest} is not a folder')
+        shutil.copyfile(source, dest/'DDSTK.lua')
+        print(f'Copied DDSTK.lua to {dest/"DDSTK.lua"}')
+        print('On the radio it belongs in /SCRIPTS/FUNCTIONS/ (see docs/radio-setup.md).')
+        return
+    if args.command == 'check-log':
+        print(format_report(analyze(args.file)))
+        return
+    if not math.isfinite(args.scale) or args.scale <= 0 or args.stale_ms <= 0:
+        p.error('scale and stale-ms must be positive finite values')
+    if not 1 <= args.http_port <= 65535:
+        p.error('invalid http port')
+    if args.command == 'run':
+        if bool(args.port) == args.demo:
+            p.error('choose exactly one of --port COM5 or --demo')
+        if args.baud <= 0:
+            p.error('invalid baud rate')
+        source = DemoSource() if args.demo else SerialSource(args.port, args.baud)
+    else:
+        if args.speed <= 0:
+            p.error('speed must be positive')
+        source = ReplaySource(args.file, args.speed, args.loop)
+    config = Config(scale=args.scale, stale_ms=args.stale_ms,
+        arm_threshold=args.arm_threshold, crash_threshold=args.crash_threshold,
+        input_label=args.input_label, demo=args.command == 'run' and args.demo)
+    pipeline = Pipeline(config)
+    recorder = Recorder(pipeline, args.recordings_dir, source=source.label)
+    if args.log:
+        recorder.start_path(args.log)
+    print(f'OBS browser source: http://127.0.0.1:{args.http_port}/overlay   API docs: http://127.0.0.1:{args.http_port}/docs', flush=True)
+    web.run_app(OverlayServer(pipeline, source, fx_config=FxConfigStore(args.fx_config), recorder=recorder,
+                              scene_store=SceneStore(args.scenes_config)).app(),
+                host='127.0.0.1', port=args.http_port)

sticklink/config.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    scale: float = 1024          # channel value that maps to +/-1.0
+    stale_ms: int = 500          # no control sample for this long = paused
+    arm_threshold: int = 0
+    crash_threshold: int = 0
+    input_label: str = 'unknown'  # sticks | outputs | unknown (when hello doesn't say)
+    demo: bool = False           # marks snapshots as synthetic ('demo' status)