def create_chat_client(self):
     # [START create_chat_client]
     from azure.communication.chat.aio import ChatClient, CommunicationUserCredential
     chat_client = ChatClient(self.endpoint,
                              CommunicationUserCredential(self.token))
     # [END create_chat_client]
     print("chat_client created")
    def setUp(self):
        super(ChatThreadClientTestAsync, self).setUp()

        self.recording_processors.extend([
            BodyReplacerProcessor(keys=[
                "id", "token", "senderId", "chatMessageId", "nextLink",
                "members", "multipleStatus", "value"
            ]),
            URIIdentityReplacer(),
            ResponseReplacerProcessor(keys=[self._resource_name]),
            ChatURIReplacer()
        ])

        endpoint, _ = parse_connection_str(self.connection_str)
        self.endpoint = endpoint

        self.identity_client = CommunicationIdentityClient.from_connection_string(
            self.connection_str)

        # create user
        self.user = self.identity_client.create_user()
        token_response = self.identity_client.issue_token(self.user,
                                                          scopes=["chat"])
        self.token = token_response.token

        # create another user
        self.new_user = self.identity_client.create_user()

        # create ChatClient
        self.chat_client = ChatClient(self.endpoint,
                                      CommunicationUserCredential(self.token))
    async def delete_message_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START delete_message]
            await chat_thread_client.delete_message(self._message_id)
            # [END delete_message]
            print("delete_message succeeded")
    async def remove_member_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START remove_member]
            await chat_thread_client.remove_member(self.new_user)
            # [END remove_member]
            print("remove_member_async succeeded")
    async def send_typing_notification_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START send_typing_notification]
            await chat_thread_client.send_typing_notification()
            # [END send_typing_notification]
        print("send_typing_notification succeeded")
    async def delete_thread_async(self):
        from azure.communication.chat.aio import ChatClient, CommunicationUserCredential

        chat_client = ChatClient(self.endpoint,
                                 CommunicationUserCredential(self.token))
        async with chat_client:
            # [START delete_thread]
            await chat_client.delete_chat_thread(self._thread_id)
            # [END delete_thread]
            print("delete_thread succeeded")
    async def send_read_receipt_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START send_read_receipt]
            await chat_thread_client.send_read_receipt(self._message_id)
            # [END send_read_receipt]

        print("send_read_receipt succeeded")
    async def update_message_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START update_message]
            content = "updated message content"
            await chat_thread_client.update_message(self._message_id, content=content)
            # [END update_message]
            print("update_message succeeded")
    async def get_message_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START get_message]
            chat_message = await chat_thread_client.get_message(self._message_id)
            # [END get_message]
            print("get_message succeeded, message id:", chat_message.id, \
                "content: ", chat_message.content)
    async def list_members_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START list_members]
            chat_thread_members = chat_thread_client.list_members()
            print("list_members succeeded, members:")
            async for chat_thread_member in chat_thread_members:
                print(chat_thread_member)
    async def get_thread_async(self):
        from azure.communication.chat.aio import ChatClient, CommunicationUserCredential

        chat_client = ChatClient(self.endpoint,
                                 CommunicationUserCredential(self.token))
        async with chat_client:
            # [START get_thread]
            chat_thread = await chat_client.get_chat_thread(self._thread_id)
            # [END get_thread]
            print("get_thread succeeded, thread id: " + chat_thread.id +
                  ", thread topic: " + chat_thread.topic)
    async def list_read_receipts_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START list_read_receipts]
            read_receipts = chat_thread_client.list_read_receipts()
            # [END list_read_receipts]
            print("list_read_receipts succeeded, receipts:")
            async for read_receipt in read_receipts:
                print(read_receipt)
    async def update_thread_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START update_thread]
            topic = "updated thread topic"
            await chat_thread_client.update_thread(topic=topic)
            # [END update_thread]

        print("update_thread succeeded")
    def get_chat_thread_client(self):
        # [START get_chat_thread_client]
        from azure.communication.chat.aio import ChatClient, CommunicationUserCredential

        chat_client = ChatClient(self.endpoint,
                                 CommunicationUserCredential(self.token))
        chat_thread_client = chat_client.get_chat_thread_client(
            self._thread_id)
        # [END get_chat_thread_client]

        print("chat_thread_client created with thread id: ",
              chat_thread_client.thread_id)
    async def list_messages_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START list_messages]
            from datetime import datetime, timedelta
            start_time = datetime.utcnow() - timedelta(days=1)
            chat_messages = chat_thread_client.list_messages(results_per_page=1, start_time=start_time)
            print("list_messages succeeded with results_per_page is 1, and start time is yesterday UTC")
            async for chat_message_page in chat_messages.by_page():
                l = [ i async for i in chat_message_page]
                print("page size: ", len(l))
    async def add_members_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START add_members]
            from azure.communication.chat import ChatThreadMember, CommunicationUser
            from datetime import datetime
            new_member = ChatThreadMember(
                    user=self.new_user,
                    display_name='name',
                    share_history_time=datetime.utcnow())
            members = [new_member]
            await chat_thread_client.add_members(members)
            # [END add_members]
            print("add_members succeeded")
    async def list_threads_async(self):
        from azure.communication.chat.aio import ChatClient, CommunicationUserCredential

        chat_client = ChatClient(self.endpoint,
                                 CommunicationUserCredential(self.token))
        async with chat_client:
            # [START list_threads]
            from datetime import datetime, timedelta
            import pytz
            start_time = datetime.utcnow() - timedelta(days=2)
            start_time = start_time.replace(tzinfo=pytz.utc)
            chat_thread_infos = chat_client.list_chat_threads(
                results_per_page=5, start_time=start_time)
            print(
                "list_threads succeeded with results_per_page is 5, and were created since 2 days ago."
            )
            async for info in chat_thread_infos:
                print("thread id: ", info.id)
    async def send_message_async(self):
        from azure.communication.chat.aio import ChatThreadClient, CommunicationUserCredential
        chat_thread_client = ChatThreadClient(self.endpoint, CommunicationUserCredential(self.token), self._thread_id)

        async with chat_thread_client:
            # [START send_message]
            from azure.communication.chat import ChatMessagePriority

            priority=ChatMessagePriority.NORMAL
            content='hello world'
            sender_display_name='sender name'

            send_message_result = await chat_thread_client.send_message(
                content,
                priority=priority,
                sender_display_name=sender_display_name)
            # [END send_message]
            self._message_id = send_message_result.id
            print("send_message succeeded, message id:", self._message_id)
    async def create_chat_thread_client_async(self):
        # [START create_chat_thread_client]
        from datetime import datetime
        from azure.communication.chat.aio import ChatClient, CommunicationUserCredential
        from azure.communication.chat import ChatThreadMember, CommunicationUserIdentifier

        chat_client = ChatClient(self.endpoint, CommunicationUserCredential(self.token))

        async with chat_client:
            topic = "test topic"
            members = [ChatThreadMember(
                user=self.user,
                display_name='name',
                share_history_time=datetime.utcnow()
            )]
            chat_thread_client = await chat_client.create_chat_thread(topic, members)
        # [END create_chat_thread_client]

        self._thread_id = chat_thread_client.thread_id
        print("thread created, id: " + self._thread_id)