How to use the cent.core.Client function in cent

body11 = "hi #11"
        body12 = "hi #12"
        body21 = "hi #21"
        body22 = "hi #22"
        bodyU1 = "We do not want to see this! #1"
        bodyU2 = "We do not want to see this! #2"
        m11 = Message.objects.create(sender=self.participant1, thread=self.thread1, body=body11)
        m12 = Message.objects.create(sender=self.participant2, thread=self.thread1, body=body12)
        m21 = Message.objects.create(sender=self.participant3, thread=self.thread2, body=body21)
        m22 = Message.objects.create(sender=self.participant1, thread=self.thread2, body=body22)
        mU1 = Message.objects.create(sender=self.participant2, thread=self.thread_unrelated, body=bodyU1)
        mU2 = Message.objects.create(sender=self.participant3, thread=self.thread_unrelated, body=bodyU2)
        # the channels are private
        # this means that Centrifugo will check the users ids to know if the user may connect
        # if we query a private channel the user does not belong to, we never see the message
        client = Client("{0}api/".format(getattr(settings, "CENTRIFUGE_ADDRESS")), getattr(settings, "CENTRIFUGE_SECRET"))
        forbidden_message = "Message forbidden"
        client.publish(
            build_channel(namespace=settings.CENTRIFUGO_MESSAGE_NAMESPACE, name=self.thread_unrelated.id, user_ids=[p.id for p in self.thread_unrelated.participants.all()]),
            forbidden_message
        )
        # we wait a little bit
        time.sleep(4)
        # now the messages should be displayed
        m11 = self.selenium.find_element_by_id('message__{0}'.format(m11.id))
        m12 = self.selenium.find_element_by_id('message__{0}'.format(m12.id))
        m21 = self.selenium.find_element_by_id('message__{0}'.format(m21.id))
        m22 = self.selenium.find_element_by_id('message__{0}'.format(m22.id))
        self.assertTrue(body11 in m11.text)
        self.assertTrue(body12 in m12.text)
        self.assertTrue(body21 in m21.text)
        self.assertTrue(body22 in m22.text)

def __init__(self, address=None, key=None, secret=None, timeout=10, json_encoder=None):
        self.address = address or settings.CENTRIFUGE_ADDRESS
        self.project_key = key or settings.CENTRIFUGE_PROJECT_KEY
        self.project_secret = secret or settings.CENTRIFUGE_PROJECT_SECRET
        self.timeout = timeout or settings.CENTRIFUGE_TIMEOUT
        self.api_address = self.address
        self._client = RawClient(
            self.api_address, self.project_key, self.project_secret,
            timeout=self.timeout, json_encoder=json_encoder
        )

def publish_participation_to_thread(sender, instance, created, **kwargs):
    """ Warns users everytime a thread including them is published. This is done via channel subscription.  """
    if kwargs.get('created_and_add_participants') is True:
        request_participant_id = kwargs.get('request_participant_id')
        if request_participant_id is not None:
            client = Client("{0}api/".format(getattr(settings, "CENTRIFUGE_ADDRESS")), getattr(settings, "CENTRIFUGE_SECRET"))
            active_participants = [participation.participant for participation in Participation.objects.filter(thread=instance, date_left__isnull=True).select_related('participant')]
            for participant in active_participants:
                client.publish(
                    build_channel(settings.CENTRIFUGO_THREAD_NAMESPACE, participant.id, [participant.id]),
                    {
                        "message_channel_to_connect_to": build_channel(settings.CENTRIFUGO_MESSAGE_NAMESPACE, instance.id, [p.id for p in active_participants])
                    }

def publish_message_to_centrifugo(sender, instance, created, **kwargs):
    """ Publishes each saved message to Centrifugo. """
    if created is True:
        client = Client("{0}api/".format(getattr(settings, "CENTRIFUGE_ADDRESS")), getattr(settings, "CENTRIFUGE_SECRET"))
        # we ensure the client is still in the thread (he may have left or have been removed)
        active_participants = [participation.participant.id for participation in Participation.objects.filter(thread=instance.thread, date_left__isnull=True).select_related('participant')]
        client.publish(
            build_channel(settings.CENTRIFUGO_MESSAGE_NAMESPACE, instance.thread.id, active_participants),
            {
                "id": instance.id,
                "body": instance.body,
                "sender": instance.sender.id,
                "thread": instance.thread.id,
                "sent_at": str(instance.sent_at),
                "is_notification": True,  # ATTENTION: check against sender too to be sure to not notify him his message
            }