Salut, je travaille sur un exercice, voici l’énoncé de l'exercice :

Vous êtes nouvellement embauché dans une banque pour mettre au point le système de commu-
nication entre les distributeurs automatiques et le système central de gestion des comptes. Votre
travail est de développer les applications sur ces deux systèmes pour permettre aux distributeurs de
communiquer avec le système central pour effectuer les transactions.

On souhaite créer une base de données SQLite3 stockant les soldes des comptes, les informations
les concernant, ainsi que les transactions effectuées. On utilisera un serveur de socket pour effectuer
les communications entre les deux systèmes. Voici les différents messages pris en charge avec (C→S)
un message du client vers le serveur et (S→C) un message du serveur vers le client :
— TESTPIN numeroCompte codePIN (C→S) : Vérifier si le code PIN saisi est correct.
— TESTPIN OK (S→C) : La vérification du code PIN est validée.

— TESTPIN NOK (S→C) : La vérification du code PIN n’est pas valide.
— RETRAIT numeroCompte montant (C→S) : Demande un retrait du montant défini.
— RETRAIT OK (S→C) : Le retrait est validé.
— RETRAIT NOK (S→C) : Le retrait est refusé.
— DEPOT numeroCompte montant (C→S) : Demande un dépôt du montant défini.
— DEPOT OK (S→C) : Le dépôt est validé.
— TRANSFERT numeroCompteSource numeroCompteDestination montant (C→S) : Demande
un transfert du montant défini entre deux comptes.
— TRANSFERT OK (S→C) : Le transfert est validé.
— TRANSFERT NOK (S→C) : Le transfert est refusé.
— SOLDE numeroCompte (C→S) : Demande le solde du compte
— SOLDE solde (S→C) : Renvoie le solde du compte demandé
— HISTORIQUE numeroCompte (C→S) : Demande les 10 dernières opérations du compte
— HISTORIQUE operationsEnCSV (S→C) : Renvoie les 10 dernières opérations du compte au
format CSV (date, libellé, montant déposé ou retiré).
— ERROPERATION (S→C) : Signale que l’opération demandée n’est pas valide

j'ai dejà écrit le programme du serveur central et bricoler pour le distributeur histoire de voir si sa fonctionne vraiment, mais j'obtiens du n'importe quoi. voici le code du serveur central :
Code HTML:
import os
import sqlite3
import socket
import select
 
# ---------------------------- Definition des fonctions -----------------------
 
def connexion_base_de_donnee() :
    """
    Fonction permettant la connexion à une base de donnée.
 
    Returns
    -------
    connexion_base : INSTANCE DE CLASSE
        DESCRIPTION : permet la connection, la déconnexion et l'envoie des
                      données dans la base selectionée.
    curseur : INSTANCE DE CLASSE.
        DESCRIPTION : stocke les requêtes SQL avant l'envoit'
 
    """
     
    connexion_base = sqlite3.connect('python_bank.db')
    curseur = connexion_base.cursor()
    return connexion_base, curseur
 
 
def test_pin (numero_compte, pin_user) :
    """
    Fonction permettant de vérifier le code pin de l'utilisateur.
 
    Parameters
    ----------
    numero_compte : INT.
        DESCRIPTION :numero du client qui veut se connecter.
    pin_user : INT
        DESCRIPTION : code pin donnant accès aux opérations de la python_bank.
 
    Returns
    -------
    bool
        DESCRIPTION : True si le pin est correct et faut s'il est incorrect'
 
    """
     
    connexion_base, curseur = connexion_base_de_donnee()
    curseur.execute("SELECT pin FROM compte WHERE id_compte = ?", \
                    (numero_compte,))
    pin_compte = curseur.fetchone()
    connexion_base.close()
     
    if pin_compte == pin_user :
        return True
    else :
        return False
   
     
def solde (numero_compte) :
    """
    Fonction permettant d'obtenir le solde d'un client.
 
    Parameters
    ----------
    numero_compte : INT
        DESCRIPTION : numero permettant la vérification du solde.
 
    Returns
    -------
    solde_compte
        DESCRIPTION renvoi le solde du client.
 
    """
     
    connexion_base, curseur = connexion_base_de_donnee()
    curseur.execute("SELECT solde FROM compte WHERE id_compte = ?", \
                    (numero_compte))
    solde_compte = curseur.fetchone() [0]
    connexion_base.close()
    return solde_compte
 
 
def depot (numero_compte, montants) :
    """
    Fonctioneffectuant un depôt dans un compte donné.
 
    Parameters
    ----------
    numero_compte : INT.
        DESCRIPTION : numero_de_compte du client.
    montants : FLOAT.
        DESCRIPTION : montant du depôt.
 
    Returns
    -------
    bool
        DESCRIPTION : renvoie True si tout c'est bien passé'
 
    """
     
    connexion_base, curseur = connexion_base_de_donnee()
    montants = float(montants)
    mon_solde = solde(numero_compte)
    mon_solde = float(mon_solde)
    nouveau_solde = montants + mon_solde
    curseur.execute("UPDATE compte SET solde = ? WHERE id_compte = ?", \
                    (nouveau_solde, numero_compte))
    curseur.execute("INSERT INTO operation (date_operation, libelle_operation,\
                    montant) VALUES(DATE('NOW'), ?, ?)", (numero_compte,\
        "DEPOT", montants))
     
    connexion_base.commit()
    connexion_base.close()
    return True
 
     
def retrait (numero_compte, montant) :
    """
    Fonction permettant d'effectuer un retrait dans son compte.
 
    Parameters
    ----------
    numero_compte : INT.
        DESCRIPTION : numero de compte du client.
    montant : INT.
        DESCRIPTION : montant du retrait
 
    Returns
    -------
    bool
        DESCRIPTION : True ou False si l'opération c'est bien passé ou pas.
 
    """
     
    connexion_base, curseur = connexion_base_de_donnee()
    solde_actuel = solde(numero_compte)
    solde_actuel = float(solde_actuel)
     
    if solde_actuel >= montant :
        solde_apres_retrait = solde_actuel - montant
        curseur.execute("UPDATE compte SET solde = ? WHERE id_compte = ?",\
                        (solde_apres_retrait, numero_compte))
        curseur.execute("INSERT INTO operation (date_operation, \
                        libelle_operation, montant) VALUES(DATE('NOW')",\
                                        numero_compte, "RETRAIT", montant)
        connexion_base.commit()
        return True
    else :
        connexion_base.close()
        return False
     
    connexion_base.close()
     
 
 
def transfert (numero_compte, numero_compte_a_transferer, montant) :
    """
    Fonction effectuant un transfert d'un compte donné à un autre.
 
    Parameters
    ----------
    numero_compte : INT.
        DESCRIPTION : numero de compte du client de base.
    numero_compte_a_transferer : TYPE : INT.
        DESCRIPTION : numero de compte du client à qui est destiné le transfert.
    montant : FLOAT.
        DESCRIPTION : montant du transfert.
 
    Returns
    -------
    Bool : True
 
    """         
     
    connexion_base, curseur = connexion_base_de_donnee()
    solde_envoyeur = solde(numero_compte)
    solde_envoyeur = float(solde_envoyeur)
     
    if montant <= solde_envoyeur :
        nouveau_solde_envoyeur = solde_envoyeur - montant
        curseur.execute("UPDATE compte SET solde = ? WHERE id_compte = ?",\
                        (nouveau_solde_envoyeur, numero_compte))
             
        solde_recepteur = solde(numero_compte_a_transferer)
        solde_recepteur = float(solde_recepteur)
        nouveau_solde_recepteur = solde_recepteur + montant
        curseur.execute("UPDATE compte SET solde = ? WHERE id_compte = ?",\
                        (nouveau_solde_recepteur, numero_compte_a_transferer))
             
        curseur.execute("INSERT INTO operation (date_operation, \
                        libelle_operation, montant) VALUES(DATE('NOW')",\
                                        numero_compte, "TRANSFERT", montant)
         
        connexion_base.commit()
        return True
    else :
        connexion_base.close()
        return False
     
    connexion_base.close()
 
 
def historique(numero_compte) :
     
    connexion_base, curseur = connexion_base_de_donnee()
    curseur.execute("SELECT * FROM operation WHERE id_client = ? LIMIT 10")
    historique_operation = curseur.fetchall()
     
    connexion_base.commit()
    connexion_base.close()
     
    return historique_operation
 
 
# ---------------------- Etablissement de la connexion ------------------------
 
# On travaille avec le module select
 
PORT = 12800
 
serveur = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serveur.bind(('', PORT))
serveur.listen()
print(f'Le serveur écoute à présent sur le port {PORT}')
 
serveur_lance = b""
clients_connectes = []
 
while serveur_lance != b"fin" :
    connexion_demande, wlist, xlist = select.select([serveur], [], [], 0.05)
     
    for connexion in connexion_demande :
        connexion_avec_client, infos_client = connexion.accept()
        clients_connectes.append(connexion_avec_client)
     
    client_a_lire = []
     
    try :
        client_a_lire, wlist, xlist = select.select(clients_connectes, [], \
                                                    [], 0.05)
    except select.error :
        pass
    else :
        for client in client_a_lire :
            message = client.recv(1024)
            message = message.decode("utf-8")
            message2 = client.recv(1024)
            message2 = message2.decode()
            message3 = client.recv(1024)
            message3 = message2.decode()
             
            if message == 1:
                pin_user = test_pin(message2, message3)
                 
                if pin_user :
                    client.send("TESTPIN OK")
                    client.encode("utf-8")
                else :
                    client.send("BAD PIN")
                    client.encode("utf-8")
                     
                message = client.recv(1024)
                message = message.decode("utf-8")
                 
                if message[0] == "DEPOT" :
                    depot_user = depot(message[1], message[2])
                     
                    if depot_user :
                        client.send("DEPOT OK")
                        client.encode("utf-8")
                    else :
                        client.send("DEPOT NOK")
                                                 
                elif message[0] == "RETRAIT" :
                    retrait_user = retrait(message[1], message[2])
                     
                    if retrait :
                        client.send("RETRAIT OK")
                        client.encode("utf-8")
                    else :
                        client.send("RETRAIT NOK")
                        client.encode("utf-8")                                                     
                elif message[0] == "TRANSFERT" :
                    transfert_user = transfert(message[1], message[2], message\
                                               [3])
                    if transfert_user :
                        client.send("TRANSFERT OK")
                        client.encode("utf-8")
                    else :
                        client.send("TRANSFERT NOK")
                        client.encode("utf-8")
                elif message[0] == "SOLDE" :
                    solde_client = solde(message[1])
                         
                    if solde_client :
                        client.send("SOLDE : " + str(solde_client))
                        client.encode("utf-8")
                    else :
                        client.send(b"OPERAION ERROR")
                        client.encode("utf-8")
                elif message[0] == "HISTORIQUE" :
                    historique_client = historique(message[1])
                     
                    if historique_client :
                        client.send("HISTORIQUE :" + str(historique_client))
                        client.encode("utf-8")
                    else :
                        client.send("OPERATION ERROR")
                        client.encode("utf-8")
            else :
                client.send(b"OPERATION FAILED")
                 
             
 
print('Fermeture des connexions')
for clients in clients_connectes :
    clients.close()
 
serveur.close()


et voici celui du client. il n'est pas terminer :

Code HTML:
import os
import socket
 
hote = "localhost"
 
port = 12800
 
 
connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
connexion.connect((hote, port))
 
print("Connexion établie avec le serveur sur le port {}".format(port))
 
 
msg_a_envoyer = b""
 
while msg_a_envoyer != b"fin":
 
    pin = input(">")
    nocompte = input(">")
    msg = input(">")
 
    connexion.send(pin)
    connexion.encode("utf-8")
    connexion.send(nocompte)
    connexion.encode()
    connexion.send(msg)
    connexion.encode()
     
    reponse = connexion.recv(1024)
    print(reponse)
print("Fermeture de la connexion")
 
connexion.close()
 
os.system("pause")