pip install requests

import requests
r = requests.get('http://wthrcdn.etouch.cn/weather_mini')
print(r.text)

import requests
data ={}
data['city']='Пекин'
r = requests.get('http://wthrcdn.etouch.cn/weather_mini',params=data)
print(r.text)

import hashlib
data ={}
data['city']='Хэфэй'
auth=hashlib.md5(data['city'].encode(encoding='utf-8')).hexdigest()
headers = {'Authorization': auth}
r = requests.get('http://wthrcdn.etouch.cn/weather_mini',params=data,headers=headers)
print(r.text)

import json
url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}
r = requests.post(url, data=json.dumps(payload))

pip install websockets

import uuid
import websockets

async def send_msg(websocket):
    text = «Я хочу проверить свой баланс»
    bs = str(base64.b64encode(text.encode('utf-8')), 'utf-8')
    sid = uuid.uuid4()
    timestamp = str(int(time.time()) * 1000)
    msg = '{"app":"test","sn":"123","timeStamp":"' + timestamp + '","version":"1.0.0","data":"' + bs + '",' \
          '"sid":"' + str(sid) + '"} '
    print(msg)
    await websocket.send(msg)
    rev_text = await websocket.recv()
    print(rev_text)

async def client():
    async with websockets.connect('ws://xxx.xxx.com/nlp') as websocket:
        await send_msg(websocket)

if __name__ == '__main__':
    asyncio.get_event_loop().run_until_complete(client())

pip install grpcio
pip install grpcio-tools

syntax = "proto3";

package protocol;

message AvatarRequest {
  string	app = 1;
  string	timestamp = 2;
  string	version = 3;
  string	anchorId = 4;
  string	vcn = 5;
  bytes		data = 6;
  int32		width = 7;
  int32		height = 8;
  string	type=9;

}

message AvatarResponse {
  string	code = 1;
  string	msg = 2;
  string	type = 3;
  bytes		data = 4;
  string	status = 5;
  string	sessionId = 6;
}

service AvatarInteraction {
  rpc Interact (stream AvatarRequest) returns (stream AvatarResponse) {
  }
}

import sys
import threading
import time
import grpc
import avatar_pb2 as pb
import avatar_pb2_grpc as avatar


class avatarClient(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.status = False
        self.serverUrl = ""
        self.anchorId = '1001'
        self.vcn = 'xiaoyuan'
        self.app = 'testapp'
        self.type = '0'
        self.sendTxt = False
        self.text = ""
        self.connectType = '1001'
        self.pingType = '-1000'
        self.width = 1080
        self.height = 1920
        self.sid = ""
        self.print_res = printRes()
        self.lastPingTime = int(time.time() * 1000)

    # служба связи
    def connect_sever(self):
        return pb.AvatarRequest(app=self.app, timestamp=str(int(time.time() * 1000)), version='1.0.0',
                                anchorId=self.anchorId, vcn=self.vcn, type=self.connectType, width=self.width,
                                height=self.height)

    # Отправить текст
    def send_text(self):
        return pb.AvatarRequest(app=self.app, timestamp=str(int(time.time() * 1000)), version='1.0.0',
                                anchorId=self.anchorId, vcn=self.vcn, type='3', data=str(self.text).encode('utf-8'))

    # отправить пинг
    def send_ping(self):
        return pb.AvatarRequest(app=self.app, timestamp=str(int(time.time() * 1000)), version='1.0.0',
                                anchorId=self.anchorId, vcn=self.vcn,тип = self.pingType)

    защита send_message (сам):
        дать self.connect_sever()
		#Интервал 10 секунд,отправить ping, выполнить проверку активности соединения
        while True:
            if self.sendTxt:
                yield self.send_text()
                self.sendTxt = False
            if (int(time.time() * 1000) - int(self.lastPingTime)) < 10000:
                continue
            else:
                yield self.send_ping()
                self.lastPingTime = int(time.time() * 1000)

    def run(self):
        self.status = True
        if self.serverUrl == "":
            return
        with grpc.insecure_channel(self.serverUrl) as channel:
            stub = avatar.AvatarInteractionStub(channel)
            self.channel = channel
            responses = stub.Interact(self.send_message())

            self.print_res.setClient(responses, self)
            self.print_res.start()
            time.sleep(1)
            while True:
                if self.print_res.runStatus == False:
                    break
                client.text = input("input your text:\n")
                client.sendTxt = True
                time.sleep(1)

    def stop(self):
        try:
            self.status = False
            self.print_res.runStatus = False
            time.sleep(1)
        except KeyboardInterrupt:
            pass


class printRes(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.runStatus = True

    def setClient(self, responses, client):
        self.responses = responses
        self.client = client

    def run(self):
        try:
            for response in self.responses:
                print(response)
                if not self.runStatus:
                    sys.exit(0)
                if response.code != "000000":
                    self.runStatus = False
                    sys.exit(0)
        except Exception:
            print("err")


if __name__ == '__main__':
    client = avatarClient()
    client.serverUrl = "xxx.xxx.xxx.xxx:xxxx"
    client.start()

pip install PyQt5

pip install PyQt5-tools

# -*- coding: utf-8 -*-
import sys
import asyncio
import base64
import time
import uuid
import websockets
from PyQt5 import QtCore, QtWidgets
from PyQt5.QtWidgets import *


class Ui_mainWindow(object):
    def __init__(self, mainWindow):
        self.mainWindow = mainWindow
        self.setupUi()

    def setupUi(self):
        self.mainWindow.setObjectName("mainWindow")
        self.mainWindow.setWindowModality(QtCore.Qt.WindowModal)
        self.mainWindow.resize(600, 300)
        self.mainWindow.setWindowTitle("Инструмент тестирования НЛП")

        self.centralwidget = QtWidgets.QWidget(self.mainWindow)
        self.centralwidget.setObjectName("centralwidget")

        self.widget1 = QtWidgets.QWidget(self.centralwidget)
        self.widget1.setGeometry(QtCore.QRect(10, 30, 400, 25))
        self.widget1.setObjectName("widget1")
        self.horizontalLayout = QtWidgets.QHBoxLayout(self.widget1)
        self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
        self.horizontalLayout.setObjectName("horizontalLayout")

        self.serverUrlLabel = QtWidgets.QLabel(self.widget1)
        self.serverUrlLabel.setObjectName("label")
        self.serverUrlLabel.setText("Адрес службы:")
        self.horizontalLayout.addWidget(self.serverUrlLabel)

        self.serverUrlLineEdit = QtWidgets.QLineEdit(self.widget1)
        self.serverUrlLineEdit.setEnabled(True)
        self.serverUrlLineEdit.setText("ws://xxx..xxx.xxx/nlp")
        self.serverUrlLineEdit.setMinimumWidth(320)
        self.serverUrlLineEdit.setMaximumWidth(320)
        self.serverUrlLineEdit.setObjectName("serverUrlLineEdit")
        self.horizontalLayout.addWidget(self.serverUrlLineEdit, stretch=500, alignment=QtCore.Qt.AlignLeft)

        self.sendTextWidget = QtWidgets.QWidget(self.centralwidget)
        self.sendTextWidget.setGeometry(QtCore.QRect(0, 70, 500, 70))
        self.sendTextWidget.setObjectName("sendTextWidget")
        self.sendTextLayout = QtWidgets.QHBoxLayout(self.sendTextWidget)
        self.sendTextLayout.setContentsMargins(0, 0, 0, 0)
        self.sendTextLayout.setObjectName("sendTextLayout")

        self.sendTextLabel = QtWidgets.QLabel(self.sendTextWidget)
        self.sendTextLabel.setContentsMargins(20, 0, 0, 0)
        self.sendTextLabel.setText("текст:")        self.sendTextLayout.addWidget(self.sendTextLabel)

        self.sendTextTextEdit = QtWidgets.QTextEdit(self.sendTextWidget)
        self.sendTextTextEdit.setObjectName("sendTextTextEdit")
        self.sendTextLayout.addWidget(self.sendTextTextEdit)

        self.sendTextButton = QtWidgets.QPushButton(self.sendTextWidget)
        self.sendTextButton.setObjectName("sendText")
        self.sendTextButton.setText("отправить")
        self.sendTextButton.clicked.connect(self.send_text)
        self.sendTextLayout.addWidget(self.sendTextButton)

        self.widget3 = QtWidgets.QWidget(self.centralwidget)
        self.widget3.setGeometry(QtCore.QRect(0, 160, 420, 90))
        self.widget3.setObjectName("widget3")

        self.logLayout = QtWidgets.QHBoxLayout(self.widget3)
        self.logLayout.setContentsMargins(0, 0, 0, 0)
        self.logLayout.setObjectName("logLayout")

        self.logLabel = QtWidgets.QLabel(self.widget3)
        self.logLabel.setObjectName("logLabel")
        self.logLabel.setContentsMargins(20, 0, 0, 0)
        self.logLabel.setLineWidth(30)
        self.logLabel.setText("возврат:")
        self.logLayout.addWidget(self.logLabel)

        self.logTextEdit = QtWidgets.QTextEdit(self.widget3)
        self.logTextEdit.setContentsMargins(0, 0, 0, 0)
        self.logTextEdit.setObjectName("logTextEdit")
        self.logLayout.addWidget(self.logTextEdit)

        self.mainWindow.setCentralWidget(self.centralwidget)
        self.statusbar = QtWidgets.QStatusBar(self.mainWindow)
        self.statusbar.setObjectName("statusbar")
        self.mainWindow.setStatusBar(self.statusbar)

        QtCore.QMetaObject.connectSlotsByName(self.mainWindow)

    def send_text(self):
        self.websocketClient = WebsocketClient()
        self.websocketClient.url = self.serverUrlLineEdit.text()
        self.websocketClient.text = self.sendTextTextEdit.toPlainText()
        result = self.websocketClient.run()
        self.logTextEdit.setText(result)

class WebsocketClient:
    def __init__(self):
        self.url = ""

    async def send_msg(self, websocket):
        if self.text == "":
            return "empty text"
        bs = str(base64.b64encode(self.text.encode('utf-8')), 'utf-8')
        sid = uuid.uuid4()
        timestamp = str(int(time.time()) * 1000)
		msg = '{"app":"test","sn":"123","timeStamp":"' + timestamp + '","version":"1.0.0","data":"' + bs + '",' \
			'"sid":"' + str(sid) + '"} '
        await websocket.send(msg)
        rev_text = await websocket.recv()
        self.result = rev_text
        self.text = ""
        return rev_text

    async def connect(self):
        try:
            async with websockets.connect(self.url) as websocket:
                res = await self.send_msg(websocket)
                return res
        except Exception as e:
            return str(e)

    def run(self):
        return asyncio.get_event_loop().run_until_complete(self.connect())


if __name__ == "__main__":
    app = QApplication(sys.argv)
	window = QMainWindow()
	box = Ui_mainWindow(window)
	window.show()
    sys.exit(app.exec_())