QtPyNetwork

QtPyNetwork is a small abstraction layer for sending and receiving messages using TCP sockets.

Check out the complete documentation.

Server

Each server has its own balancer.

Servers:

• TCPServer - listen for TCP connections

Balancers:

• NoBalancer - sockets are stored in main thread
• ThreadBalancer - each socket lives in its own thread, which is created dynamically
• ThreadPoolBalancer - constant amount of threads, new sockets are created in threads with least load

Client

• TCPClient
• ThreadedTCPClient

Usage

See examples directory for client and server code samples.

TCP Client

from qtpy.QtWidgets import QApplication
from qtpy.QtCore import QObject, Slot, QCoreApplication, qInstallMessageHandler

import sys
import logging

from QtPyNetwork.client import TCPClient

IP = "127.0.0.1"
PORT = 12500


class Main(QObject):

    def __init__(self):
        super(Main, self).__init__(None)
        self.logger = logging.getLogger(self.__class__.__name__)

        self.client = TCPClient()
        self.client.message.connect(self.on_message)
        self.client.connected.connect(self.on_connected)
        self.client.failed_to_connect.connect(self.on_failed_to_connect)
        self.client.disconnected.connect(self.close)

    @Slot()
    def start(self):
        self.client.start(IP, PORT)

    @Slot(str, int)
    def on_connected(self, ip: str, port: int):
        self.logger.info(f"Connected to {ip}:{port}")
        self.client.write(b"Kick me plz")

    @Slot(bytes)
    def on_message(self, data: bytes):
        self.logger.info(f"Received: {data}")

    @Slot()
    def on_failed_to_connect(self):
        self.logger.error("Failed to connect")

    @Slot()
    def close(self):
        self.client.close()
        QApplication.instance().quit()


if __name__ == '__main__':
    logging.basicConfig(
        level=logging.NOTSET,
        format="%(asctime)s [%(threadName)s] [%(name)s] [%(levelname)s] %(message)s",
        handlers=[logging.StreamHandler()])
    logging.getLogger().debug("Logger enabled")

    app = QCoreApplication(sys.argv)
    main = Main()
    main.start()
    sys.exit(app.exec_())

TCPServer + ThreadPoolBalancer

from qtpy.QtWidgets import QApplication
from qtpy.QtCore import QObject, Slot, QCoreApplication

import sys
import logging
import traceback

from QtPyNetwork.server import TCPServer
from QtPyNetwork.balancer import ThreadPoolBalancer
from QtPyNetwork.models import Client

IP = "127.0.0.1"
PORT = 12500


class Main(QObject):

    def __init__(self):
        super(Main, self).__init__(None)
        self.logger = logging.getLogger(self.__class__.__name__)
        # declare server using ThreadPoolBalancer
        self.server = TCPServer(ThreadPoolBalancer(threads=8))
        # connect signals
        self.server.connected.connect(lambda client, ip, port: client.write(b"Some important data"))
        self.server.disconnected.connect(self.on_disconnected)
        self.server.message.connect(self.on_message)

    @Slot()
    def setup(self):
        # start server
        self.server.start(IP, PORT)

    @Slot(Client, bytes)
    def on_message(self, client: Client, message: bytes):
        # this code will be run everyu time client sends data
        self.logger.info("Received {}: {}".format(client.id(), message))
        if message.decode() == "Kick me plz":
            client.disconnect()

    @Slot(Client)
    def on_disconnected(self, client: Client):
        # do some actions when client disconnects form server
        self.logger.info("Disconnected: {}; Connected: {}".format(client.id(), client.is_connected()))
        self.close()

    @Slot()
    def close(self):
        self.server.close()
        while self.server.is_running():
            self.server.wait()
        QApplication.instance().quit()