U e»{j_Cã@s6ddlmZddlmZdgZdgZGdd„dƒZdS)é)Ú SAMPClient)Ú SAMPHubProxyÚSAMPIntegratedClientzSAMPIntegratedClient.*c@sÐeZdZdZdPdd„Zedd„ƒZdQd d „Zd d „Zdd„Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„ZdRd4d5„Zd6d7„Zejje_d8d9„Zejje_d:d;„Z ej je _dSdd?„Z"ej"je"_dUd@dA„Z#ej#je#_dBdC„Z$ej$je$_dVdDdE„Z%ej%je%_dWdFdG„Z&ej&je&_dHdI„Z'ej'je'_dXdJdK„Z(ej(je(_dLdM„Z)ej)je)_dNdO„Z*ej*je*_dS)Yrao A Simple SAMP client. This class is meant to simplify the client usage providing a proxy class that merges the :class:`~astropy.samp.SAMPClient` and :class:`~astropy.samp.SAMPHubProxy` functionalities in a simplified API. Parameters ---------- name : str, optional Client name (corresponding to ``samp.name`` metadata keyword). description : str, optional Client description (corresponding to ``samp.description.text`` metadata keyword). metadata : dict, optional Client application metadata in the standard SAMP format. addr : str, optional Listening address (or IP). This defaults to 127.0.0.1 if the internet is not reachable, otherwise it defaults to the host name. port : int, optional Listening XML-RPC server socket port. If left set to 0 (the default), the operating system will select a free port. callable : bool, optional Whether the client can receive calls and notifications. If set to `False`, then the client can send notifications and calls, but can not receive any. NéTcCs&tƒ|_||||||dœ|_d|_dS)N)ÚnameÚ descriptionÚmetadataÚaddrÚportÚcallable)rÚhubÚclient_argumentsÚclient)Úselfrrrr r r ©rú]/var/www/html/bwave/python/venv/lib/python3.8/site-packages/astropy/samp/integrated_client.pyÚ__init__/s úzSAMPIntegratedClient.__init__cCs|jjo|jjS)zØ Testing method to verify the client connection with a running Hub. Returns ------- is_connected : bool True if the client is connected to a Hub, False otherwise. )r Ú is_connectedrÚ is_running©rrrrrNs z!SAMPIntegratedClient.is_connectedécCs:|j |||¡t|jf|jŽ|_|j ¡|j ¡dS)aN Connect with the current or specified SAMP Hub, start and register the client. Parameters ---------- hub : `~astropy.samp.SAMPHubServer`, optional The hub to connect to. hub_params : dict, optional Optional dictionary containing the lock-file content of the Hub with which to connect. This dictionary has the form ``{: , ...}``. pool_size : int, optional The number of socket connections opened to communicate with the Hub. N)r Úconnectrr rÚstartÚregister)rr Z hub_paramsZ pool_sizerrrrZs zSAMPIntegratedClient.connectcCs8|jr4z|j ¡W5|jjr(|j ¡|j ¡XdS)zw Unregister the client from the current SAMP Hub, stop the client and disconnect from the Hub. N)rrrÚstopr Ú disconnectÚ unregisterrrrrrxs  zSAMPIntegratedClient.disconnectcCs |j ¡S)zL Proxy to ``ping`` SAMP Hub method (Standard Profile only). )r Úpingrrrrr†szSAMPIntegratedClient.pingcCs |j |¡S)z? Proxy to ``declareMetadata`` SAMP Hub method. )rÚdeclare_metadata)rrrrrrŒsz%SAMPIntegratedClient.declare_metadatacCs|j | ¡|¡S)z; Proxy to ``getMetadata`` SAMP Hub method. )r Ú get_metadataÚget_private_key©rZ client_idrrrr’sz!SAMPIntegratedClient.get_metadatacCs|j | ¡|¡S)z@ Proxy to ``getSubscriptions`` SAMP Hub method. )r Úget_subscriptionsr r!rrrr"˜sz&SAMPIntegratedClient.get_subscriptionscCs|j | ¡¡S)z” Proxy to ``getRegisteredClients`` SAMP Hub method. This returns all the registered clients, excluding the current client. )r Úget_registered_clientsr rrrrr#žsz+SAMPIntegratedClient.get_registered_clientscCs|j | ¡|¡S)zD Proxy to ``getSubscribedClients`` SAMP Hub method. )r Úget_subscribed_clientsr )rÚmtyperrrr$¦sz+SAMPIntegratedClient.get_subscribed_clientscCs>i}d|kr0|d}|d=||dœ}| |¡n ||dœ}|S)NZ extra_kws)z samp.mtypez samp.params©Úupdate)rr%ÚparamsÚmsgÚextrarrrÚ_format_easy_msg¬s   z%SAMPIntegratedClient._format_easy_msgcCs|j | ¡||¡S)z6 Proxy to ``notify`` SAMP Hub method. )r Únotifyr )rÚ recipient_idÚmessagerrrr,¹szSAMPIntegratedClient.notifycKs| || ||¡¡S)a4 Easy to use version of :meth:`~astropy.samp.integrated_client.SAMPIntegratedClient.notify`. This is a proxy to ``notify`` method that allows to send the notification message in a simplified way. Note that reserved ``extra_kws`` keyword is a dictionary with the special meaning of being used to add extra keywords, in addition to the standard ``samp.mtype`` and ``samp.params``, to the message sent. Parameters ---------- recipient_id : str Recipient ID mtype : str the MType to be notified params : dict or set of str Variable keyword set which contains the list of parameters for the specified MType. Examples -------- >>> from astropy.samp import SAMPIntegratedClient >>> cli = SAMPIntegratedClient() >>> ... >>> cli.enotify("samp.msg.progress", msgid = "xyz", txt = "initialization", ... percent = "10", extra_kws = {"my.extra.info": "just an example"}) )r,r+)rr-r%r(rrrÚenotify¿szSAMPIntegratedClient.enotifycCs|j | ¡|¡S)z9 Proxy to ``notifyAll`` SAMP Hub method. )r Ú notify_allr )rr.rrrr0àszSAMPIntegratedClient.notify_allcKs| | ||¡¡S)a Easy to use version of :meth:`~astropy.samp.integrated_client.SAMPIntegratedClient.notify_all`. This is a proxy to ``notifyAll`` method that allows to send the notification message in a simplified way. Note that reserved ``extra_kws`` keyword is a dictionary with the special meaning of being used to add extra keywords, in addition to the standard ``samp.mtype`` and ``samp.params``, to the message sent. Parameters ---------- mtype : str MType to be notified. params : dict or set of str Variable keyword set which contains the list of parameters for the specified MType. Examples -------- >>> from astropy.samp import SAMPIntegratedClient >>> cli = SAMPIntegratedClient() >>> ... >>> cli.enotify_all("samp.msg.progress", txt = "initialization", ... percent = "10", ... extra_kws = {"my.extra.info": "just an example"}) )r0r+)rr%r(rrrÚ enotify_allæsz SAMPIntegratedClient.enotify_allcCs|j | ¡|||¡S)z4 Proxy to ``call`` SAMP Hub method. )r Úcallr )rr-Úmsg_tagr.rrrr2szSAMPIntegratedClient.callcKs| ||| ||¡¡S)a} Easy to use version of :meth:`~astropy.samp.integrated_client.SAMPIntegratedClient.call`. This is a proxy to ``call`` method that allows to send a call message in a simplified way. Note that reserved ``extra_kws`` keyword is a dictionary with the special meaning of being used to add extra keywords, in addition to the standard ``samp.mtype`` and ``samp.params``, to the message sent. Parameters ---------- recipient_id : str Recipient ID msg_tag : str Message tag to use mtype : str MType to be sent params : dict of set of str Variable keyword set which contains the list of parameters for the specified MType. Examples -------- >>> from astropy.samp import SAMPIntegratedClient >>> cli = SAMPIntegratedClient() >>> ... >>> msgid = cli.ecall("abc", "xyz", "samp.msg.progress", ... txt = "initialization", percent = "10", ... extra_kws = {"my.extra.info": "just an example"}) )r2r+)rr-r3r%r(rrrÚecall s$zSAMPIntegratedClient.ecallcCs|j | ¡||¡S)z7 Proxy to ``callAll`` SAMP Hub method. )r Úcall_allr )rr3r.rrrr51szSAMPIntegratedClient.call_allcKs| || ||¡¡dS)aV Easy to use version of :meth:`~astropy.samp.integrated_client.SAMPIntegratedClient.call_all`. This is a proxy to ``callAll`` method that allows to send the call message in a simplified way. Note that reserved ``extra_kws`` keyword is a dictionary with the special meaning of being used to add extra keywords, in addition to the standard ``samp.mtype`` and ``samp.params``, to the message sent. Parameters ---------- msg_tag : str Message tag to use mtype : str MType to be sent params : dict of set of str Variable keyword set which contains the list of parameters for the specified MType. Examples -------- >>> from astropy.samp import SAMPIntegratedClient >>> cli = SAMPIntegratedClient() >>> ... >>> msgid = cli.ecall_all("xyz", "samp.msg.progress", ... txt = "initialization", percent = "10", ... extra_kws = {"my.extra.info": "just an example"}) N)r5r+)rr3r%r(rrrÚ ecall_all7s zSAMPIntegratedClient.ecall_allcCs|j | ¡|||¡S)z; Proxy to ``callAndWait`` SAMP Hub method. )r Ú call_and_waitr )rr-r.Útimeoutrrrr7Ys ÿz"SAMPIntegratedClient.call_and_waitcKs| || ||¡|¡S)a• Easy to use version of :meth:`~astropy.samp.integrated_client.SAMPIntegratedClient.call_and_wait`. This is a proxy to ``callAndWait`` method that allows to send the call message in a simplified way. Note that reserved ``extra_kws`` keyword is a dictionary with the special meaning of being used to add extra keywords, in addition to the standard ``samp.mtype`` and ``samp.params``, to the message sent. Parameters ---------- recipient_id : str Recipient ID mtype : str MType to be sent timeout : str Call timeout in seconds params : dict of set of str Variable keyword set which contains the list of parameters for the specified MType. Examples -------- >>> from astropy.samp import SAMPIntegratedClient >>> cli = SAMPIntegratedClient() >>> ... >>> cli.ecall_and_wait("xyz", "samp.msg.progress", "5", ... txt = "initialization", percent = "10", ... extra_kws = {"my.extra.info": "just an example"}) )r7r+)rr-r%r8r(rrrÚecall_and_waitas # ÿz#SAMPIntegratedClient.ecall_and_waitcCs|j | ¡||¡S)z5 Proxy to ``reply`` SAMP Hub method. )r Úreplyr )rÚmsg_idÚresponserrrr:ˆszSAMPIntegratedClient.replycCs8d|i}|dk r| d|i¡|dk r4| d|i¡|S)Nz samp.statusz samp.resultz samp.errorr&)rÚstatusÚresultÚerrorr)rrrÚ_format_easy_responseŽs z*SAMPIntegratedClient._format_easy_responsecCs| || |||¡¡S)aa Easy to use version of :meth:`~astropy.samp.integrated_client.SAMPIntegratedClient.reply`. This is a proxy to ``reply`` method that allows to send a reply message in a simplified way. Parameters ---------- msg_id : str Message ID to which reply. status : str Content of the ``samp.status`` response keyword. result : dict Content of the ``samp.result`` response keyword. error : dict Content of the ``samp.error`` response keyword. Examples -------- >>> from astropy.samp import SAMPIntegratedClient, SAMP_STATUS_ERROR >>> cli = SAMPIntegratedClient() >>> ... >>> cli.ereply("abd", SAMP_STATUS_ERROR, result={}, ... error={"samp.errortxt": "Test error message"}) )r:r@)rr;r=r>r?rrrÚereply—szSAMPIntegratedClient.ereplycCs|j |||¡S©N)rÚreceive_notification)rÚ private_keyÚ sender_idr.rrrrC¸sz)SAMPIntegratedClient.receive_notificationcCs|j ||||¡SrB)rÚ receive_call)rrDrEr;r.rrrrF½sz!SAMPIntegratedClient.receive_callcCs|j ||||¡SrB)rÚreceive_response)rrDZ responder_idr3r<rrrrGÂs ÿz%SAMPIntegratedClient.receive_responsecCs|jj||ddddS)NT)Údeclarer)rÚbind_receive_message©rr%ÚfunctionrHrrrrrIÉsz)SAMPIntegratedClient.bind_receive_messagecCs|j ||||¡dSrB)rÚbind_receive_notificationrJrrrrLÎsz.SAMPIntegratedClient.bind_receive_notificationcCs|j ||||¡dSrB)rÚbind_receive_callrJrrrrMÓsz&SAMPIntegratedClient.bind_receive_callcCs|j ||¡dSrB)rÚbind_receive_response)rr3rKrrrrNØsz*SAMPIntegratedClient.bind_receive_responsecCs|j ||¡dSrB)rÚunbind_receive_notification©rr%rHrrrrOÝsz0SAMPIntegratedClient.unbind_receive_notificationcCs|j ||¡dSrB)rÚunbind_receive_callrPrrrrQâsz(SAMPIntegratedClient.unbind_receive_callcCs|j |¡dSrB)rÚunbind_receive_response)rr3rrrrRçsz,SAMPIntegratedClient.unbind_receive_responsecCs|j |¡dSrB)rÚdeclare_subscriptions)rZ subscriptionsrrrrSìsz*SAMPIntegratedClient.declare_subscriptionscCs |j ¡SrB)rr rrrrr ñsz$SAMPIntegratedClient.get_private_keycCs |j ¡SrB)rÚ get_public_idrrrrrTösz"SAMPIntegratedClient.get_public_id)NNNNrT)NNr)NN)TN)TN)TN)T)T)N)+Ú__name__Ú __module__Ú __qualname__Ú__doc__rÚpropertyrrrrrrr"r#r$r+r,r/r0r1r2r4r5r6r7r9r:r@rArCrrFrGrIrLrMrNrOrQrRrSr rTrrrrr st$ù   !&"' !                  N)rrZ hub_proxyrÚ__all__Z__doctest_skip__rrrrrÚs