h:UddlmZddlZddlZddlmZddlmZmZm Z m Z ddl m Z ddl Z ddlmZddlmZmZmZmZdd lmZmZmZmZmZdd lmZdd lmZdd lm Z m!Z!dd l"m#Z#ddl$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:erddl;mmd?ZYGd@dAeYZZGdBdCeYZ[GdDdEeYZ\GdFdGeYZ]GdHdIeYZ^GdJdKeYZ_dS)L) annotationsN) TracebackType) TYPE_CHECKINGAnyIteratorcast) AsyncIterator) BaseModel) NOT_GIVENQueryHeadersNotGiven)is_azure_clientmaybe_transformstrip_not_givenasync_maybe_transformis_async_azure_client)cached_property)construct_type_unchecked)SyncAPIResourceAsyncAPIResource) OpenAIError)_merge_mappings) ClientSecretsAsyncClientSecretsClientSecretsWithRawResponse!AsyncClientSecretsWithRawResponse"ClientSecretsWithStreamingResponse'AsyncClientSecretsWithStreamingResponse)session_update_event_param)WebsocketConnectionOptions)RealtimeClientEvent)RealtimeServerEvent)ConversationItemParam)RealtimeClientEventParam)!RealtimeResponseCreateParamsParam)ClientConnection)OpenAI AsyncOpenAIRealtime AsyncRealtimezlogging.LoggerlogcheZdZeddZeddZeddZiiidddZdS)r,returnrc*t|jSN)r_clientselfs o/var/www/html/web-builder-api.evdpl.com/venv/lib/python3.11/site-packages/openai/resources/realtime/realtime.pyclient_secretszRealtime.client_secrets7sT\***RealtimeWithRawResponsec t|Sa This property can be used as a prefix for any HTTP method call to return 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 )r9r4s r6with_raw_responsezRealtime.with_raw_response;s't,,,r8RealtimeWithStreamingResponsec t|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 )r=r4s r6with_streaming_responsez Realtime.with_streaming_responseEs-T222r8 extra_query extra_headerswebsocket_connection_optionsmodelstrrBr rCrrDr#RealtimeConnectionManagerc4t|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. )clientrBrCrDrE)rGr3r5rErBrCrDs r6connectzRealtime.connectNs,&)<#')E     r8N)r0r)r0r9)r0r=) rErFrBr rCrrDr#r0rG__name__ __module__ __qualname__rr7r<r@rLr8r6r,r,6s+++_+---_-333_3 !#CE         r8cheZdZeddZeddZeddZiiidddZdS)r-r0rc*t|jSr2)rr3r4s r6r7zAsyncRealtime.client_secretsks!$,///r8AsyncRealtimeWithRawResponsec t|Sr;)rTr4s r6r<zAsyncRealtime.with_raw_responseos,D111r8"AsyncRealtimeWithStreamingResponsec t|Sr?)rVr4s r6r@z%AsyncRealtime.with_streaming_responseys2$777r8rArErFrBr rCrrDr#AsyncRealtimeConnectionManagerc4t|j||||SrI)rXr3rKs r6rLzAsyncRealtime.connects,&.<#')E     r8N)r0r)r0rT)r0rV) rErFrBr rCrrDr#r0rXrMrQr8r6r-r-js000_0222_2888_8 !#CE         r8c.eZdZd dZed dZdS) r9realtimer,r0Nonec||_dSr2 _realtimer5r[s r6__init__z RealtimeWithRawResponse.__init__ !r8rc4t|jjSr2)rr_r7r4s r6r7z&RealtimeWithRawResponse.client_secretss+DN,IJJJr8Nr[r,r0r\)r0rrNrOrPrarr7rQr8r6r9r9sN""""KKK_KKKr8r9c.eZdZd dZed dZdS) rTr[r-r0r\c||_dSr2r^r`s r6raz%AsyncRealtimeWithRawResponse.__init__rbr8rc4t|jjSr2)rr_r7r4s r6r7z+AsyncRealtimeWithRawResponse.client_secretss01NOOOr8Nr[r-r0r\)r0rrerQr8r6rTrTsN""""PPP_PPPr8rTc.eZdZd dZed dZdS) r=r[r,r0r\c||_dSr2r^r`s r6raz&RealtimeWithStreamingResponse.__init__rbr8r c4t|jjSr2)r r_r7r4s r6r7z,RealtimeWithStreamingResponse.client_secretss1$.2OPPPr8Nrd)r0r rerQr8r6r=r=sN""""QQQ_QQQr8r=c.eZdZd dZed dZdS) rVr[r-r0r\c||_dSr2r^r`s r6raz+AsyncRealtimeWithStreamingResponse.__init__rbr8r!c4t|jjSr2)r!r_r7r4s r6r7z1AsyncRealtimeWithStreamingResponse.client_secretss6t~7TUUUr8Nri)r0r!rerQr8r6rVrVsN""""VVV_VVVr8rVceZdZUdZded<ded<ded<ded <d ed <d ed <d'dZd(dZd)dZd*dZd+dZ dddd,d"Z d-d%Z d&S).AsyncRealtimeConnection:Represents a live websocket connection to the Realtime APIAsyncRealtimeSessionResourcesessionAsyncRealtimeResponseResourceresponse%AsyncRealtimeInputAudioBufferResourceinput_audio_buffer!AsyncRealtimeConversationResource conversation&AsyncRealtimeOutputAudioBufferResourceoutput_audio_bufferAsyncWebsocketConnection _connection connectionr0r\c||_t||_t||_t ||_t||_t||_ dSr2) r~rsrtrurvrwrxryrzr{r|r5rs r6raz AsyncRealtimeConnection.__init__s^%3D99 5d;; "G"M"M=dCC#I$#O#O   r8"AsyncIterator[RealtimeServerEvent]cjKddlm} |d{VWV#|$rYdSwxYwzq An infinite-iterator that will continue to yield events until the connection is closed. r)ConnectionClosedOKTNwebsockets.exceptionsrrecvr5rs r6 __aiter__z!AsyncRealtimeConnection.__aiter__st =<<<<<  ( IIKK'''''''''' (!    FF s )22r%c`K||d{VS) 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_bytesr4s r6rzAsyncRealtimeConnection.recvs8 doo&7&7 7 7 7 7 7 7888r8bytescK|jdd{V}td||S)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: %sr~rr.debugr5messages r6rz"AsyncRealtimeConnection.recv_bytessM(--U-;;;;;;;; 3W===r8event.RealtimeClientEvent | RealtimeClientEventParamcKt|tr|dddn,tjt |t d{V}|j|d{VdSNT) use_api_namesexclude_defaults exclude_unset) isinstancer to_jsonjsondumpsrr'r~sendr5rdatas r6rzAsyncRealtimeConnection.sends%++ ZEMMtSWM X X X"7?W"X"XXXXXXXYY ##D)))))))))))r8codereasonrintrrFcNK|j||d{VdSNrr~closer5rrs r6rzAsyncRealtimeConnection.closes:$$$v$>>>>>>>>>>>r8r str | bytesc 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%rrloadsrr5rs r6rz#AsyncRealtimeConnection.parse_event@  !9 4@P@PX\]`buXvXv!w!w!w   r8N)rr}r0r\)r0rr0r%r0rrrr0r\rrrrFr0r\rrr0r%) rNrOrP__doc____annotations__rarrrrrrrQr8r6rqrqsDD))))++++====3333????))))PPPP    9999    *****.R??????      r8rqc6eZdZdZddZddZeZddZddZdS)rXa) Context manager over a `AsyncRealtimeConnection` that is returned by `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.realtime.connect(...).enter() # ... await connection.close() ``` rJr+rErFrBr rCrrDr#r0r\cZ||_||_d|_||_||_||_dSr2)'_AsyncRealtimeConnectionManager__client&_AsyncRealtimeConnectionManager__model+_AsyncRealtimeConnectionManager__connection,_AsyncRealtimeConnectionManager__extra_query._AsyncRealtimeConnectionManager__extra_headers=_AsyncRealtimeConnectionManager__websocket_connection_optionsr5rJrErBrCrDs r6raz'AsyncRealtimeConnectionManager.__init__!s8  <@(,.J+++r8rqc K ddlm}n"#t$r}td|d}~wwxYw|j}|jd{V|jj}t|jr*|j |j |d{V\}}nD| i|jj jd|j i|}td||jr td|jt%|t'|f|jjt+i||jd |jd{V|_|jS) 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.realtime.connect(...).enter() # ... await connection.close() ``` rrL9You need to install `openai[realtime]` to use this methodNrEparamsConnecting to %sConnection options: %suser_agent_headeradditional_headers)websockets.asyncio.clientrL ImportErrorrrr_refresh_api_key auth_headersr_configure_realtimer _prepare_url copy_withbase_urlrr.rrrqrF user_agentrrrr5rLexcrBrurls r6 __aenter__z)AsyncRealtimeConnectionManager.__aenter__1s d 9 9 9 9 9 9 9 d d dYZZ`c c d( m,,.........}1  / / &*m&G&G Va&b&b b b b b b b C##%%//m,3T\"0C $c***  . U II.0S T T T3'C "&-":#2&( $$  5             s *%* httpx.URLc|jjtj|jj}n |jjd}|jddz}||SNwss)scheme/s /realtime)raw_path)rwebsocket_base_urlhttpxURL _base_urlrrrstripr5rmerge_raw_paths r6rz+AsyncRealtimeConnectionManager._prepare_urlfp = + 7y!ABBHH}.888FFH!*11$77,F!!>!:::r8exc_typetype[BaseException] | NonerBaseException | Noneexc_tbTracebackType | NonecZK|j!|jd{VdSdSr2)rrr5rrrs r6 __aexit__z(AsyncRealtimeConnectionManager.__aexit__osF   (#))++ + + + + + + + + + ) (r8N) rJr+rErFrBr rCrrDr#r0r\)r0rqr0rrrrrrrr0r\) rNrOrPrrarenterrrrQr8r6rXrX sz&KKKK 1!1!1!1!f E;;;;,,,,,,r8rXceZdZUdZded<ded<ded<ded <d ed <d ed <d'dZd(dZd)dZd*dZd+dZ dddd,d"Z d-d%Z d&S).RealtimeConnectionrrRealtimeSessionResourcertRealtimeResponseResourcerv RealtimeInputAudioBufferResourcerxRealtimeConversationResourcerz!RealtimeOutputAudioBufferResourcer|WebsocketConnectionr~rr0r\c||_t||_t||_t ||_t||_t||_ dSr2) r~rrtrrvrrxrrzrr|rs r6razRealtimeConnection.__init__s^%.t44 066 "B4"H"H8>>#DT#J#J   r8Iterator[RealtimeServerEvent]c#\Kddlm} |V#|$rYdSwxYwrrrs r6__iter__zRealtimeConnection.__iter__s_ =<<<<<  "iikk!!! "!    FF s "++r%cP||S)rrr4s r6rzRealtimeConnection.recvs"  1 1222r8rcr|jd}td||S)rFrrrrs r6rzRealtimeConnection.recv_bytess7"''u'55 3W===r8rrct|tr|dddn&tjt |t }|j|dSr) rr rrrrr'r~rrs r6rzRealtimeConnection.sendsk%++ NEMMtSWM X X XOE3KLLMM d#####r8rrrrrrrFc>|j||dSrrrs r6rzRealtimeConnection.closes$ D88888r8rrc ttttj|tt tSrrrs r6rzRealtimeConnection.parse_eventrr8N)rrr0r\)r0rrrrrr) rNrOrPrrrarrrrrrrQr8r6rrvsDD$$$$&&&&8888....::::$$$$KKKK    3333    $$$$$(r999999      r8rc6eZdZdZddZddZeZddZddZdS)rGa Context manager over a `RealtimeConnection` that is returned by `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.realtime.connect(...).enter() # ... connection.close() ``` rJr*rErFrBr rCrrDr#r0r\cZ||_||_d|_||_||_||_dSr2)"_RealtimeConnectionManager__client!_RealtimeConnectionManager__model&_RealtimeConnectionManager__connection'_RealtimeConnectionManager__extra_query)_RealtimeConnectionManager__extra_headers8_RealtimeConnectionManager__websocket_connection_optionsrs r6raz"RealtimeConnectionManager.__init__s8  7;(,.J+++r8rc  ddlm}n"#t$r}td|d}~wwxYw|j}|j|jj}t|jr$|j |j |\}}nD| i|jj jd|j i|}td||jr td|jt%|t'|f|jjt+i||jd |j|_|jS) uv 👋 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.realtime.connect(...).enter() # ... connection.close() ``` rrrNrErrrr)websockets.sync.clientrLrrrrrrrrrrrrrr.rrrrFrrrrrs r6 __enter__z#RealtimeConnectionManager.__enter__s d 6 6 6 6 6 6 6 d d dYZZ`c c d(  &&(((}1 4= ) )  $ A A$,P[ \ \ C##%%//m,3T\"0C $c***  . U II.0S T T T. GC "&-":#2&( $$  5       s (#(rc|jjtj|jj}n |jjd}|jddz}||Sr)rrrrrrrrrs r6rz&RealtimeConnectionManager._prepare_urlrr8rrrrrrcJ|j|jdSdSr2)rrrs r6__exit__z"RealtimeConnectionManager.__exit__#s0   (   # # % % % % % ) (r8N) rJr*rErFrBr rCrrDr#r0r\)r0rrr) rNrOrPrrarrrrrQr8r6rGrGsz&KKKK 1!1!1!1!f E;;;;&&&&&&r8rGceZdZddZdS)BaseRealtimeConnectionResourcerrr0r\c||_dSr2r~rs r6raz'BaseRealtimeConnectionResource.__init__+%r8N)rrr0r\rNrOrPrarQr8r6rr*(&&&&&&r8rceZdZedd dZd S) revent_idrt"session_update_event_param.Sessionr%str | NotGivenr0r\c |jttt d||ddSu Send this event to update the session’s configuration. The client may send this event at any time to update any field except for `voice` and `model`. `voice` can be updated only if there have been no other audio outputs yet. When the server receives a `session.update`, it will respond with a `session.updated` event showing the full, effective configuration. Only the fields that are present in the `session.update` are updated. To clear a field like `instructions`, pass an empty string. To clear a field like `tools`, pass an empty array. To clear a field like `turn_detection`, pass `null`. zsession.update)typertr%Nr~rrr'rr5rtr%s r6updatezRealtimeSessionResource.update0sP  ()9g[c d dee       r8Nrtr&r%r'r0r\rNrOrPr r-rQr8r6rr/s5`i        r8rc.eZdZeedd dZeed dd Zd S)rr%rvr%r'rv,RealtimeResponseCreateParamsParam | NotGivenr0r\c |jttt d||ddSa 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 by default. 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 `tools`. If these are set, they will override the Session's configuration for this Response only. Responses can be created out-of-band of the default Conversation, meaning that they can have arbitrary input, and it's possible to disable writing the output to the Conversation. Only one Response can write to the default Conversation at a time, but otherwise multiple Responses can be created in parallel. The `metadata` field is a good way to disambiguate multiple simultaneous Responses. Clients can set `conversation` to `none` to create a Response that does not write to the default Conversation. Arbitrary input can be provided with the `input` field, which is an array accepting raw Items and references to existing Items. zresponse.create)r*r%rvNr+r5r%rvs r6createzRealtimeResponseResource.createEsQB  ():^f g ghh       r8r% response_idr8c |jttt d||ddSaSend this event to cancel an in-progress response. The server will respond with a `response.done` event with a status of `response.status=cancelled`. If there is no response to cancel, the server will respond with an error. It's safe to call `response.cancel` even if no response is in progress, an error will be returned the session will remain unaffected. zresponse.cancel)r*r%r8Nr+r5r%r8s r6cancelzRealtimeResponseResource.cancelmsP  ():al m mnn       r8Nr%r'rvr2r0r\r%r'r8r'r0r\rNrOrPr r6r<rQr8r6rrDsa$-AJ & & & & & & P4=\e        r8rc8eZdZedd dZedd dZedd d Zd S)rr$r%r'r0r\c |jttt d|ddSzSend this event to clear the audio bytes in the buffer. The server will respond with an `input_audio_buffer.cleared` event. zinput_audio_buffer.clearr*r%Nr+r5r%s r6clearz&RealtimeInputAudioBufferResource.clearsI  )?D^lt;u;u+v+v w w     r8c |jttt d|ddSa@ 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.commitrCNr+rDs r6commitz'RealtimeInputAudioBufferResource.commitsI  )?D_mu;v;v+w+w x x     r8audiorFc |jttt d||ddSaSend this event to append audio bytes to the input audio buffer. The audio buffer is temporary storage you can write to and later commit. A "commit" will create a new user message item in the conversation history from the buffer content and clear the buffer. Input audio transcription (if enabled) will be generated when the buffer is committed. If VAD is enabled 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. Input audio noise reduction operates on writes to the audio buffer. 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 most other client events, the server will not send a confirmation response to this event. zinput_audio_buffer.append)r*rIr%Nr+r5rIr%s r6appendz'RealtimeInputAudioBufferResource.appendsP"  ()Dubj k kll       r8Nr%r'r0r\rIrFr%r'r0r\rNrOrPr rErHrMrQr8r6rr~s}2;      4=      @I        r8rc&eZdZeddZdS)rr0 RealtimeConversationItemResourcec*t|jSr2)rRr~r4s r6itemz!RealtimeConversationResource.items/0@AAAr8N)r0rRrNrOrPrrTrQr8r6rrs8BBB_BBBr8rcHeZdZedddZeed dd ZedddZedddZdS)rRr$item_idrFr%r'r0r\c |jttt d||ddSa,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.deleter*rWr%Nr+r5rWr%s r6deletez'RealtimeConversationItemResource.deletesQ  ()CPWem n noo       r8r%previous_item_idrTr&r^c |jttt d|||ddSa 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)r*rTr%r^Nr+r5rTr%r^s r6r6z'RealtimeConversationItemResource.creates\  ( : $$,,<    r8 audio_end_msr content_indexc |jttt d||||ddSuSend 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*rbrcrWr%Nr+r5rbrcrWr%s r6truncatez)RealtimeConversationItemResource.truncates_"  ( <(4)6#*$,    r8c |jttt d||ddSa Send this event when you want to retrieve the server's representation of a specific item in the conversation history. This is useful, for example, to inspect user audio after noise cancellation and VAD. The server will respond with a `conversation.item.retrieved` event, unless the item does not exist in the conversation history, in which case the server will respond with an error. zconversation.item.retrieverZNr+r[s r6retrievez)RealtimeConversationItemResource.retrievesQ  ()ERYgo p pqq       r8NrWrFr%r'r0r\rTr&r%r'r^r'r0r\ rbrrcrrWrFr%r'r0r\rNrOrPr r\r6rgrjrQr8r6rRrRsAJ       &$-+4       >bk      @DM         r8rRceZdZedddZdS) rr$r%r'r0r\c |jttt d|ddSa**WebRTC Only:** Emit to cut off the current audio response. This will trigger the server to stop generating audio and emit a `output_audio_buffer.cleared` event. This event should be preceded by a `response.cancel` client event to stop the generation of the current response. [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc). zoutput_audio_buffer.clearrCNr+rDs r6rEz'RealtimeOutputAudioBufferResource.clearsI  )?D_mu;v;v+w+w x x     r8NrNrNrOrPr rErQr8r6rrs52;         r8rceZdZddZdS)#BaseAsyncRealtimeConnectionResourcerrqr0r\c||_dSr2rrs r6raz,BaseAsyncRealtimeConnectionResource.__init__r r8N)rrqr0r\r!rQr8r6rtrtr"r8rtceZdZedd dZd S) rsr$rtr&r%r'r0r\c K|jttt d||dd{VdSr)r+r,s r6r-z#AsyncRealtimeSessionResource.update$sr## ()9g[c d dee             r8Nr.r/rQr8r6rsrs#s5Yb        r8rsc.eZdZeedd dZeed dd Zd S)rur1r%r'rvr2r0r\c K|jttt d||dd{VdSr4r+r5s r6r6z$AsyncRealtimeResponseResource.create;ssB## ():^f g ghh             r8r7r8c K|jttt d||dd{VdSr:r+r;s r6r<z$AsyncRealtimeResponseResource.cancelcsr## ():al m mnn             r8Nr=r>r?rQr8r6ruru:sb$-AJ & & & & & & P:Cbk        r8ruc8eZdZedd dZedd dZedd d Zd S)rwr$r%r'r0r\c K|jttt d|dd{VdSrBr+rDs r6rEz+AsyncRealtimeInputAudioBufferResource.clearusk ## )?D^lt;u;u+v+v w w           r8c K|jttt d|dd{VdSrGr+rDs r6rHz,AsyncRealtimeInputAudioBufferResource.commitsk ## )?D_mu;v;v+w+w x x           r8rIrFc K|jttt d||dd{VdSrKr+rLs r6rMz,AsyncRealtimeInputAudioBufferResource.appendsr"## ()Dubj k kll             r8NrNrOrPrQr8r6rwrwts~8A      :C      FO        r8rwc&eZdZeddZdS)ryr0%AsyncRealtimeConversationItemResourcec*t|jSr2)rr~r4s r6rTz&AsyncRealtimeConversationResource.items4T5EFFFr8N)r0rrUrQr8r6ryrys8GGG_GGGr8rycHeZdZedddZeed dd ZedddZedddZdS)rr$rWrFr%r'r0r\c K|jttt d||dd{VdSrYr+r[s r6r\z,AsyncRealtimeConversationItemResource.deletess## ()CPWem n noo             r8r]rTr&r^c K|jttt d|||dd{VdSr`r+ras r6r6z,AsyncRealtimeConversationItemResource.creates~ ## ( : $$,,<      r8rbrrcc K|jttt d||||dd{VdSrer+rfs r6rgz.AsyncRealtimeConversationItemResource.truncates"## ( <(4)6#*$,      r8c K|jttt d||dd{VdSrir+r[s r6rjz.AsyncRealtimeConversationItemResource.retrievess## ()ERYgo p pqq             r8NrkrlrmrnrQr8r6rrsGP       &$-+4       >bk      @JS         r8rceZdZedddZdS) r{r$r%r'r0r\c K|jttt d|dd{VdSrqr+rDs r6rEz,AsyncRealtimeOutputAudioBufferResource.clearsk## )?D_mu;v;v+w+w x x           r8NrNrrrQr8r6r{r{s58A         r8r{)` __future__rrloggingtypesrtypingrrrrtyping_extensionsr rpydanticr _typesr r rr_utilsrrrrr_compatr_modelsr _resourcerr _exceptionsr _base_clientrr7rrrrr r!types.realtimer""types.websocket_connection_optionsr#$types.realtime.realtime_client_eventr$$types.realtime.realtime_server_eventr%&types.realtime.conversation_item_paramr&*types.realtime.realtime_client_event_paramr'4types.realtime.realtime_response_create_params_paramr(rr)rrr}r3r*r+__all__ getLoggerrNr.rr,r-r9rTr=rVrqrXrrGrrrrrrRrrtrsrurwryrr{rQr8r6rs#"""""" 555555555555++++++ 999999999999'&&&&&//////::::::::&&&&&&++++++988888LLLLLLGGGGGGGGGGGGKKKKKKRRRRRReeeeee/NNNNNNVVVVVV........  ''g'1111111 1 1 1 1 1 1 1 h1 1 1 1 1 $1 1 1 hKKKKKKKKPPPPPPPPQQQQQQQQVVVVVVVVH H H H H H H H Vf,f,f,f,f,f,f,f,RH H H H H H H H Vf&f&f&f&f&f&f&f&R&&&&&&&&      <   *7 7 7 7 7 =7 7 7 t+ + + + + 'E+ + + \BBBBB#ABBB Z Z Z Z Z 'EZ Z Z z      (F    &&&&&&&&      #F   .7 7 7 7 7 $G7 7 7 t+ + + + + ,O+ + + \GGGGG(KGGG Z Z Z Z Z ,OZ Z Z z      -P      r8