def download_nodes_list():
url = 'https://nodes.tox.chat/json'
s = settings.Settings.get_instance()
if not s['download_nodes_list']:
return
if not s['proxy_type']: # no proxy
try:
req = urllib.request.Request(url)
req.add_header('Content-Type', 'application/json')
response = urllib.request.urlopen(req)
result = response.read()
save_nodes(result)
except Exception as ex:
log('TOX nodes loading error: ' + str(ex))
else: # proxy
netman = QtNetwork.QNetworkAccessManager()
proxy = QtNetwork.QNetworkProxy()
proxy.setType(QtNetwork.QNetworkProxy.Socks5Proxy if s['proxy_type'] ==
2 else QtNetwork.QNetworkProxy.HttpProxy)
proxy.setHostName(s['proxy_host'])
proxy.setPort(s['proxy_port'])
netman.setProxy(proxy)
try:
request = QtNetwork.QNetworkRequest()
request.setUrl(QtCore.QUrl(url))
reply = netman.get(request)
while not reply.isFinished():
QtCore.QThread.msleep(1)
QtCore.QCoreApplication.processEvents()
data = bytes(reply.readAll().data())
save_nodes(data)
except Exception as ex:
log('TOX nodes loading error: ' + str(ex))
def onTimer(self):
timeStr = Time(datetime.utcnow(), scale='utc').iso.split('.')[0]
self.curTime.setText(timeStr.split(" ")[1])
#print('write ' + timeStr.split(" ")[1])
dateStr = Time(datetime.utcnow(), scale='utc').iso.split(' ')[0]
self.curDate.setText(dateStr)
if (self.cmd < 200):
self.cmd = 200
else:
self.cmd = 100
self.SendTimePacket()
self.SrhAntSocket.writeDatagram(
QtCore.QByteArray(
struct.pack('!16sHHHLL', b'_Srh_Net_Packet_', 0,
self.cmd, 0, 0, 0)),
QtNetwork.QHostAddress('192.168.0.168'), 9998)
testSocket = QtNetwork.QTcpSocket()
testSocket.connectToHost('192.168.0.1', 80)
if testSocket.waitForConnected() == True:
self.Network.setPixmap(self.greenBox)
else:
self.Network.setPixmap(self.redBox)
testSocket.close()
def connect_client(self):
self.logger.debug("Client connection initializer called")
if self.sock.state() != QtNetwork.QAbstractSocket.ConnectedState:
# Get the host and port from the settings file for the client connection
host = self.cfg_data.get_tcp_client_host()
port = self.cfg_data.get_tcp_client_port()
self.sock = QtNetwork.QTcpSocket() # Create the TCP socket
self.sock.readyRead.connect(self._receive) # Data que signal
self.sock.connected.connect(
self._host_connected) # What to do when we have connected
self.sock.error.connect(
self._error
) # Log any error occurred and also perform the necessary actions
self.sock.disconnected.connect(
self._disconnected
) # If there is state change then call the function
self.conStatSigC.emit(
"Connecting") # Indicate that we are attempting a connection
self.sock.connectToHost(
QtNetwork.QHostAddress(host),
int(port)) # Attempt to connect to the server
if not self.sock.waitForConnected(
msecs=1000
): # Wait a until connected (the function is waiting for 1 sec)
self.conStatSigC.emit(
"Disconnected") # Indicate that we are not connected
self.logger.warning("Client was unable to connect to: %s:%s",
host, port)
def forward(self, alarm):
data = None
if alarm.source == 'pager':
data = alarm.pager.encode('utf-8')
socket = QtNetwork.QUdpSocket()
for host, addr, port in self.hosts:
self.logger.info('Forwarding to %s (%s:%u/udp)', host,
addr.toString(), port)
socket.writeDatagram(data, addr, port)
elif alarm.source == 'xml':
data = alarm.xml # bytes
socket = QtNetwork.QTcpSocket()
for host, addr, port in self.hosts:
self.logger.info('Forwarding to %s (%s:%u/tcp)', host,
addr.toString(), port)
socket.connectToHost(addr, port)
if not socket.waitForConnected(5000):
self.logger.error('Connection failed.')
continue
socket.writeData(data)
if not socket.waitForBytesWritten(5000):
self.logger.error('Writing to socket failed.')
socket.close()
def __init__(self, id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QtNetwork.QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QtCore.QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QtNetwork.QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def run(self):
'''This starts the thread running, but it must not be called directly,
it must be started with Server.start() instead for it to be started
in its own thread. If it is called directly then it will run in
the thread in which it was called.'''
self.debug = False
self.lock = False
for i in QtNetwork.QNetworkInterface.allAddresses():
print("Found Address:", i.toString())
if i != QtNetwork.QHostAddress.LocalHost and i.protocol() == QtNetwork.QAbstractSocket.IPv4Protocol:
self.address = i
break
# This determines the IP adress of the server
self.tcpServer = QtNetwork.QTcpServer(self)
self.tcpServer.listen(QtNetwork.QHostAddress("0.0.0.0"), self.port)
# Listen on all addreses on the specified port only
self.tcpServer.newConnection.connect(self.addConnection)
# Call self.addConnection whenever the server signals that there is a new inbound connection
print("Server Initialised")
self.constantTimer = QtCore.QTimer()
self.constantTimer.timeout.connect(self.checkQueue)
self.constantTimer.start(1)
print("Server Checking Queue")
# Integrate the checkQueue function into the QT event loop, with
# a delay between calls of 1 millisecond
self.receiveQueue.put({"action":"showAddress", "port":self.port, "address":self.address, "client":"thread"})
def make_request(self, url, data, filename):
print(f"Making request to {url}")
# Create the request object
self.request = qtn.QNetworkRequest(url)
# create the multipart object
self.multipart = qtn.QHttpMultiPart(qtn.QHttpMultiPart.FormDataType)
# Write the key-value data to the multipart
json_string = json.dumps(data)
http_part = qtn.QHttpPart()
http_part.setHeader(qtn.QNetworkRequest.ContentTypeHeader, 'text/json')
http_part.setBody(json_string.encode('utf-8'))
self.multipart.append(http_part)
# Write the file data to the multipart
if filename:
file_part = qtn.QHttpPart()
filedata = open(filename, 'rb').read()
file_part.setHeader(
qtn.QNetworkRequest.ContentDispositionHeader,
f'form-data; name="attachment"; filename="{filename}"')
file_part.setBody(filedata)
self.multipart.append(file_part)
# Post the request with the form data
self.nam.post(self.request, self.multipart)
def checkWeather(self):
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleResponse)
req = QtNetwork.QNetworkRequest(self.url)
self.nam.get(req)
def __init__(self, parent=None):
super(ServerDlg, self).__init__("&Close Server", parent)
self.setWindowFlags(QC.Qt.WindowStaysOnTopHint)
self.tcpServer = QN.QTcpServer(self)
#Zjistím si svojí IP adresu
for address in QN.QNetworkInterface.allAddresses():
if address != QN.QHostAddress.LocalHost and address.toIPv4Address(
):
break
else:
address = QN.QHostAddress.LocalHost
#print(address.toString())
self.tcpServer.listen(QN.QHostAddress("0.0.0.0"), PORT) #Any address
self.tcpServer.newConnection.connect(self.addConnection)
self.connections = [None for _ in range(6)]
self.connectionAddress = [None for _ in range(6)]
self.players = {}
self.clicked.connect(self.close)
font = self.font()
font.setPointSize(24)
self.setFont(font)
self.setWindowTitle("Server")
def upload_file(file_to_upload, post_url, key, callback):
"""Method for uploading files to GIS Cloud"""
zip_part = QtNetwork.QHttpPart()
zip_part_content_disposition = QByteArray(
'form-data; name="upfile"; filename="{}"'.format(
os.path.basename(file_to_upload)).encode('utf-8'))
zip_part.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
QByteArray(b'application/json'))
zip_part.setHeader(QtNetwork.QNetworkRequest.ContentDispositionHeader,
zip_part_content_disposition)
file_handler = QFile(file_to_upload)
file_handler.open(QIODevice.ReadOnly)
zip_part.setBodyDevice(file_handler)
multi_part = QtNetwork.QHttpMultiPart(
QtNetwork.QHttpMultiPart.FormDataType)
file_handler.setParent(multi_part)
multi_part.append(zip_part)
request = QtNetwork.QNetworkRequest()
request.setRawHeader(QByteArray(b'X-GIS-CLOUD-APP'),
GISCloudNetworkHandler.app_id.encode("utf-8"))
result = GISCloudNetworkHandler.blocking_request(
GISCloudNetworkHandler.POST, post_url, key, multi_part, request,
callback)
return result
def construct_multipart(self, data, files):
multi_part = QtNetwork.QHttpMultiPart(
QtNetwork.QHttpMultiPart.FormDataType)
for key, value in data.items():
post_part = QtNetwork.QHttpPart()
post_part.setHeader(
QtNetwork.QNetworkRequest.ContentDispositionHeader,
"form-data; name=\"{}\"".format(key))
post_part.setBody(str(value).encode())
multi_part.append(post_part)
for field, filepath in files.items():
if filepath:
file = QFile(filepath)
if not file.open(QIODevice.ReadOnly):
break
post_part = QtNetwork.QHttpPart()
post_part.setHeader(
QtNetwork.QNetworkRequest.ContentDispositionHeader,
"form-data; name=\"{}\"; filename=\"{}\"".format(
field, file.fileName()))
post_part.setBodyDevice(file)
file.setParent(multi_part)
multi_part.append(post_part)
else:
break
return multi_part
def check_for_updates(self):
if self.checkBox_UpdateCheck.isChecked():
print("check for updates")
update_key = self.updateKey.displayText()
if len(update_key) == 50:
data = QUrlQuery()
data.addQueryItem("update_key", update_key)
data.addQueryItem("product", "OnAirScreen")
data.addQueryItem("current_version", versionString)
data.addQueryItem("distribution", distributionString)
data.addQueryItem("mac", self.get_mac())
data.addQueryItem(
"include_beta",
f'{self.checkBox_IncludeBetaVersions.isChecked()}')
req = QtNetwork.QNetworkRequest(QUrl(update_url))
req.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
self.nam_update_check = QtNetwork.QNetworkAccessManager()
self.nam_update_check.finished.connect(
self.handle_update_check_response)
self.nam_update_check.post(
req,
data.toString(QUrl.FullyEncoded).encode("UTF-8"))
else:
print("error, update key in wrong format")
self.error_dialog = QErrorMessage()
self.error_dialog.setWindowTitle("Update Check Error")
self.error_dialog.showMessage(
'Update key is in the wrong format!', 'UpdateKeyError')
def retrieve_latest_version(self):
''' return latest version from server '''
req = QtNetwork.QNetworkRequest(QtCore.QUrl(self.__url))
self.__qnam = QtNetwork.QNetworkAccessManager()
self.__res = self.__qnam.get(req)
self.__res.finished.connect(self.processRes)
self.__res.error.connect(self.processErr)
def makeOWMApiCall(self):
print("OWM API Call")
url = "https://api.openweathermap.org/data/2.5/weather?id=" + self.owmCityID + "&units=" + self.owmUnit + "&lang=" + self.owmLanguage + "&appid=" + self.owmAPIKey
req = QtNetwork.QNetworkRequest(QtCore.QUrl(url))
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleOWMResponse)
self.nam.get(req)
def updstartup(self):
self.udprecvcnt = 0
self.udpsendcnt = 0
self.socket = QtNetwork.QUdpSocket()
self.socket.bind(QtNetwork.QHostAddress(""), 6000)
self.socket.readyRead.connect(self.recvudp)
log.debug("Connected to socket, waiting for udp stream", extra = log.HST)
def test_startCommunication_3():
app.tcpServer = None
server = QtNetwork.QTcpServer(app)
hostAddress = QtNetwork.QHostAddress('127.0.0.1')
server.listen(hostAddress, 3490)
suc = app.startCommunication()
assert not suc
def __init__(self):
"""Initialize"""
super().__init__()
self.server = qtn.QTcpServer()
self.sock = qtn.QTcpSocket(self.server)
# if self.server.listen(qtn.QHostAddress(self.ip), self.s):
if self.server.listen(qtn.QHostAddress.LocalHost, self.s):
print(
f'DATA SERVER:\n\tAddress: {self.server.serverAddress().toString()}\n\tPort: {str(self.server.serverPort())}'
)
else:
print('ERROR!!!!')
exit()
self.server.newConnection.connect(self.__session)
f = open('key.bin', 'rb')
self.key = f.read()
f.close()
self.f = Fernet(self.key)
del self.key
# set your properties
self.db = mysql.connector.connect(host='localhost',
user='******',
passwd='password',
database='login_data',
auth_plugin='mysql_native_password')
self.mycursor = self.db.cursor()
def doRequest(self):
url = "http://www.something.com"
req = QtNetwork.QNetworkRequest(QtCore.QUrl(url))
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleResponse)
self.nam.get(req)
def doRequest(self, license_code):
print("Request started")
req = QtNetwork.QNetworkRequest(QUrl(verification_url + license_code))
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleResponse)
self.nam.get(req)
def doRequest(self):
url = 'http://webcode.me' # url to receive html from
req = QtNetwork.QNetworkRequest(QUrl(url)) #request instance
self.nam = QtNetwork.QNetworkAccessManager() # create the manager object
self.nam.finished.connect(self.handleResponse) # handle response when requist is finished
self.nam.get(req)
def __init__(self, qtapp):
super().__init__()
self.qtapp = qtapp
self.socket = QtNetwork.QUdpSocket()
self.socket.bind(QtNetwork.QHostAddress(""), 6001)
self.t1 = QtCore.QTimer(qtapp)
self.t1.setInterval(10)
self.t1.timeout.connect(self.sample)
def doRequest(self):
#url = "http://www.google.com"
url = "https://oradocs-corp.documents.us2.oraclecloud.com/documents/"
req = QtNetwork.QNetworkRequest(QUrl(url))
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleResponse)
self.nam.get(req)
def init_tcp(self, is_server, addr):
if is_server:
self.server = QtNetwork.QTcpServer(self)
self.server.listen(QtNetwork.QHostAddress.Any, 8888)
self.server.newConnection.connect(self.start_new_connection)
else:
self.socket = QtNetwork.QTcpSocket(self)
self.socket.connectToHost(QtNetwork.QHostAddress(addr), 8888)
self.socket.readyRead.connect(self.recv)
def startMultiplexer(self, address):
if self.protocol() == 'unix':
self.multiplexer = QtNetwork.QLocalSocket(self)
self.multiplexer.connectToServer(address,
QtCore.QIODevice.WriteOnly)
else:
self.multiplexer = QtNetwork.QTcpSocket(self)
address, port = address.split(':')
self.multiplexer.connectToHost(address, int(port),
QtCore.QIODevice.WriteOnly)
def __init__(self, *args, **kwargs):
QtCore.QObject.__init__(self, *args, **kwargs)
url = QtCore.QUrl("https://www.google.com/")
req = QtNetwork.QNetworkRequest(url)
self.net_manager = QtNetwork.QNetworkAccessManager()
self.res = self.net_manager.get(req)
self.res.finished.connect(self.processRes)
self.res.error.connect(self.processErr)
self.msg = QtWidgets.QMessageBox()
self.sig.
def doRequest(self):
print("dorequest方法执行了")
url = "http://localhost:18080"
# 创建一个请求
req = QtNetwork.QNetworkRequest(QUrl(url))
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleResponse)
# 使用get请求 如果有参数的话 写一个data 放到get里
self.nam.get(req)
def Send_Message(message, HOST="127.0.0.1", PORT=33002):
if message.startswith("{FIELD}"):
message = message.replace("{FIELD}", "")
SOCKET.writeDatagram(message.encode(),
QtNetwork.QHostAddress(HOST), PORT)
Message_Field.setText("")
Message_Field.setFocus()
else:
SOCKET.writeDatagram(message.encode(),
QtNetwork.QHostAddress(HOST), PORT)
def onCookieAdded(self, cookie):
data = {
bytearray(QtNetwork.QNetworkCookie(cookie).name()).decode():
bytearray(QtNetwork.QNetworkCookie(cookie).value()).decode()
}
self.cookies.update(data)
if 'yiban_user_token' in self.cookies:
mainw.tokenLineedit.setText(json.dumps(self.cookies))
self.resetWebview()
self.close()
def autoDetectNetworkInterface(self):
hostAddresses = []
interfaceFlags = QtNetwork.QNetworkInterface.IsUp | \
QtNetwork.QNetworkInterface.IsRunning
# Grab all available interfaces
allInterfaces = QtNetwork.QNetworkInterface.allInterfaces()
for interface in allInterfaces:
if ((interface.flags() & interfaceFlags == interfaceFlags) \
):#and (interface.flags() &
# QtNetwork.QNetworkInterface.IsLoopBack == 0)):
addresses = interface.addressEntries()
for address in addresses:
if (address.ip().protocol() ==
QtNetwork.QAbstractSocket.IPv4Protocol) and \
address.ip() != (
QtNetwork.QHostAddress(
QtNetwork.QHostAddress.LocalHost)):
hostAddresses.append(address.ip())
# If there is more than one host address detected,
# show error dialog
if len(hostAddresses) > 1:
alert = AlertDialog(
"Network Error",
"Could not auto detect network "
"settings")
alert.show()
else: # only one IP address returned, try port 80
testServer = QtNetwork.QTcpServer(self)
# Try to start a QTcpServer at hostAddress:80
# If the server starts, return those values as
# detected values
if testServer.listen(hostAddresses[0], 80):
ipAddress = hostAddresses[0].toString()
# populate server text boxes
self.hostAddressTextBox.setText(ipAddress)
self.hostPortTextBox.setText(str(80))
testServer.close()
else:
# Could not listen at detected IP address and
# port 80. This may be because port 80 is
# being used by another service, so let
# QTcpServer pick the port.
if testServer.listen(hostAddresses[0]):
ipAddress = hostAddresses[0].toString()
port = testServer.serverPort()
# populate server text boxes
self.hostAddressTextBox.setText(ipAddress)
self.hostPortTextBox.setText(str(port))
testServer.close()
else: # Can't auto detect network settings
alert = AlertDialog(
"Network Error", "Could not auto "
"detect network "
"settings")
alert.show()
def makeOWMTestCall(self):
appid = self.owmAPIKey.displayText()
cityID = self.owmCityID.displayText()
units = ww.owm_units.get(self.owmUnit.currentText())
lang = ww.owm_languages.get(self.owmLanguage.currentText())
url = "http://api.openweathermap.org/data/2.5/weather?id=" + cityID + "&units=" + units + "&lang=" + lang + "&appid=" + appid
req = QtNetwork.QNetworkRequest(QUrl(url))
self.nam = QtNetwork.QNetworkAccessManager()
self.nam.finished.connect(self.handleOWMResponse)
self.nam.get(req)
