Skip to main content
`Ctrl`+`K`

# Communication between Integrated Clients Objects

As shown in Sending and Receiving Tables and Images over SAMP, the |SAMPIntegratedClient| class can be used to communicate with other SAMP-enabled tools such as |TOPCAT|, SAO DS9, or Aladin Desktop.

In this section, we look at how we can set up two |SAMPIntegratedClient| instances and communicate between them.

First, start up a SAMP hub as described in Starting and Stopping a SAMP Hub Server.

Next, we create two clients and connect them to the hub:

    >>> from astropy import samp
    >>> client1 = samp.SAMPIntegratedClient(name="Client 1", description="Test Client 1",
    ...                                     metadata = {"client1.version":"0.01"})
    >>> client2 = samp.SAMPIntegratedClient(name="Client 2", description="Test Client 2",
    ...                                     metadata = {"client2.version":"0.25"})
    >>> client1.connect()
    >>> client2.connect()

We now define functions to call when receiving a notification, call or response:

    >>> def test_receive_notification(private_key, sender_id, mtype, params, extra):
    ...     print("Notification:", private_key, sender_id, mtype, params, extra)

    >>> def test_receive_call(private_key, sender_id, msg_id, mtype, params, extra):
    ...     print("Call:", private_key, sender_id, msg_id, mtype, params, extra)
    ...     client1.ereply(msg_id, samp.SAMP_STATUS_OK, result = {"txt": "printed"})

    >>> def test_receive_response(private_key, sender_id, msg_id, response):
    ...     print("Response:", private_key, sender_id, msg_id, response)

We subscribe client 1 to `"samp.app.*"` and bind it to the related functions:

    >>> client1.bind_receive_notification("samp.app.*", test_receive_notification)
    >>> client1.bind_receive_call("samp.app.*", test_receive_call)

We now bind message tags received by client 2 to suitable functions:

    >>> client2.bind_receive_response("my-dummy-print", test_receive_response)
    >>> client2.bind_receive_response("my-dummy-print-specific", test_receive_response)

We are now ready to test out the clients and callback functions. Client 2 notifies all clients using the “samp.app.echo” message type via the hub:

    >>> client2.enotify_all("samp.app.echo", txt="Hello world!")
    ['cli#2']
    Notification: 0d7f4500225981c104a197c7666a8e4e cli#2 samp.app.echo {'txt':
    'Hello world!'} {'host': 'antigone.lambrate.inaf.it', 'user': 'unknown'}

We can also find a dictionary that specifies which clients would currently receive `samp.app.echo` messages:

    >>> print(client2.get_subscribed_clients("samp.app.echo"))
    {'cli#2': {}}

Client 2 calls all clients with the `"samp.app.echo"` message type using `"my-dummy-print"` as a message-tag:

    >>> print(client2.call_all("my-dummy-print",
    ...                        {"samp.mtype": "samp.app.echo",
    ...                         "samp.params": {"txt": "Hello world!"}}))
    {'cli#1': 'msg#1;;cli#hub;;cli#2;;my-dummy-print'}
    Call: 8c8eb53178cb95e168ab17ec4eac2353 cli#2
    msg#1;;cli#hub;;cli#2;;my-dummy-print samp.app.echo {'txt': 'Hello world!'}
    {'host': 'antigone.lambrate.inaf.it', 'user': 'unknown'}
    Response: d0a28636321948ccff45edaf40888c54 cli#1 my-dummy-print
    {'samp.status': 'samp.ok', 'samp.result': {'txt': 'printed'}}

Client 2 then calls client 1 using the `"samp.app.echo"` message type, tagging the message as `"my-dummy-print-specific"`:

    >>> try:
    ...     print(client2.call(client1.get_public_id(),
    ...                        "my-dummy-print-specific",
    ...                        {"samp.mtype": "samp.app.echo",
    ...                         "samp.params": {"txt": "Hello client 1!"}}))
    ... except samp.SAMPProxyError as e:
    ...     print("Error ({0}): {1}".format(e.faultCode, e.faultString))
    msg#2;;cli#hub;;cli#2;;my-dummy-print-specific
    Call: 8c8eb53178cb95e168ab17ec4eac2353 cli#2
    msg#2;;cli#hub;;cli#2;;my-dummy-print-specific samp.app.echo {'txt': 'Hello
    Cli 1!'} {'host': 'antigone.lambrate.inaf.it', 'user': 'unknown'}
    Response: d0a28636321948ccff45edaf40888c54 cli#1 my-dummy-print-specific
    {'samp.status': 'samp.ok', 'samp.result': {'txt': 'printed'}}

We can now define a function called to test synchronous calls:

    >>> def test_receive_sync_call(private_key, sender_id, msg_id, mtype, params, extra):
    ...     import time
    ...     print("SYNC Call:", sender_id, msg_id, mtype, params, extra)
    ...     time.sleep(2)
    ...     client1.reply(msg_id, {"samp.status": samp.SAMP_STATUS_OK,
    ...                            "samp.result": {"txt": "printed sync"}})

We now bind the `samp.test` message type to `test_receive_sync_call`:

    >>> client1.bind_receive_call("samp.test", test_receive_sync_call)
    >>> try:
    ...     # Sync call
    ...     print(client2.call_and_wait(client1.get_public_id(),
    ...                                 {"samp.mtype": "samp.test",
    ...                                  "samp.params": {"txt": "Hello SYNCRO client 1!"}},
    ...                                  "10"))
    ... except samp.SAMPProxyError as e:
    ...     # If timeout expires than a SAMPProxyError is returned
    ...     print("Error ({0}): {1}".format(e.faultCode, e.faultString))
    SYNC Call: cli#2 msg#3;;cli#hub;;cli#2;;sampy::sync::call samp.test {'txt':
    'Hello SYNCRO Cli 1!'} {'host': 'antigone.lambrate.inaf.it', 'user':
    'unknown'}
    {'samp.status': 'samp.ok', 'samp.result': {'txt': 'printed sync'}}

Finally, we disconnect the clients from the hub at the end:

    >>> client1.disconnect()
    >>> client2.disconnect()