Serveur de chat

import socket
import sys
import threading
import select

_HOST = '127.0.0.1'
_PORT = 4567
_BUFFER = 1024
_RUNNING = True
_USERS = []

print('/--------- HAXOR CHAT SERVER ----------')


class Server(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.host = socket.gethostbyname(_HOST)
        self.port = int(_PORT)
        self.buffer = _BUFFER
        self.run = _RUNNING
        self.users = _USERS
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    def broadcast_data(self, sock, data):
        for sockt in self.users:
            if sockt != self.sock and sockt != sock:
                try:
                    sockt.send(data.encode())
                except:
                    sockt.close()
                    self.users.remove(sockt)

    def main(self):
        try:
            self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.sock.bind((self.host, self.port))
            self.sock.listen(10)
            self.users.append(self.sock)
        except socket.error:
            print('Unable to connect ot the remote host: {0}'.format(self.host))
            sys.exit()
        print('Chat server started on port: ' + str(self.port) + '\r')

        while 1:

            read_sockets, write_sockets, in_error = select.select(self.users, [], [])

            for sockp in read_sockets:
                if sockp == self.sock:

                    sockfd, addr = self.sock.accept()
                    self.users.append(sockfd)
                    print('Client ({0}) connected\n'.format(addr))
                    self.broadcast_data(sockfd, '[{0}] entered the chatroom\n'.format(addr))

                else:

                    try:
                        data = sockp.recv(self.buffer).decode()
                        if data:
                            print('\r' + str(sockp.getpeername()) + data)
                            self.broadcast_data(sockp, '\r' + '(' + str(sockp.getpeername()) + ')' + data)
                    except socket.error:
                        self.broadcast_data(sockp, 'Client({0}) is offline\n'.format(addr))
                        print('Client({0}) is offline\n'.format(addr))
                        sockp.close()
                        try:
                            self.users.remove(sockp)
                        except socket.error:
                            print('\r')
                            continue
                        continue
        self.sock.close()

if __name__ == '__main__':
    server = Server()
    server.main()

import sqlite3
import sys
import socket
import select
import hashlib

if len(sys.argv) < 3:
    print('[usage] python client.py <hostname> <port> <nickname>')
    sys.exit()

HOST = str(sys.argv[1])
PORT = int(sys.argv[2])
USERNAME = str(sys.argv[3])
PASSWORD = hashlib.md5(sys.argv[4].encode()).hexdigest()

conn = sqlite3.connect('users_database')
cursor = conn.cursor()

cursor.execute('SELECT username FROM users')
c = cursor.fetchall()
print(c)


class Client:
    def __init__(self):
        self.host = HOST
        self.port = PORT
        self.run = True
        self.buff = 1024
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.settimeout(2)

    def prompt(self):
        sys.stdout.write('<you> ')
        sys.stdout.flush()

    def main(self):
        try:
            self.sock.connect((self.host, self.port))
        except socket.error:
            print('Unable to connect to the remote host: {0}'.format(self.host))
            sys.exit()

        print('connected to the remote host. Start sending messages')
        self.prompt()

        while 1:
            rlist = [sys.stdin, self.sock]

            read_list, write_list, error_list = select.select(rlist, [], [])

            for sock in read_list:

                if sock == self.sock:
                    data = self.sock.recv(self.buff).decode()
                    if not data:
                        print('\nDisconnected from chat server')
                        sys.exit()
                    if data:
                        sys.stdout.write(data)
                        self.prompt()
                else:
                    data = sys.stdin.readline()
                    self.sock.send(data.encode())
                    self.prompt()

if __name__ == '__main__':
    client = Client()
    client.main()

import sqlite3
import hashlib
import sys

conn = sqlite3.connect('database.db')
cursor = conn.cursor()

if len(sys.argv) < 3:
    print('[Usage] python manager.py <username> <password>')
    sys.exit()

USERNAME = sys.argv[1]
PASSWORD = hashlib.md5(sys.argv[2].encode()).hexdigest()


class Register:
    def __init__(self):
        self.user = USERNAME
        self.password = PASSWORD
        self.conn = sqlite3.connect('users_database')
        self.cursor = self.conn.cursor()

    def checker(self, username, password):
        with self.conn:
            try:
                self.cursor.execute('CREATE TABLE IF NOT EXISTS users '
                                    '(username TEXT NOT NULL UNIQUE,'
                                    ' password TEXT NOT NULL)')
                data = (username, password)
                self.cursor.execute('INSERT INTO users VALUES(?, ?)', data)
                self.cursor.execute('SELECT * FROM users')
                c = self.cursor.fetchall()
                print(c)
            except sqlite3.IntegrityError:
                print('This username already exists choose another one please...')
                sys.exit()

    def main(self):
        self.checker(self.user, self.password)

if __name__ == '__main__':
    register = Register()
    register.main()