gjxUddlmZddlZddlZddlmZddlmZmZm Z m Z ddl m Z ddl Z ddlmZddlmZmZmZmZmZmZd d lmZmZmZmZd d lmZmZmZm Z m!Z!d d l"m#Z#d d l$m%Z%d dl&m'Z'm(Z(d dl)m*Z*d dl+m,Z,d dl-m.Z.m/Z/d dl0m1Z1d dl2m3Z3d dl4m5Z5d dl6m7Z7d dl8m9Z9erddl:m;Z<ddl=m;Z>d dl?m@Z@mAZAddgZBejeDZEdeFd<Gdde'ZGGdde(ZHGdd ZIGd!d"ZJGd#d$ZKGd%d&ZLGd'd(ZMGd)d*ZNGd+d,ZOGd-d.ZPGd/d0ZQGd1d2eQZRGd3d4eQZSGd5d6eQZTGd7d8eQZUGd9d:eQZVGd;d<ZWGd=d>eWZXGd?d@eWZYGdAdBeWZZGdCdDeWZ[GdEdFeWZ\y)G) annotationsN) TracebackType) TYPE_CHECKINGAnyIteratorcast) AsyncIterator) BaseModel)Sessions AsyncSessionsSessionsWithRawResponseAsyncSessionsWithRawResponseSessionsWithStreamingResponse"AsyncSessionsWithStreamingResponse) NOT_GIVENQueryHeadersNotGiven)is_azure_clientmaybe_transformstrip_not_givenasync_maybe_transformis_async_azure_client)cached_property)construct_type_unchecked)SyncAPIResourceAsyncAPIResource) OpenAIError)_merge_mappings)session_update_event_paramresponse_create_event_param)WebsocketConnectionOptions)RealtimeClientEvent)RealtimeServerEvent)ConversationItemParam)RealtimeClientEventParam)ClientConnection)OpenAI AsyncOpenAIRealtime AsyncRealtimezlogging.LoggerlogcfeZdZeddZeddZed dZiiid d dZy) r,c,t|jSN)r _clientselfs \/var/www/openai/venv/lib/python3.12/site-packages/openai/resources/beta/realtime/realtime.pysessionszRealtime.sessions6s %%ct|Sa This property can be used as a prefix for any HTTP method call to return the the raw response object instead of the parsed content. For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers )RealtimeWithRawResponser3s r5with_raw_responsezRealtime.with_raw_response:s't,,r7ct|Sz An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/openai/openai-python#with_streaming_response )RealtimeWithStreamingResponser3s r5with_streaming_responsez Realtime.with_streaming_responseDs-T22r7 extra_query extra_headerswebsocket_connection_optionsc6t|j||||Sa The Realtime API enables you to build low-latency, multi-modal conversational experiences. It currently supports text and audio as both input and output, as well as function calling. Some notable benefits of the API include: - Native speech-to-speech: Skipping an intermediate text format means low latency and nuanced output. - Natural, steerable voices: The models have natural inflection and can laugh, whisper, and adhere to tone direction. - Simultaneous multimodal output: Text is useful for moderation; faster-than-realtime audio ensures stable playback. The Realtime API is a stateful, event-based API that communicates over a WebSocket. )clientrArBrCmodel)RealtimeConnectionManagerr2r4rGrArBrCs r5connectzRealtime.connectMs$&)<<#')E   r7N)returnr )rKr:)rKr>) rGstrrArrBrrCr$rKrH__name__ __module__ __qualname__rr6r;r?rJr7r5r,r,5s&&--33 !#CE       'A   # r7cfeZdZeddZeddZed dZiiid d dZy) r-c,t|jSr1)r r2r3s r5r6zAsyncRealtime.sessionsjsT\\**r7ct|Sr9)AsyncRealtimeWithRawResponser3s r5r;zAsyncRealtime.with_raw_responsens,D11r7ct|Sr=)"AsyncRealtimeWithStreamingResponser3s r5r?z%AsyncRealtime.with_streaming_responsexs2$77r7r@c6t|j||||SrE)AsyncRealtimeConnectionManagerr2rIs r5rJzAsyncRealtime.connects$&.<<#')E   r7N)rKr )rKrU)rKrW) rGrLrArrBrrCr$rKrYrMrQr7r5r-r-is++2288 !#CE       'A   ( r7c&eZdZddZeddZy)r:c||_yr1 _realtimer4realtimes r5__init__z RealtimeWithRawResponse.__init__ !r7c@t|jjSr1)rr]r6r3s r5r6z RealtimeWithRawResponse.sessionss&t~~'>'>??r7Nr_r,rKNone)rKrrNrOrPr`rr6rQr7r5r:r:s"@@r7r:c&eZdZddZeddZy)rUc||_yr1r\r^s r5r`z%AsyncRealtimeWithRawResponse.__init__rar7c@t|jjSr1)rr]r6r3s r5r6z%AsyncRealtimeWithRawResponse.sessionss+DNN,C,CDDr7Nr_r-rKrd)rKrrerQr7r5rUrUs"EEr7rUc&eZdZddZeddZy)r>c||_yr1r\r^s r5r`z&RealtimeWithStreamingResponse.__init__rar7c@t|jjSr1)rr]r6r3s r5r6z&RealtimeWithStreamingResponse.sessionss,T^^-D-DEEr7Nrc)rKrrerQr7r5r>r>s"FFr7r>c&eZdZddZeddZy)rWc||_yr1r\r^s r5r`z+AsyncRealtimeWithStreamingResponse.__init__rar7c@t|jjSr1)rr]r6r3s r5r6z+AsyncRealtimeWithStreamingResponse.sessionss1$..2I2IJJr7Nri)rKrrerQr7r5rWrWs"KKr7rWceZdZUdZded<ded<ded<ded <d ed <dd Zdd ZddZddZddZ dddddZ ddZ y)AsyncRealtimeConnection:Represents a live websocket connection to the Realtime APIAsyncRealtimeSessionResourcesessionAsyncRealtimeResponseResourceresponse!AsyncRealtimeConversationResource conversation%AsyncRealtimeInputAudioBufferResourceinput_audio_bufferAsyncWebsocketConnection _connectionc||_t||_t||_t ||_t||_yr1) r|rsrtrurvrwrxryrzr4 connections r5r`z AsyncRealtimeConnection.__init__s<%3D9 5d; =dC"G"Mr7clKddlm} |jd{7#|$rYywxYwwzq An infinite-iterator that will continue to yield events until the connection is closed. r)ConnectionClosedOKNwebsockets.exceptionsrrecvr4rs r5 __aiter__z!AsyncRealtimeConnection.__aiter__s; =  IIK'''!   s 4)' )1414c\K|j|jd{S7w) Receive the next message from the connection and parses it into a `RealtimeServerEvent` object. Canceling this method is safe. There's no risk of losing data. N parse_event recv_bytesr3s r5rzAsyncRealtimeConnection.recvs& doo&7 788 7s ,* ,cK|jjdd{}tjd|t |t st dt||S7Cw)Receive the next message from the connection as raw bytes. Canceling this method is safe. There's no risk of losing data. If you want to parse the message into a `RealtimeServerEvent` object like `.recv()` does, then you can call `.parse_event(data)`. FdecodeNReceived websocket message: %s9Expected `.recv(decode=False)` to return `bytes` but got r|rr.debug isinstancebytes TypeErrortyper4messages r5rz"AsyncRealtimeConnection.recv_bytessb((--U-;; 2W='5)WX\]dXeWfgh h >>s !+)+c ttttj|tt tSz Converts a raw `str` or `bytes` message into a `RealtimeServerEvent` object. This is helpful if you're using `.recv_bytes()`. )valuetype_rr&rrloadsrr4rs r5rz#AsyncRealtimeConnection.parse_event1  !9 4@PX\]`buXv!w  r7N)rr{rKrd)rKz"AsyncIterator[RealtimeServerEvent]rKr&rKrrz.RealtimeClientEvent | RealtimeClientEventParamrKrdrintrrLrKrdrz str | bytesrKr&) rNrOrP__doc____annotations__r`rrrrrrrQr7r5rqrqsND ))++33==))N 9 **.R? r7rqc\eZdZdZ ddZddZeZd dZ d dZy) rYa3 Context manager over a `AsyncRealtimeConnection` that is returned by `beta.realtime.connect()` This context manager ensures that the connection will be closed when it exits. --- Note that if your application doesn't work well with the context manager approach then you can call the `.enter()` method directly to initiate a connection. **Warning**: You must remember to close the connection with `.close()`. ```py connection = await client.beta.realtime.connect(...).enter() # ... await connection.close() ``` cX||_||_d|_||_||_||_yr1)'_AsyncRealtimeConnectionManager__client&_AsyncRealtimeConnectionManager__model+_AsyncRealtimeConnectionManager__connection,_AsyncRealtimeConnectionManager__extra_query._AsyncRealtimeConnectionManager__extra_headers=_AsyncRealtimeConnectionManager__websocket_connection_optionsr4rFrGrArBrCs r5r`z'AsyncRealtimeConnectionManager.__init__"s2  <@(,.J+r7c .K ddlm}|j}|j j }t|j r1|j j|j|d{\}}|jji|j jjd|ji|}tjd||j r tjd|j t#|t%|f|j j&t)i|d d i|j*d |j d{|_|j,S#t$r}td|d}~wwxYw7&79w) u 👋 If your application doesn't work well with the context manager approach then you can call this method directly to initiate a connection. **Warning**: You must remember to close the connection with `.close()`. ```py connection = await client.beta.realtime.connect(...).enter() # ... await connection.close() ``` rrJ9You need to install `openai[realtime]` to use this methodNrGparamsConnecting to %sConnection options: %s OpenAI-Beta realtime=v1user_agent_headeradditional_headers)websockets.asyncio.clientrJ ImportErrorr rr auth_headersr_configure_realtimer _prepare_url copy_withbase_urlrr.rrrqrL user_agentr!rrr4rJexcrArurls r5 __aenter__z)AsyncRealtimeConnectionManager.__aenter__2s d 9(( }}11  /.2mm.O.OPTP\P\^i.j(j %K!++--((//,  $c*  . . II.0S0S T3C "&--":":#2&%}(( $ 55       E dYZ`c c d )k sGFE3A F*F+C.FFF3 F < FF  FFc.|jj*tj|jj}n&|jjj d}|j jddz}|j |SNwss)scheme/s /realtime)raw_path)rwebsocket_base_urlhttpxURL _base_urlrrrstripr4rmerge_raw_paths r5rz+AsyncRealtimeConnectionManager._prepare_urlgv == + + 7yy!A!ABH}}..888FH!**11$7,F!!>!::r7cnK|j#|jjd{yy7wr1)rrr4exc_typerexc_tbs r5 __aexit__z(AsyncRealtimeConnectionManager.__aexit__ps4    (##))+ + + ) +s *535N) rFr+rGrLrArrBrrCr$rKrd)rKrqrKz httpx.URLrztype[BaseException] | NonerzBaseException | NonerzTracebackType | NonerKrd) rNrOrPrr`renterrrrQr7r5rYrYs&KK K  K  K'AK K 1!f E;,2,9M,Wk, ,r7rYceZdZUdZded<ded<ded<ded <d ed <dd Zdd ZddZddZddZ dddddZ ddZ y)RealtimeConnectionrrRealtimeSessionResourcertRealtimeResponseResourcervRealtimeConversationResourcerx RealtimeInputAudioBufferResourcerzWebsocketConnectionr|c||_t||_t||_t ||_t||_yr1) r|rrtrrvrrxrrzr~s r5r`zRealtimeConnection.__init__s<%.t4 06 8>"B4"Hr7c#VKddlm} |j#|$rYywxYwwrrrs r5__iter__zRealtimeConnection.__iter__s5 = iik!!   s)&)&)c@|j|jS)rrr3s r5rzRealtimeConnection.recvs  122r7c|jjd}tjd|t |t st dt||S)rFrrrrrs r5rzRealtimeConnection.recv_bytessV""''u'5 2W='5)WX\]dXeWfgh hr7ct|tr|jdddn"tjt |t }|jj|yr) rr rrrrr(r|rrs r5rzRealtimeConnection.sendsR%+ MMtSWM XOE3KLM d#r7rrrc>|jj||yrrrs r5rzRealtimeConnection.closes D8r7c ttttj|tt tSrrrs r5rzRealtimeConnection.parse_eventrr7N)rrrKrd)rKzIterator[RealtimeServerEvent]rrrrr) rNrOrPrrr`rrrrrrrQr7r5rrwsND $$&&..88$$I 3 $$(r9 r7rc\eZdZdZ ddZddZeZd dZ d dZy) rHa" Context manager over a `RealtimeConnection` that is returned by `beta.realtime.connect()` This context manager ensures that the connection will be closed when it exits. --- Note that if your application doesn't work well with the context manager approach then you can call the `.enter()` method directly to initiate a connection. **Warning**: You must remember to close the connection with `.close()`. ```py connection = client.beta.realtime.connect(...).enter() # ... connection.close() ``` cX||_||_d|_||_||_||_yr1)"_RealtimeConnectionManager__client!_RealtimeConnectionManager__model&_RealtimeConnectionManager__connection'_RealtimeConnectionManager__extra_query)_RealtimeConnectionManager__extra_headers8_RealtimeConnectionManager__websocket_connection_optionsrs r5r`z"RealtimeConnectionManager.__init__s2  7;(,.J+r7c  ddlm}|j}|j j }t|j r)|j j|j|\}}|jji|j jjd|ji|}tjd||j r tjd|j t#|t%|f|j j&t)i|d d i|j*d |j |_|j,S#t$r}td|d}~wwxYw) u{ 👋 If your application doesn't work well with the context manager approach then you can call this method directly to initiate a connection. **Warning**: You must remember to close the connection with `.close()`. ```py connection = client.beta.realtime.connect(...).enter() # ... connection.close() ``` rrrNrGrrrrrr)websockets.sync.clientrJrr r r rrrr rrrrr.rrrrLrr!r r rs r5 __enter__z#RealtimeConnectionManager.__enter__so d 6(( }}11 4== )(, (I(I$,,Xc(d %K!++--((//,  $c*  . . II.0S0S T. C "&--":":#2&%}(( $ 55      E dYZ`c c dsE!! E;* E66E;c.|jj*tj|jj}n&|jjj d}|j jddz}|j |Sr)r rrrrrrrrs r5rz&RealtimeConnectionManager._prepare_urlrr7cR|j|jjyyr1)r rrs r5__exit__z"RealtimeConnectionManager.__exit__&s'    (    # # % )r7N) rFr*rGrLrArrBrrCr$rKrd)rKrrr) rNrOrPrr`rrrrrQr7r5rHrHs&KK K  K  K'AK K 1!f E;&2&9M&Wk& &r7rHceZdZddZy)BaseRealtimeConnectionResourcec||_yr1r|r~s r5r`z'BaseRealtimeConnectionResource.__init__. %r7N)rrrKrdrNrOrPr`rQr7r5rr-&r7rceZdZedddZy)revent_idc p|jjttt d||dyuSend this event to update the session’s default configuration. The client may send this event at any time to update the session configuration, and any field may be updated at any time, except for "voice". The server will respond with a `session.updated` event that shows the full effective configuration. Only fields that are present are updated, thus the correct way to clear a field like "instructions" is to pass an empty string. zsession.update)rrtrNr|rrr(rr4rtrs r5updatezRealtimeSessionResource.update3s4  ()9g[c de  r7Nrtz"session_update_event_param.Sessionrstr | NotGivenrKrdrNrOrPrr#rQr7r5rr2s `i r7rc6eZdZeedddZeed ddZy)rr response_idc p|jjttt d||dyzSend this event to cancel an in-progress response. The server will respond with a `response.cancelled` event or an error if there is no response to cancel. zresponse.cancel)rrr)Nr!r4rr)s r5cancelzRealtimeResponseResource.cancelFs4  ():al mn  r7rrvc p|jjttt d||dya This event instructs the server to create a Response, which means triggering model inference. When in Server VAD mode, the server will create Responses automatically. A Response will include at least one Item, and may have two, in which case the second will be a function call. These Items will be appended to the conversation history. The server will respond with a `response.created` event, events for Items and content created, and finally a `response.done` event to indicate the Response is complete. The `response.create` event includes inference configuration like `instructions`, and `temperature`. These fields will override the Session's configuration for this Response only. zresponse.create)rrrvNr!r4rrvs r5createzRealtimeResponseResource.createTs4.  ():^f gh  r7Nrr%r)r%rKrdrr%rvz/response_create_event_param.Response | NotGivenrKrdrNrOrPrr-r2rQr7r5rrEs93<\e  "$-DM  ! B    r7rceZdZeddZy)rc,t|jSr1) RealtimeConversationItemResourcer|r3s r5itemz!RealtimeConversationResource.itemts/0@0@AAr7N)rKr8rNrOrPrr9rQr7r5rrssBBr7rcXeZdZedddZeed ddZed d dZy) r8rc p|jjttt d||dya,Send this event when you want to remove any item from the conversation history. The server will respond with a `conversation.item.deleted` event, unless the item does not exist in the conversation history, in which case the server will respond with an error. zconversation.item.delete)ritem_idrNr!r4r>rs r5deletez'RealtimeConversationItemResource.deletezs5  ()CPWem no  r7rprevious_item_idc r|jjttt d|||dya Add a new Item to the Conversation's context, including messages, function calls, and function call responses. This event can be used both to populate a "history" of the conversation and to add new items mid-stream, but has the current limitation that it cannot populate assistant audio messages. If successful, the server will respond with a `conversation.item.created` event, otherwise an `error` event will be sent. zconversation.item.create)rr9rrBNr!r4r9rrBs r5r2z'RealtimeConversationItemResource.creates<  ( : $$,,<   r7c t|jjttt d||||dyuSend this event to truncate a previous assistant message’s audio. The server will produce audio faster than realtime, so this event is useful when the user interrupts to truncate audio that has already been sent to the client but not yet played. This will synchronize the server's understanding of the audio with the client's playback. Truncating audio will delete the server-side text transcript to ensure there is not text in the context that hasn't been heard by the user. If successful, the server will respond with a `conversation.item.truncated` event. zconversation.item.truncate)r audio_end_ms content_indexr>rNr!r4rHrIr>rs r5truncatez)RealtimeConversationItemResource.truncates?"  ( <(4)6#*$,   r7Nr>rLrr%rKrdr9r'rr%rBr%rKrd rHrrIrr>rLrr%rKrdrNrOrPrr@r2rKrQr7r5r8r8yssAJ  &$-+4  $ !  )    >bk " 36 AD P^  r7r8c6eZdZedddZedddZedddZy)rrc n|jjttt d|dyzSend this event to clear the audio bytes in the buffer. The server will respond with an `input_audio_buffer.cleared` event. zinput_audio_buffer.clearrrNr!r4rs r5clearz&RealtimeInputAudioBufferResource.clears/  )?D^lt;u+v w r7c n|jjttt d|dyar Send this event to commit the user input audio buffer, which will create a new user message item in the conversation. This event will produce an error if the input audio buffer is empty. When in Server VAD mode, the client does not need to send this event, the server will commit the audio buffer automatically. Committing the input audio buffer will trigger input audio transcription (if enabled in session configuration), but it will not create a response from the model. The server will respond with an `input_audio_buffer.committed` event. zinput_audio_buffer.commitrSNr!rTs r5commitz'RealtimeInputAudioBufferResource.commits/  )?D_mu;v+w x r7c p|jjttt d||dyaSend this event to append audio bytes to the input audio buffer. The audio buffer is temporary storage you can write to and later commit. In Server VAD mode, the audio buffer is used to detect speech and the server will decide when to commit. When Server VAD is disabled, you must commit the audio buffer manually. The client may choose how much audio to place in each event up to a maximum of 15 MiB, for example streaming smaller chunks from the client may allow the VAD to be more responsive. Unlike made other client events, the server will not send a confirmation response to this event. zinput_audio_buffer.append)raudiorNr!r4r[rs r5appendz'RealtimeInputAudioBufferResource.appends4  ()Dubj kl  r7Nrr%rKrdr[rLrr%rKrdrNrOrPrrUrXr]rQr7r5rrs 2; 4= "@I r7rceZdZddZy)#BaseAsyncRealtimeConnectionResourcec||_yr1rr~s r5r`z,BaseAsyncRealtimeConnectionResource.__init__rr7N)rrqrKrdrrQr7r5rbrbrr7rbc$eZdZed ddZy)rsrc K|jjttt d||dd{y7wr r!r"s r5r#z#AsyncRealtimeSessionResource.updatesB## ()9g[c de    :AAANr$r&rQr7r5rsrss"Yb < HV  r7rsc6eZdZeedddZeed ddZy)rur(c K|jjttt d||dd{y7wr+r!r,s r5r-z$AsyncRealtimeResponseResource.cancelsB## ():al mn    rfr.c K|jjttt d||dd{y7wr0r!r1s r5r2z$AsyncRealtimeResponseResource.create#sB.## ():^f gh    rfNr3r4r5rQr7r5rurus99Bbk  "$-DM  ! B    r7ruceZdZeddZy)rwc,t|jSr1)%AsyncRealtimeConversationItemResourcer|r3s r5r9z&AsyncRealtimeConversationResource.itemCs4T5E5EFFr7N)rKrlr:rQr7r5rwrwBsGGr7rwcXeZdZedddZeed ddZed d dZy) rlrc K|jjttt d||dd{y7wr=r!r?s r5r@z,AsyncRealtimeConversationItemResource.deleteIsC## ()CPWem no    rfrAc K|jjttt d|||dd{y7wrDr!rEs r5r2z,AsyncRealtimeConversationItemResource.createXsJ ## ( : $$,,<    s;AAAc K|jjttt d||||dd{y7wrGr!rJs r5rKz.AsyncRealtimeConversationItemResource.truncatevsM"## ( <(4)6#*$,    sbk " 36 AD P^  r7rlc6eZdZedddZedddZedddZy)ryrc K|jjttt d|dd{y7wrRr!rTs r5rUz+AsyncRealtimeInputAudioBufferResource.clears= ## )?D^lt;u+v w   9AAAc K|jjttt d|dd{y7wrWr!rTs r5rXz,AsyncRealtimeInputAudioBufferResource.commits=## )?D_mu;v+w x   rsc K|jjttt d||dd{y7wrZr!r\s r5r]z,AsyncRealtimeInputAudioBufferResource.appendsB## ()Dubj kl    rfNr^r_r`rQr7r5ryrys!8A :C "FO r7ry)] __future__rrloggingtypesrtypingrrrrtyping_extensionsr rpydanticr r6r r rrrr_typesrrrr_utilsrrrrr_compatr_modelsr _resourcerr _exceptionsr _base_clientr!types.beta.realtimer"r#"types.websocket_connection_optionsr$)types.beta.realtime.realtime_client_eventr%)types.beta.realtime.realtime_server_eventr&+types.beta.realtime.conversation_item_paramr'/types.beta.realtime.realtime_client_event_paramr(rr)rrr{r2r*r+__all__ getLoggerrNr.rr,r-r:rUr>rWrqrYrrHrrrrr8rrbrsrurwrlryrQr7r5rs# 55+ ;:(0;',[MMMQXNV/  ''g''1^11 1 h1 $1 h@@EEFFKKJ J Zf,f,RJ J Zf&f&R&&  < &+ =+ \B#AB L 'EL ^/ 'E/ d&&  #F *+ $G+ \G(KG L ,OL ^/ ,O/ r7