o iVj@s ddlmZddlZddlZddlZddlZddlZddlmZm Z m Z m Z m Z m Z mZmZmZddlmZmZddlmZmZddlmZddlmZdd lmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%ddl&m'Z'm(Z(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl,m2Z2ddl3m4Z4m5Z5m6Z6m7Z7Gddde8Z9Gddde8Z:Gddde8Z;Gddde8Ze d!ge e e e?e e?ffZ@ed"e e2ge e e e?e e?ffd#ZAGd$d%d%e>ZBGd&d'd'e>ZCdS)() annotationsN) ListUnionCallableDict AwaitableOptionalMappingcastTypeVar)abstractmethodABC) FfiClient FfiHandle)ffi_pb2)participant_pb2)TrackPublishOptions)TranscriptionSegment)ParticipantTrackPermission)BroadcastQueue) LocalTrack)LocalTrackPublicationRemoteTrackPublicationTrackPublication) Transcription)RpcError)"RpcMethodInvocationResponseRequest)logger)RpcInvocationData)TextStreamWriterByteStreamWriterByteStreamInfoSTREAM_CHUNK_SIZEc@eZdZdddZdS) PublishTrackErrormessagestrreturnNonecC ||_dSNr&selfr&r/Y/var/www/html/livekit_bhavya/venv/lib/python3.10/site-packages/livekit/rtc/participant.py__init__; zPublishTrackError.__init__Nr&r'r(r)__name__ __module__ __qualname__r1r/r/r/r0r%:r%c@r$) UnpublishTrackErrorr&r'r(r)cCr*r+r,r-r/r/r0r1@r2zUnpublishTrackError.__init__Nr3r4r/r/r/r0r9?r8r9c@r$) PublishDataErrorr&r'r(r)cCr*r+r,r-r/r/r0r1Er2zPublishDataError.__init__Nr3r4r/r/r/r0r:Dr8r:c@r$) PublishDTMFErrorr&r'r(r)cCr*r+r,r-r/r/r0r1Jr2zPublishDTMFError.__init__Nr3r4r/r/r/r0r;Ir8r;c@r$) PublishTranscriptionErrorr&r'r(r)cCr*r+r,r-r/r/r0r1Or2z"PublishTranscriptionError.__init__Nr3r4r/r/r/r0r<Nr8r<c@seZdZd ddZeed!dd Zed"d d Zed"d dZed"ddZ ed"ddZ ed#ddZ ed$ddZ ed%ddZ ed&ddZdS)' Participant owned_info"proto_participant.OwnedParticipantr(r)cCs|j|_t|jj|_dSr+)info_inforhandleid _ffi_handler.r>r/r/r0r1TszParticipant.__init__Mapping[str, TrackPublication]cCsdS)U A dictionary of track publications associated with the participant. Nr/r.r/r/r0track_publicationsXszParticipant.track_publicationsr'cC|jjSr+)rAsidrHr/r/r0rK`zParticipant.sidcCrJr+)rAnamerHr/r/r0rMdrLzParticipant.namecCrJr+)rAidentityrHr/r/r0rNhrLzParticipant.identitycCrJr+)rAmetadatarHr/r/r0rOlrLzParticipant.metadatadict[str, str]cCs t|jjS)z2Custom attributes associated with the participant.)dictrA attributesrHr/r/r0rRps zParticipant.attributes+proto_participant.ParticipantKind.ValueTypecCrJ)zLParticipant's kind (e.g., regular participant, ingress, egress, sip, agent).)rAkindrHr/r/r0rTuzParticipant.kind'proto_participant.ParticipantPermissioncCrJ)z.The participant's permissions within the room.)rA permissionrHr/r/r0 permissionszrUzParticipant.permissions6Optional[proto_participant.DisconnectReason.ValueType]cCs|jjtjjkr dS|jjS)aReason for the participant's disconnection. Returns one of DisconnectReasons or None if the participant isn't disconnected. Common reasons are: - CLIENT_INITIATED - the client initiated the disconnect - DUPLICATE_IDENTITY - another participant with the same identity has joined the room - SERVER_SHUTDOWN - the server instance is shutting down - PARTICIPANT_REMOVED - RoomService.RemoveParticipant was called - ROOM_DELETED - RoomService.DeleteRoom was called - STATE_MISMATCH - the client is attempting to resume a session, but server is not aware of it - JOIN_FAILURE - client was unable to connect fully When dialing a participant via SIP, you may see the following reasons: - USER_UNAVAILABLE - SIP callee did not respond in time - USER_REJECTED - SIP callee rejected the call (busy) - SIP_TRUNK_FAILURE - SIP protocol failure or unexpected response N)rAdisconnect_reasonproto_participantDisconnectReasonUNKNOWN_REASONrHr/r/r0rZszParticipant.disconnect_reasonNr>r?r(r))r(rFr(r')r(rP)r(rS)r(rV)r(rY)r5r6r7r1propertyr rIrKrMrNrOrRrTrXrZr/r/r/r0r=Ss*        r=rF)boundcs>eZdZdZdpfdd Zedqd d Zd gdddrddZdsddZdtd!d"Z d#d$dud)d*Z #dvdwd/d0Z dxd1d2Z d#d3dyd7d8Z dzd=d>Zd{d@dAZd|dCdDZd}dGdHZd#dd#d#d#d#d#dId~dSdTZd#dd#d#dUddWdXZd#dYd#d#d#ddZdd]d^Zdd#d#d#d_ddbdcZefddidjZddldmZddndoZZS)LocalParticipantz+Represents the local participant in a room. room_queue"BroadcastQueue[proto_ffi.FfiEvent]r>r?r(r)cs"t|||_i|_i|_dSr+)superr1 _room_queue_track_publications _rpc_handlers)r.rdr> __class__r/r0r1s  zLocalParticipant.__init__#Mapping[str, LocalTrackPublication]cC|jSrGrhrHr/r/r0rIz#LocalParticipant.track_publicationsT)reliabledestination_identitiestopicpayloadUnion[bytes, str]rrboolrs List[str]rtr'c st|tr |d}t|}tj||}t}|jj |j _ t ||j _ ||j _||j _||j _|j j|tjj}ztj||fddIdH} Wtjj|ntjj|w| j jrnt| j jdS)a Publish arbitrary data to the room. Args: payload (Union[bytes, str]): The data to publish. reliable (bool, optional): Whether to send reliably or not. Defaults to True. destination_identities (List[str], optional): List of participant identities to send to. Defaults to []. topic (str, optional): The topic under which to publish the data. Defaults to "". Raises: PublishDataError: If there is an error in publishing data. zutf-8c|jjjjkSr+) publish_dataasync_iderespr/r0z/LocalParticipant.publish_data..N) isinstancer'encodelenctypesc_byte proto_ffi FfiRequestrDrBrzlocal_participant_handle addressofdata_ptrdata_lenrrrtrsextendrinstancequeue subscriberequestwait_for unsubscribeerrorr:) r.rurrrsrtrcdatareqrcbr/r~r0rzs,        zLocalParticipant.publish_datacodeintdigitc st}|jj|j_||j_||j_tj j }ztj || fddIdH}Wtj j |ntj j |w|jjrGt|jjdS)z Publish SIP DTMF message. Args: code (int): DTMF code. digit (str): DTMF digit. Raises: PublishDTMFError: If there is an error in publishing SIP DTMF message. cryr+)publish_sip_dtmfr{r|r~r/r0rrz/LocalParticipant.publish_dtmf..N)rrrDrBrrrrrrrrrrrrr;)r.rrrrrr/r~r0 publish_dtmfs      zLocalParticipant.publish_dtmf transcriptionrc st}dd|jD}|jj|j_|j|j_|jj||j |j_ t j j }zt j ||fddIdH}Wt j j |nt j j |w|jjrXt|jjdS)a Publish transcription data to the room. Args: transcription (Transcription): The transcription data to publish. Raises: PublishTranscriptionError: If there is an error in publishing transcription. c Ss,g|]}t|j|j|j|j|j|jdqS))rCtext start_timeend_timefinallanguage)ProtoTranscriptionSegmentrCrrrrr).0sr/r/r0 s z:LocalParticipant.publish_transcription..cryr+)publish_transcriptionr{r|r~r/r0rrz8LocalParticipant.publish_transcription..N)rrsegmentsrDrBrrparticipant_identityr track_sidtrack_idrrrrrrrrr<)r.rrproto_segmentsrrr/r~r0rs&         z&LocalParticipant.publish_transcriptionN)response_timeoutdestination_identitymethodrOptional[float]c st}|jj|j_||j_||j_||j_|dur#t |d|j_ t j j }zt j ||fddIdH}Wt j j |nt j j |w|jdrZt|jj|jjS)a Initiate an RPC call to a remote participant. Args: destination_identity (str): The `identity` of the destination participant method (str): The method name to call payload (str): The method payload response_timeout (Optional[float]): Timeout for receiving a response after initial connection Returns: str: The response payload Raises: RpcError: On failure. Details in `message`. Nicryr+) perform_rpcr{r|r~r/r0rFrz.LocalParticipant.perform_rpc..r)rrrDrBrrrrrurresponse_timeout_msrrrrrrrHasFieldr _from_protor)r.rrrurrrrr/r~r0r$s      zLocalParticipant.perform_rpc method_namehandler Optional[F]Union[F, Callable[[F], F]]cs$dfdd }|dur||S|S)a Establishes the participant as a receiver for calls of the specified RPC method. Can be used either as a decorator or a regular method. The handler will receive one argument of type `RpcInvocationData` and should return a string response which will be forwarded back to the caller. The handler may be synchronous or asynchronous. If unable to respond within `response_timeout`, the caller will hang up and receive an error on their side. You may raise errors of type `RpcError` in the handler, and they will be forwarded to the caller. Other errors raised in your handler will be caught and forwarded to the caller as "1500 Application Error". Args: method_name (str): The name of the indicated RPC method. handler (Optional[Callable]): Handler to be invoked whenever an RPC request for this method is received. Omit this argument to use the decorator syntax. Returns: None (when used as a decorator it returns the decorator function) Example: # As a decorator: @room.local_participant.register_rpc_method("greet") async def greet_handler(data: RpcInvocationData) -> str: print(f"Received greeting from {data.caller_identity}: {data.payload}") return f"Hello, {data.caller_identity}!" # As a regular method: async def greet_handler(data: RpcInvocationData) -> str: print(f"Received greeting from {data.caller_identity}: {data.payload}") return f"Hello, {data.caller_identity}!" room.local_participant.register_rpc_method('greet', greet_handler) handler_funcrar(cs6|j<t}jj|j_|j_tj ||Sr+) rirrrDrBregister_rpc_methodrrrrr)rrrr.r/r0registerxs   z6LocalParticipant.register_rpc_method..registerN)rrar(rar/)r.rrrr/rr0rOs)z$LocalParticipant.register_rpc_methodcCs:|j|dt}|jj|j_||j_t j |dS)z Unregisters a previously registered RPC method. Args: method (str): The name of the RPC method to unregister N) ripoprrrDrBunregister_rpc_methodrrrrr)r.rrr/r/r0rs  z&LocalParticipant.unregister_rpc_method)participant_permissionsallow_all_participantsr*Optional[List[ParticipantTrackPermission]]cCsF|durg}t}|jj|j_||j_|jj|t j |dS)a Set the track subscription permissions for the local participant. Args: allow_all_participants (bool): Whether to allow all participants to subscribe to this participant's tracks. participant_permissions (List[ParticipantTrackPermission]): Participant-specific track subscription permissions, ignored if `allow_all_participants` is True. N) rrrDrB"set_track_subscription_permissionsrall_participants_allowedrXrrrr)r.rrrr/r/r0rs  z3LocalParticipant.set_track_subscription_permissions invocation_id request_idcaller_identityfloatc sfd}d}t||||} |j|} | sttjj}niz.N)rrrDrBrrrOrrrrrrr)r.rOrrr/r~r0 set_metadata     "zLocalParticipant.set_metadatarMc r)z Set the name for the local participant. Note: this requires `canUpdateOwnMetadata` permission. Args: name (str): The new name. cryr+)set_local_namer{r|r~r/r0rrz+LocalParticipant.set_name..N)rrrDrBrrrMrrrrrrr)r.rMrrr/r~r0set_namerzLocalParticipant.set_namerRrPc st}|jj|j_dd|jjD}|||D]\}}|jj }||_ ||_ qt j j}zt j ||fddIdHWt j j|dSt j j|w)z Set custom attributes for the local participant. Note: this requires `canUpdateOwnMetadata` permission. Args: attributes (dict[str, str]): A dictionary of attributes to set. cSsi|]}|j|jqSr/)keyvalue)rentryr/r/r0 s z3LocalParticipant.set_attributes..cryr+)set_local_attributesr{r|r~r/r0r&rz1LocalParticipant.set_attributes..N)rrrDrBrrrRupdateitemsaddrrrrrrrrr)r.rRrexisting_attributesrrrrr/r~r0set_attributes s$       "zLocalParticipant.set_attributes)rsrtrR stream_id reply_to_id total_sizesender_identityOptional[List[str]]Optional[Dict[str, str]]r str | Nonerr int | Nonerr c s,t||||||||d}|IdH|S)z Returns a TextStreamWriter that allows to write individual chunks of text to a text stream. In most cases where you want to simply send a text message use send_text() instead. )rtrRrrsrrrN)r _send_header) r.rsrtrRrrrrwriterr/r/r0 stream_text+ zLocalParticipant.stream_text)rsrtrRrrcsLt|}|j|||||dIdH}||IdH|IdH|jS)N)rsrtrRrr)rrrwriteacloser@)r.rrsrtrRrrrr/r/r0 send_textIs  zLocalParticipant.send_textapplication/octet-stream)r mime_typerRrrsrtrr!c s,t||||||||d}|IdH|S)z Returns a ByteStreamWriter that allows to write individual chunks of bytes to a byte stream. In cases where you want to simply send a file from the file system use send_file() instead. )rMrRrrrrsrtN)r!r) r.rMrrrRrrsrtrr/r/r0 stream_bytes`rzLocalParticipant.stream_bytes)rtrsrRr file_pathr"c stj|}tj|}t|\}} |durd}|j|||||||dIdH} t|d4IdH'} | t IdH} rP| | IdH| t IdH} s>WdIdHn 1IdHs`wY| IdH| j S)Nr)rMrrrRrrsrtrb)ospathgetsizebasename mimetypes guess_typeraiofilesopenreadr#rrr@) r.rrtrsrRr file_size file_namer_rfbytesr/r/r0 send_file~s,   (zLocalParticipant.send_filetrackroptionsrrc st}|jj|j_|jj|j_|jj||j }z=t j ||fddIdH}|jjr:t|jjt|jj}||_|j|j_||j|j<||W|j |S|j |w)a Publish a local track to the room. Args: track (LocalTrack): The track to publish. options (TrackPublishOptions, optional): Options for publishing the track. Returns: LocalTrackPublication: The publication of the published track. Raises: PublishTrackError: If there is an error in publishing the track. cryr+) publish_trackr{r|r~r/r0rrz0LocalParticipant.publish_track..N)rrrDrBr track_handlerrCopyFromrgrrrrrrr%r publication_trackrKrArh task_doner)r.rrrrrtrack_publicationr/r~r0rs(          zLocalParticipant.publish_trackrc st}|jj|j_||j_d|j_|j }z2t j || fddIdH}|jjr5t|jj|j|}d|_|W|j|dS|j|w)z Unpublish a track from the room. Args: track_sid (str): The SID of the track to unpublish. Raises: UnpublishTrackError: If there is an error in unpublishing the track. Tcryr+)unpublish_trackr{r|r~r/r0rrz2LocalParticipant.unpublish_track..N)rrrDrBrrrstop_on_unpublishrgrrrrrrr9rhrrrr)r.rrrrrr/r~r0rs"        z LocalParticipant.unpublish_trackcCd|jd|jd|jdS)Nzrtc.LocalParticipant(sid= , identity=, name=)rKrNrMrHr/r/r0__repr__zLocalParticipant.__repr__)rdrer>r?r(r))r(rl) rurvrrrwrsrxrtr'r(r))rrrr'r(r))rrr(r)) rr'rr'rur'rrr(r'r+)rr'rrr(r)rr'r(r))rrwrrr(r))rrrr'rr'rr'rur'rrr(r))rOr'r(r))rMr'r(r))rRrPr(r))rsrrtr'rRrrrrrrrrrr(r ) rr'rsrrtr'rRrrr)rMr'rrrr'rRrrrrsrrtr'r(r!) rr'rtr'rsrrRrrrr(r")rrrrr(r)rr'r(r)r_)r5r6r7__doc__r1r`rIrzrrrrrrrrrrrrrrrrrr! __classcell__r/r/rjr0rcsf   . .. 6  7  !""! )rccs6eZdZd fdd Zeddd Zdd d ZZS)RemoteParticipantr>r?r(r)cst|i|_dSr+)rfr1rhrErjr/r0r1s  zRemoteParticipant.__init__$Mapping[str, RemoteTrackPublication]cCrmrnrorHr/r/r0rIrpz$RemoteParticipant.track_publicationsr'cCr)Nzrtc.RemoteParticipant(sid=rrrr rHr/r/r0r!r"zRemoteParticipant.__repr__r^)r(r&r_)r5r6r7r1r`rIr!r$r/r/rjr0r%s  r%)D __future__rrrrrrtypingrrrrrrr r r abcr r _ffi_clientrr_protorrrr[_proto.room_pb2rrr_proto.track_pb2r_utilsrrrrrrrrrrpcr_proto.rpc_pb2rlogrr data_streamr r!r"r#rr%r9r:r;r<r=r' RpcHandlerrarcr%r/r/r/r0sN ,            "E"P