| """Robo page + unchanged TYGER Conversation and EARS, sharing the Playground TTS.""" |
| import asyncio |
| import json |
| import logging |
| import os |
| from pathlib import Path |
| import time |
| import numpy as np |
|
|
| from aiohttp import web, WSMsgType |
| import httpx |
|
|
| import paths |
| from app.ears.conversation import Conversation |
| from app.plugins.base import PluginContext |
| from app.plugins.ears.tyger.plugin import Tyger |
| from tts_bridge import MouthBridge |
| from app.ears.playback import mic_block |
| from audio_sync import estimate_echo_delay |
| from feature_tap import attach_feature_tap,local_only,extract,extract_context,extract_layers,transcribe_check |
| from identity import IdentityManager |
| from speaker_teacher import preserve_encoder_precision |
|
|
| preserve_encoder_precision() |
|
|
| ROOT=paths.ROOT |
| log=logging.getLogger('robo') |
| STATE={'ready':False,'error':None,'phase':'Starting Nemotron / TYGER','ears':None} |
|
|
|
|
| class RoboConversation(Conversation): |
| async def _on_text(self,payload): |
| data=json.loads(payload) |
| if data.get('status_only'): |
| await self.ws.send_json({'type':'service_status','text':str(data.get('text',''))[:300],'stage':data.get('stage')}) |
| return |
| if self.speaker_ext is not None:await self.speaker_ext.metadata(data) |
| await self.ws.send_json({'type':'backchannel' if data.get('bc') else 'reply','text':data['text'], |
| 'reply_id':self.playback.rid,'performance':data.get('performance'), |
| 'speaker_id':(data.get('speaker') or {}).get('speaker_id'),'speaker_name':(data.get('speaker') or {}).get('display_name'), |
| 'speaker_update':data.get('speaker_update')}) |
|
|
| def __init__(self,*args,**kwargs): |
| super().__init__(*args,**kwargs) |
| self.identity_enabled=False;self.predictor=None;self.last_identity_notice=0 |
| self.identity_mode='ecapa';self.teacher=None;self.teacher_stream=None |
| self.identity_audio=np.zeros(0,np.float32) |
| selection={};robo=None |
| ref=ROOT/'speaker_v2/artifacts/robo_reference.npz' |
| if ref.exists(): |
| try:robo=np.load(ref)['embedding'] |
| except Exception:pass |
| checkpoint=ROOT/'speaker_v2/artifacts/best.pt' |
| if checkpoint.exists(): |
| try: |
| from speaker_v2.inference import Predictor |
| self.predictor=Predictor(checkpoint) |
| path=ROOT/'speaker_v2/artifacts/selection.json' |
| if path.exists():selection=json.loads(path.read_text()) |
| except Exception as exc:log.warning('Speaker pilot unavailable: %s',type(exc).__name__) |
| self.student_threshold=float(selection.get('verification_threshold',.65)) |
| self.teacher_threshold=.58 |
| self.identity=IdentityManager(threshold=self.teacher_threshold,robo=robo) |
| self.speaker_ext=None;self.current_speaker=None |
| self.input_samples=0;self.input_blocks=0;self.last_input_notice=0. |
| self.pending_barge_proposal=None |
| self.native_barge_settings=(self.session.barge_thr,self.session.barge_deb) |
| try: |
| from speaker_session import SpeakerSession |
| self.speaker_ext=SpeakerSession(self,long_context='long') |
| self.identity_mode='v4-long';self.identity_enabled=True |
| self._speaker_barge_sensitivity(True) |
| except Exception as exc:log.warning('Completed speaker student unavailable: %s',type(exc).__name__) |
|
|
| def _speaker_barge_sensitivity(self,enabled): |
| |
| |
| |
| threshold,debounce=(.20,1) if enabled else self.native_barge_settings |
| self.ears.set_threshold(self.session,'barge_thr',threshold) |
| self.ears.set_threshold(self.session,'barge_deb',debounce) |
|
|
| def _ready_message(self): |
| return {**super()._ready_message(),'identity_enabled':self.identity_enabled,'identity_mode':self.identity_mode, |
| 'speaker_instruction':'Say: Hey Robbie, I am Christoph. Only enrolled voices keep their turn open.'} |
|
|
| async def _send_turn(self,transcript): |
| self._start_speaking() |
| await self.to_mouth(b'T',{'transcript':transcript,'speaker':self.current_speaker}) |
|
|
| def _start_speaking(self): |
| |
| |
| self.speaker_reply_start_s=self.hop_pos/self.ears.sr |
| super()._start_speaking() |
|
|
| async def run(self): |
| if self.speaker_ext is not None:self.speaker_ext.start() |
| try:await super().run() |
| finally: |
| if self.speaker_ext is not None:await self.speaker_ext.close() |
| task=getattr(self,'calibration_task',None) |
| if task is not None:task.cancel() |
| self.identity.clear();self._reset_identity_context() |
| self.cal_mic=[];self.cal_ref=[] |
|
|
| async def _teacher(self): |
| if self.teacher is None: |
| from speaker_teacher import get_cached_teacher,StreamingTeacher |
| self.teacher=await asyncio.to_thread(get_cached_teacher) |
| self.teacher_stream=StreamingTeacher(self.teacher) |
| return self.teacher |
|
|
| def _reset_identity_context(self): |
| self.identity.reset_utterance();self.identity_audio=np.zeros(0,np.float32) |
| if self.predictor is not None:self.predictor.reset() |
| if self.teacher_stream is not None:self.teacher_stream.reset() |
|
|
| async def _on_events(self,events,hop_end): |
| if self.identity_enabled and self.speaker_ext is not None and self.identity_mode.startswith('v4'): |
| proposals=[e for e in events if e['kind']=='BARGE'] |
| if proposals and self.speaking:self.pending_barge_proposal=(max(proposals,key=lambda e:e.get('yield_prob',0)),hop_end) |
| if proposals and getattr(self,'synthetic_diagnostics',False): |
| await self.ws.send_json({'type':'synthetic_barge_proposal','audio_s':hop_end/self.ears.sr, |
| 'proposals':proposals,'speaker_cue':self.speaker_ext.last_activity}) |
| |
| |
| if not self.speaking: |
| for event in events: |
| if event['kind']=='PARTIAL': |
| self.speaker_ext.note_asr(event['text'],hop_end/self.ears.sr) |
| await self.ws.send_json({'type':'asr_preview','text':event['text'], |
| 'status':'not_submitted','source':'native_asr'}) |
| for event in events: |
| if event['kind']=='SPEAKER_FEATURES':await self.speaker_ext.observe(event,hop_end) |
| |
| |
| |
| filtered=[e for e in events if e['kind']=='FRAME'] |
| pending=self.pending_barge_proposal |
| if pending and self.speaking and 0<=hop_end-pending[1]<=1.28*self.ears.sr: |
| confirmed=await self.speaker_ext.confirm_interrupt(pending[0],hop_end) |
| if confirmed:filtered.append(pending[0]);self.pending_barge_proposal=None |
| elif pending and (not self.speaking or hop_end-pending[1]>1.28*self.ears.sr):self.pending_barge_proposal=None |
| if getattr(self,'calibrating',False):filtered=[e for e in filtered if e['kind']=='FRAME'] |
| await super()._on_events(filtered,hop_end);return |
| for event in events: |
| if event['kind']=='SPEAKER_FEATURES': |
| energy=float(np.sqrt(np.mean(10**(np.asarray(event['energy_db'])/10)))) |
| prediction=self.predictor.update(event['features'],energy=energy) if self.predictor is not None else {'kind':'warming'} |
| audio=event['audio16'] |
| if self.identity_enabled or self.identity_mode=='student': |
| self.identity_audio=np.r_[self.identity_audio,audio][-(32000 if self.speaking else 320000):] |
| identity=None |
| if self.identity_mode=='student':identity=self.identity.observe(prediction) |
| elif self.identity_enabled: |
| try: |
| await self._teacher() |
| cue=await asyncio.to_thread(self.teacher_stream.update,audio,speech=bool(self.session.in_turn and not self.speaking)) |
| identity=self.identity.observe(cue) |
| except Exception as exc: |
| self.identity_enabled=False |
| await self.ws.send_json({'type':'identity','enabled':False,'mode':self.identity_mode,**self.identity.status()}) |
| await self.ws.send_json({'type':'warning','text':'ECAPA unavailable; speaker filter disabled ('+type(exc).__name__+').'}) |
| if identity is None:continue |
| if time.monotonic()-self.last_identity_notice>.8: |
| self.last_identity_notice=time.monotonic() |
| await self.ws.send_json({'type':'identity','prediction':identity,'enabled':self.identity_enabled,**self.identity.status()}) |
| filtered=[e for e in events if e['kind']!='SPEAKER_FEATURES'] |
| if getattr(self,'calibrating',False):filtered=[e for e in filtered if e['kind']=='FRAME'] |
| await super()._on_events(filtered,hop_end) |
|
|
| async def _on_endpoint(self,event): |
| if self.identity_enabled or self.identity_mode=='student': |
| if self.identity_mode=='ecapa' and self.identity_enabled: |
| try: |
| teacher=await self._teacher() |
| audio=self.identity_audio |
| |
| active=np.flatnonzero(np.abs(audio)>.003) |
| if len(active):audio=audio[max(0,active[0]-320):min(len(audio),active[-1]+321)] |
| embedding=await asyncio.to_thread(teacher.embed,audio) |
| self.identity.reset_utterance() |
| |
| self.identity.observe({'embedding':embedding,'kind':'speech','confidence':.8}) |
| self.identity.voiced_ms=round(len(audio)/16) |
| except Exception: |
| self.identity.reset_utterance() |
| decision=self.identity.finish(event.get('transcript') or '',enabled=self.identity_enabled) |
| if self.predictor is not None:self.predictor.reset() |
| if self.teacher_stream is not None:self.teacher_stream.reset() |
| self.identity_audio=np.zeros(0,np.float32) |
| await self.ws.send_json({'type':'identity','decision':decision,'enabled':self.identity_enabled,**self.identity.status()}) |
| if not decision['accepted']: |
| await self.ws.send_json({'type':'ignored','reason':decision.get('reason','Unenrolled or uncertain speaker')}) |
| return |
| await super()._on_endpoint(event) |
|
|
| async def _on_barge(self,event,hop_end): |
| self.pending_barge_proposal=None |
| generated=self.mouth_done |
| if generated and self.have_mouth:await self.to_mouth(b'H',{'interrupted':True}) |
| if getattr(self,'calibrating',False): |
| self.calibrating=False;self.cal_mic=[];self.cal_ref=[] |
| if getattr(self,'calibration_task',None) is not None:self.calibration_task.cancel() |
| await super()._on_barge(event,hop_end) |
| onset=max(0.,min(2.,float(event.get('onset_s') or 0.))) |
| samples=int(onset*16000) |
| self.identity_audio=self.identity_audio[-samples:] if samples else np.zeros(0,np.float32) |
| self.identity.reset_utterance() |
| if self.teacher_stream is not None:self.teacher_stream.reset() |
|
|
| async def _on_browser(self,msg): |
| if msg.type==WSMsgType.BINARY: |
| block=mic_block(msg.data) |
| if block is not None: |
| pcm=block[2];self.input_samples+=len(pcm);self.input_blocks+=1 |
| now=time.monotonic() |
| if now-self.last_input_notice>.5: |
| self.last_input_notice=now |
| await self.ws.send_json({'type':'input_status','blocks':self.input_blocks, |
| 'seconds':round(self.input_samples/16000,2), |
| 'rms_dbfs':round(20*np.log10(max(1e-7,float(np.sqrt(np.mean(pcm**2))))),1)}) |
| if getattr(self,'calibrating',False) and msg.type==WSMsgType.BINARY: |
| block=mic_block(msg.data) |
| if block is not None: |
| rid,at24,pcm=block;ref=np.zeros(len(pcm),np.float32) |
| if rid==self.playback.rid and at24>=0: |
| at=round(at24*16000/24000);length=max(0,min(len(pcm),self.playback.n16-at)) |
| ref[:length]=self.playback.audio[at:at+length] |
| self.cal_mic.append(pcm);self.cal_ref.append(ref) |
| await super()._on_browser(msg) |
|
|
| async def _on_command(self,data): |
| if data.startswith('identity:'): |
| command=data.split(':',1)[1] |
| if command.startswith('mode:v4'): |
| mode=command.split(':',1)[1] |
| if mode not in ('v4','v4-long','v4-long3'):return |
| from speaker_runtime import available |
| if mode=='v4-long3' and 'long3' not in available(): |
| await self.ws.send_json({'type':'warning','text':'The 3.04-s optimized study has not finished; no winner is claimed yet.'});return |
| if self.speaker_ext is not None:await self.speaker_ext.close() |
| from speaker_session import SpeakerSession |
| self.current_speaker=None;self.speaker_ext=SpeakerSession(self,None if mode=='v4' else 'long3' if mode=='v4-long3' else 'long',use_diarization=mode!='v4') |
| self.speaker_ext.start();self.identity_mode=mode;self.identity_enabled=True |
| self._speaker_barge_sensitivity(True) |
| await self.speaker_ext.notice();return |
| if self.speaker_ext is not None and self.identity_mode.startswith('v4'): |
| if command in ('on','off'): |
| self.identity_enabled=command=='on';await self.speaker_ext.clear();self.current_speaker=None |
| self._speaker_barge_sensitivity(self.identity_enabled) |
| self.session.reset();await self.speaker_ext.notice();return |
| if command=='clear': |
| await self.speaker_ext.clear();self.current_speaker=None;await self.speaker_ext.notice();return |
| if command.startswith('timeout:'): |
| try: |
| value=float(command.split(':',1)[1]) |
| if np.isfinite(value) and 0<=value<=3600:self.speaker_ext.memory.timeout_s=value |
| except ValueError:pass |
| await self.speaker_ext.notice();return |
| if command.startswith('threshold:'): |
| try: |
| value=float(command.split(':',1)[1]) |
| if np.isfinite(value) and .1<=value<=.95:self.speaker_ext.memory.threshold=value |
| except ValueError:pass |
| await self.speaker_ext.notice();return |
| if command.startswith('utterance_threshold:'): |
| try: |
| value=float(command.split(':',1)[1]) |
| if np.isfinite(value) and .3<=value<=.9:self.speaker_ext.utterance_threshold=value |
| except ValueError:pass |
| await self.speaker_ext.notice();return |
| if command.startswith('mode:') and command.split(':')[1] in ('ecapa','student'): |
| if self.speaker_ext is not None:await self.speaker_ext.close();self.speaker_ext=None |
| self._speaker_barge_sensitivity(False) |
| self.current_speaker=None |
| if data.startswith('identity:'): |
| command=data.split(':',1)[1] |
| if command=='on': |
| self._reset_identity_context() |
| if self.identity_mode=='ecapa': |
| try:await self._teacher();self.identity_enabled=True |
| except Exception as exc:await self.ws.send_json({'type':'warning','text':'ECAPA local weights unavailable; filter remains off ('+type(exc).__name__+').'}) |
| else:await self.ws.send_json({'type':'warning','text':'The TYGER V2 pilot failed held-out reliability checks. Diagnostic cues only; use ECAPA to try enrollment.'}) |
| elif command=='off':self.identity_enabled=False;self._reset_identity_context() |
| elif command=='clear': |
| self.identity.clear();self.identity_audio=np.zeros(0,np.float32) |
| if self.teacher_stream is not None:self.teacher_stream.reset() |
| if self.predictor is not None:self.predictor.reset() |
| elif command.startswith('mode:') and command.split(':')[1] in ('ecapa','student'): |
| self.identity_mode=command.split(':')[1];self.identity_enabled=False;self.identity.clear() |
| self._reset_identity_context() |
| self.identity.threshold=self.teacher_threshold if self.identity_mode=='ecapa' else self.student_threshold |
| elif command.startswith('timeout:'): |
| try: |
| timeout=float(command.split(':')[1]) |
| if np.isfinite(timeout) and 0<=timeout<=3600:self.identity.timeout_s=timeout |
| except ValueError:pass |
| await self.ws.send_json({'type':'identity','enabled':self.identity_enabled,'mode':self.identity_mode,**self.identity.status()}) |
| elif data=='calibrate' and not self.speaking: |
| self.calibrating=True;self.cal_mic=[];self.cal_ref=[];self._start_speaking() |
| calibration_rid=self.playback.rid |
| t=np.arange(24000*.45)/24000 |
| probe=(.025*np.sin(2*np.pi*(250*t+1600*t*t))*np.sin(np.pi*t/.45)**2).astype(np.float32) |
| await self._on_reply_audio(probe.tobytes()) |
| async def finish_calibration(): |
| await asyncio.sleep(2.5) |
| if not self.calibrating or self.playback.rid!=calibration_rid:return |
| self.calibrating=False |
| report=estimate_echo_delay(np.concatenate(self.cal_mic) if self.cal_mic else [],np.concatenate(self.cal_ref) if self.cal_ref else []) |
| self.cal_mic=[];self.cal_ref=[] |
| if not self.ws.closed: |
| await self.ws.send_json({'type':'calibration',**report}) |
| await self._on_done(b'{}') |
| self.calibration_task=asyncio.create_task(finish_calibration()) |
| elif data=='interrupt' and self.speaking: |
| await self._on_barge({'onset_s':0.,'yield_prob':1.},self.hop_pos) |
| elif data.startswith('text:') and not self.speaking and not self.halting: |
| text=data[5:].strip()[:2000] |
| if text:self.current_speaker=None;await self._send_turn(text) |
| elif data.startswith('text:'):await self.ws.send_json({'type':'busy','text':'Please stop or finish this reply before sending another typed turn.'}) |
| else:await super()._on_command(data) |
|
|
| async def _finish_turn(self,barged): |
| offset=self.playback.offset_ms() |
| await super()._finish_turn(barged) |
| if not barged: |
| self.identity_audio=np.zeros(0,np.float32);self.identity.reset_utterance() |
| if self.predictor is not None:self.predictor.reset() |
| if self.teacher_stream is not None:self.teacher_stream.reset() |
| await self.ws.send_json({'type':'sync','arrival_order_error_ms':offset, |
| 'method':'capture timestamps + actual scheduled PCM sample positions', |
| 'hardware_accuracy':'not independently measured; inspect device latency availability'}) |
|
|
|
|
| async def startup(app): |
| import torch |
| torch.set_num_threads(4) |
| bridge=MouthBridge();app['bridge']=bridge;app['tasks']=[] |
| app['mouth_server']=await asyncio.start_server(bridge.accept,'127.0.0.1',8795) |
| cfg={'server':{'max_sessions':1,'max_session_s':int(os.environ.get('ROBO_MAX_SESSION_S','1800')),'mouth_host':'127.0.0.1','mouth_port':8795},'mouth':{}} |
| app['cfg']=cfg |
| async def load(): |
| try: |
| block={'plugin':'tyger','model':str(paths.BUNDLE),'ep_thr':.915,'ep_deb':2, |
| 'barge_thr':.5,'barge_deb':2,'bc_thr':.4,'bc_deb':2,'cpu_threads':4} |
| STATE['ears']=await asyncio.to_thread(Tyger,block,PluginContext(None,cfg,'robo-ears')) |
| attach_feature_tap(STATE['ears']) |
| STATE.update(ready=True,phase='Ready: Small RL + Nemotron 3.5 + TYGER') |
| app['tasks'].append(asyncio.create_task(bridge.prepare_ack())) |
| except Exception as exc: |
| log.exception('EARS startup failed');STATE.update(error=type(exc).__name__+': '+str(exc),phase='EARS error') |
| app['load_task']=asyncio.create_task(load()) |
|
|
|
|
| async def cleanup(app): |
| for task in app['tasks']:task.cancel() |
| app['mouth_server'].close();await app['mouth_server'].wait_closed() |
|
|
|
|
| async def state(request): |
| import torch |
| trained=(ROOT/'speaker_v2/artifacts/best.pt').exists() |
| try: |
| from speaker_teacher import resolve_model_root |
| resolve_model_root();teacher=True |
| except Exception:teacher=False |
| from speaker_runtime import available |
| students=available() |
| return web.json_response({k:v for k,v in STATE.items() if k!='ears'}|{ |
| 'tts':'Humaneness Voice Small 1.1 Alpha RL r128 v1','tts_shared':True, |
| 'privacy':'Camera inference is local in your browser. Mic audio goes to this server; transcripts go to the configured Luna API. No mic recordings are saved by Robo.', |
| 'identity_model':'V4 layer-mix 320-ms + session enrollment; experimental, not authentication' if students else 'legacy ECAPA baseline', |
| 'identity_available':bool(students) or teacher,'identity_student_available':bool(students), |
| 'identity_models':students,'identity_quiet_seconds':1., |
| 'identity_teacher_available':teacher,'identity_default_enabled':bool(students), |
| 'tf32_matmul':bool(torch.backends.cuda.matmul.allow_tf32),'tf32_cudnn':bool(torch.backends.cudnn.allow_tf32)}) |
|
|
|
|
| async def socket(request): |
| synthetic_diagnostics=request.query.get('synthetic_diagnostics')=='1' |
| if synthetic_diagnostics:local_only(request) |
| if not STATE['ready']:raise web.HTTPServiceUnavailable(text=STATE['error'] or STATE['phase']) |
| ears=STATE['ears'];ears.browser_waiting=getattr(ears,'browser_waiting',0)+1;sess=None |
| try: |
| for _ in range(100): |
| sess=ears.open_session(ears.defaults) |
| if sess is not None:break |
| await asyncio.sleep(.02) |
| finally:ears.browser_waiting-=1 |
| if sess is None:raise web.HTTPTooManyRequests(text='One microphone session at a time on this pilot.') |
| ws=web.WebSocketResponse(max_msg_size=65536,heartbeat=30) |
| try: |
| await ws.prepare(request) |
| conv=RoboConversation(ws,ears,sess,request.app['cfg'],voices=['emolia_c1699'], |
| default_voice='emolia_c1699',labels={'emolia_c1699':'Mira · fixed reference'}) |
| conv.synthetic_diagnostics=synthetic_diagnostics |
| await conv.run() |
| finally:ears.close(sess) |
| return ws |
|
|
|
|
| async def index(request):return web.FileResponse(ROOT/'static/index.html') |
|
|
|
|
| async def desk_robot(request): |
| |
| html=(ROOT/'static/index.html').read_text() |
| html=html.replace('<body>','<body data-robot-view="desk3d">') |
| html=html.replace('<title>Robby · a little more human</title>','<title>Robby · 3D desk robot prototype</title>') |
| html=html.replace('href="/desk-robot/">3D desk robot ↗','href="/">Original avatar ↗') |
| html=html.replace('A FACE. A VOICE. A CONVERSATION.','TWO AXES. FORTY EXPRESSIONS. ONE LITTLE ROBOT.') |
| html=html.replace('<h1>A little company.<br><span>A little expression.</span></h1>', |
| '<h1>A little desk companion.<br><span>Made to turn towards you.</span></h1>') |
| html=html.replace('id="avatar" class="avatar"','id="avatar" class="avatar desk-avatar"') |
| html=html.replace('smoothly varying brows, eyelids, gaze, mouth, head and arms.', |
| 'smoothly varying brows, eyelids, gaze and mouth. This construction has pan and tilt only, no arms or roll axis.') |
| html=html.replace('Show the robot’s 101 animation anchors','Show display anchors and mechanical axes') |
| return web.Response(text=html,content_type='text/html',headers={'Cache-Control':'no-store'}) |
|
|
|
|
| async def validate(request): |
| local_only(request) |
| if not STATE['ready'] or STATE['ears'].active():raise web.HTTPConflict(text='EARS must be ready and idle') |
| from sync_validation import model_checks |
| return web.json_response(await model_checks(STATE['ears'])) |
|
|
|
|
| async def features(request):return await extract(request,STATE['ears']) |
|
|
|
|
| async def context_features(request):return await extract_context(request,STATE['ears']) |
|
|
|
|
| async def layer_features(request):return await extract_layers(request,STATE['ears']) |
|
|
|
|
| async def live_speaker_features(request): |
| from speaker_live.research import extract_predictions |
| return await extract_predictions(request,STATE['ears']) |
|
|
|
|
| async def asr_check(request):return await transcribe_check(request,STATE['ears']) |
|
|
|
|
| async def v4_status(request): |
| path=ROOT/'speaker_v4/progress.json' |
| return web.json_response(json.loads(path.read_text()) if path.exists() else {'phase':'Preparing'},headers={'Cache-Control':'no-store'}) |
|
|
|
|
| async def v4_report(request): |
| path=Path.home()/'.cache/robo-v4/report.html' |
| return web.FileResponse(path) if path.exists() else web.Response(text='Study preparing; please reload shortly.') |
|
|
|
|
| async def v5_status(request): |
| path=ROOT/'speaker_v5/progress.json' |
| return web.json_response(json.loads(path.read_text()) if path.exists() else {'phase':'Queued'},headers={'Cache-Control':'no-store'}) |
|
|
|
|
| async def v5_report(request): |
| path=Path.home()/'.cache/robo-v5/report.html' |
| return web.FileResponse(path) if path.exists() else web.Response(text='Context study preparing; please reload shortly.') |
|
|
|
|
| async def training_status(request): |
| path=ROOT/'speaker_v3/progress.json' |
| data=json.loads(path.read_text()) if path.exists() else {'phase':'Not started'} |
| data.pop('results_path',None) |
| return web.json_response(data,headers={'Cache-Control':'no-store'}) |
|
|
|
|
| async def training_page(request):return web.FileResponse(ROOT/'static/speaker-training.html') |
|
|
|
|
| async def large_training_report(request): |
| path=Path(os.environ.get('ROBO_V3_WORK',str(Path.home()/'.cache/robo-v3')))/'models/report.html' |
| if not path.exists():return web.HTTPFound('/speaker-training/') |
| return web.FileResponse(path) |
|
|
|
|
| async def expressions(request):return web.FileResponse(ROOT/'static/expressions.html') |
|
|
|
|
| async def speaker_report(request): |
| variant=request.match_info.get('variant') |
| path=ROOT/'speaker_v2'/variant/'report.html' if variant else ROOT/'speaker_v2/report.html' |
| if not path.exists():raise web.HTTPServiceUnavailable(text='Pilot report is still being generated') |
| return web.FileResponse(path) |
|
|
|
|
| async def release_download(request): |
| path=ROOT/'speaker_v2/release/tyger-v2-public-pilot.zip' |
| if not path.exists():raise web.HTTPNotFound() |
| return web.FileResponse(path,headers={'Content-Disposition':'attachment; filename="tyger-v2-public-pilot.zip"'}) |
|
|
|
|
| async def source_download(request): |
| path=ROOT/'releases/robby-source.zip' |
| if not path.exists():raise web.HTTPNotFound() |
| return web.FileResponse(path,headers={'Content-Disposition':'attachment; filename="robby-source.zip"'}) |
|
|
|
|
| def main(): |
| app=web.Application(client_max_size=2*1024*1024) |
| app.router.add_get('/',index);app.router.add_get('/robo/',index) |
| app.router.add_get('/desk-robot/',desk_robot) |
| app.router.add_get('/desk-robot',lambda request:web.HTTPFound('/desk-robot/')) |
| app.router.add_get('/api/state',state);app.router.add_get('/ws',socket) |
| app.router.add_post('/internal/sync-check',validate) |
| app.router.add_post('/internal/features',features) |
| app.router.add_post('/internal/context-features',context_features) |
| app.router.add_post('/internal/layer-features',layer_features) |
| app.router.add_post('/internal/speaker-predictions',live_speaker_features) |
| app.router.add_post('/internal/transcribe',asr_check) |
| app.router.add_get('/api/speaker-v4',v4_status) |
| app.router.add_get('/speaker-training/320ms-study/',v4_report) |
| app.router.add_get('/api/speaker-v5',v5_status) |
| app.router.add_get('/speaker-training/context-study/',v5_report) |
| app.router.add_get('/api/speaker-training',training_status) |
| app.router.add_get('/speaker-training/',training_page) |
| app.router.add_get('/speaker-training/report.html',large_training_report) |
| app.router.add_get('/expressions/',expressions) |
| app.router.add_get('/speaker-study/',speaker_report) |
| app.router.add_get('/speaker-study/{variant:results|results_centered|results_v2_raw|results_v2_centered|results_v2_gru}/report.html',speaker_report) |
| app.router.add_get('/downloads/tyger-v2-public-pilot.zip',release_download) |
| app.router.add_get('/downloads/robby-source.zip',source_download) |
| app.router.add_static('/static/',ROOT/'static') |
| app.on_startup.append(startup);app.on_cleanup.append(cleanup) |
| logging.basicConfig(level=logging.INFO,format='%(asctime)s %(name)s %(message)s') |
| logging.getLogger('httpx').setLevel(logging.WARNING) |
| web.run_app(app,host='127.0.0.1',port=8793,access_log=None) |
|
|
|
|
| if __name__=='__main__':main() |
|
|
