Esta muy viejo mi codigo python cliente-servidor

[feder]

Francisco, hace mas de 20 años que no programo. Algún consejo para este codigo.
Gracias

#serverIP_7.py
import socket
import threading
import mysql.connector
from mysql.connector import errorcode
from itertools import cycle
from tkinter import messagebox
import tkinter as tk

miIPv4= 'xxx.xxx.x.xx'
miBD='miU'
mipass='micontraseña'
Puerto = miPuerto

DB_CONFIG = {
    'user': 'root',
    'password': mipass,
    'host': miIPv4,
    'database': miBD,
}

def manejar_cliente(cliente_socketC):
    try:
        datos_del_entrycliente = cliente_socketC.recv(1024).decode('utf-8')
        #print("datos_del_entrycliente-->", datos_del_entrycliente)
        result = confirmando_rut_en_baseDedatos(datos_del_entrycliente)
        #print("manejar_cliente solo RUT en servidor resul-->", result)
        if len(datos_del_entrycliente) > 0 and len(datos_del_entrycliente) < 13:
            convertir_resultado = '\n'.join(map(str, result))  # Convertir lista a una cadena
            cliente_socketC.send(convertir_resultado.encode('utf-8'))

        elif len(datos_del_entrycliente) > 14:
            AgregarModificarEliminar, *valores_del_entry = datos_del_entrycliente.split(',')
            #print("Los datos llegan al servidor ", datos_del_entrycliente)
            #print("AgregarModificarEliminar servidor ", AgregarModificarEliminar)
            if AgregarModificarEliminar == "Agregar":
                trae_seleccion = agregar_registro(*valores_del_entry)#aqui llegan los datos con*valores_del_entry
            elif AgregarModificarEliminar == "Modificar":
                trae_seleccion = modificar_registro(*valores_del_entry)#aqui llegan los datos con*valores_del_entry
            elif AgregarModificarEliminar == "Eliminar":
                trae_seleccion = eliminar_registro(*valores_del_entry)#aqui llegan los datos con*valores_del_entry
            else:
                trae_seleccion = "Operación no permitida en el servidor "
            convertir_resultado = str(trae_seleccion)
            cliente_socketC.send(convertir_resultado.encode('utf-8'))
        else:
            pass
    finally:
        cliente_socketC.close()

def confirmando_rut_en_baseDedatos(rut):
    try:
        connection = mysql.connector.connect(**DB_CONFIG)
        cursor = connection.cursor()
        query = "SELECT * FROM profesores WHERE rut = %s"
        cursor.execute(query, (rut,))
        resultados=cursor.fetchall()#results
        #print("confirmando_rut_en_baseDedatos servidor resultados-->", resultados)
        if resultados:
            return resultados  # si rut existe
        else:
            return resultados  # si rut incorrecto o no existe en BD
               
    except mysql.connector.Error as err:
        if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
            return "Error: Acceso denegado"
        elif err.errno == errorcode.ER_BAD_DB_ERROR:
            return "Error: base de datos no existe"
        else:
            return f"Error: {err}"
    finally:
        if 'connection' in locals() and connection.is_connected():
            cursor.close()
            connection.close()

def agregar_registro(codigoPro, rut, nombres, apellidos, titulo, direccion, ciudad, email, celular):
    try:
        connection = mysql.connector.connect(**DB_CONFIG)
        cursor = connection.cursor()
        sql = "INSERT INTO profesores (codigoPro, rut, nombres, apellidos, titulo, \
            direccion, ciudad, email, celular) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
        cursor.execute(sql, (codigoPro, rut, nombres, apellidos, titulo, \
            direccion, ciudad, email, celular))
        connection.commit()
        return "Registro agregado correctamente servidor"
    except mysql.connector.Error as err:
        return f"Error al agregar registro servidor: {err}"
    finally:
        if 'conexion servidor' in locals() and connection.is_connected():
            cursor.close()
            connection.close()

def modificar_registro(codigoPro, rut, nuevos_nombres, nuevos_apellidos, nuevo_titulo, \
    nueva_direccion, nueva_ciudad, nuevo_email, nuevo_celular):
    try:
        connection = mysql.connector.connect(**DB_CONFIG)
        cursor = connection.cursor()
        sql = "UPDATE profesores SET nombres = %s, apellidos = %s, titulo = %s, \
            direccion = %s, ciudad = %s, email = %s, celular = %s WHERE codigoPro = %s AND rut = %s"
        cursor.execute(sql, (nuevos_nombres, nuevos_apellidos, nuevo_titulo, \
            nueva_direccion, nueva_ciudad, nuevo_email, nuevo_celular, codigoPro, rut))
        connection.commit()
        return "Registro actualizado correctamente servidor"
    except mysql.connector.Error as err:
        return f"Error al actualizar registro servidor: {err}"
    finally:
        if 'conexion servidor' in locals() and connection.is_connected():
            cursor.close()
            connection.close()

def eliminar_registro(codigoPro, rut):
    try:
        connection = mysql.connector.connect(**DB_CONFIG)
        cursor = connection.cursor()
        sql = "DELETE FROM profesores WHERE codigoPro = %s AND rut = %s"
        cursor.execute(sql, (codigoPro, rut))
        connection.commit()
        if cursor.rowcount > 0:
            return "Registro eliminado correctamente servidor"
        else:
            return "No se encontró ningún registro para eliminar"
    except mysql.connector.Error as err:
        return f"Error al eliminar el registro: {err}"
    finally:
        if 'conexion servidor' in locals() and connection.is_connected():
            cursor.close()
            connection.close()

def ejecutar_servidor():
    servidor_socketS = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    servidor_direccionIPv4 = (miIPv4, Puerto) 
    try:
        servidor_socketS.bind(servidor_direccionIPv4)
        servidor_socketS.listen(8)
        print('Servidor escuchando...')
        while True:
            cliente_socketC, cliente_direccionIPv4 = servidor_socketS.accept()
            print(f'Conexion desde cliente {cliente_direccionIPv4}')
            cliente_manejador = threading.Thread(target=manejar_cliente, args=(cliente_socketC,))
            cliente_manejador.start()
    finally:
        servidor_socketS.close()

if __name__ == '__main__':
    ejecutar_servidor()

############################################################
#clienteIP_7.py
import socket
import tkinter as tk
from tkinter import messagebox
from tkinter import * #label
import threading
from itertools import cycle

Puerto=#miPuerto
miIPv4= 'xxx.xxx.x.xx'

def consultar_rut():
    rut = entry_rut.get()
    def enviar_al_servidor():
        try:
            cliente_socketC = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            servidor_direccionIPv4 = (miIPv4, Puerto)  # Utilice el mismo puerto que el servidor, direccionIPv4
            cliente_socketC.connect(servidor_direccionIPv4)
            cliente_socketC.send(rut.encode('utf-8'))
            resultado2 = cliente_socketC.recv(1024).decode('utf-8')
            #print("enviar al  servidor resultado2-->", resultado2)
            #messagebox.showinfo('Resultado', f'mostrar: {resultado2}')
            registros = resultado2.split('\n')  # Dividir la cadena en una lista de registros
            #print(f'registros-->\n{registros}')
            #print("enviar al  servidor registros-->", registros)
            if registros[0]:   
                campos = registros[0].split(',')#el importante
                limpiar=campos[0].strip("()' ")
                entry0.delete(0, tk.END) 
                entry0.insert(0, limpiar)
                limpiar=campos[1].strip("()' ")
                entry1.delete(0, tk.END) 
                entry1.insert(0, limpiar)
                limpiar=campos[2].strip("()' ")
                entry2.delete(0, tk.END) 
                entry2.insert(0, limpiar)
                limpiar=campos[3].strip("()' ")
                entry3.delete(0, tk.END) 
                entry3.insert(0, limpiar)
                limpiar=campos[4].strip("()' ")
                entry4.delete(0, tk.END) 
                entry4.insert(0, limpiar)
                limpiar=campos[5].strip("()' ")
                entry5.delete(0, tk.END) 
                entry5.insert(0, limpiar)
                limpiar=campos[6].strip("()' ")
                entry6.delete(0, tk.END) 
                entry6.insert(0, limpiar)
                limpiar=campos[7].strip("()' ")
                entry7.delete(0, tk.END) 
                entry7.insert(0, limpiar)
                limpiar=campos[8].strip("()' ")
                entry8.delete(0, tk.END) 
                entry8.insert(0, limpiar)
            else:
                messagebox.showinfo("Resultado de consulta", "RUT no encontrado o mal digitado")
        finally:
            cliente_socketC.close()
    threading.Thread(target=enviar_al_servidor).start()

def enviar_entrys(losDatos):
    servidor_direccionIPv4 = (miIPv4, Puerto)
    cliente_socketC = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    try:
        cliente_socketC.connect(servidor_direccionIPv4)
        cliente_socketC.send(losDatos.encode('utf-8'))
        resultado2 = cliente_socketC.recv(1024).decode('utf-8')
        #print("los datos cliente-->", losDatos)
        #print("el resultado2 cliente--> ", resultado2)
        return resultado2
    finally:
        cliente_socketC.close()

def operacion_seleccionada(valores_del_entry, operacion):
    #print("valores_del_entry cliente-->", valores_del_entry)
    #print("operacion cliente Agregar, Modificar, Eliminar-->", operacion)
    losDatos = f"{operacion},{','.join(valores_del_entry)}"
    #print("operacion_seleccionada losDatos cliente-->", losDatos)
    # Send the formatted losDatos to the servidor
    resultado2 = enviar_entrys(losDatos)
    #print("operacion_seleccionada resultado2 cliente-->", resultado2)
    messagebox.showinfo(f"{operacion.capitalize()} resultado", resultado2)

if __name__ == '__main__':
    root = tk.Tk()
    root.title("Cliente")
    root.geometry('750x600')

    codigoPro=StringVar()
    rut=StringVar()
    nombres=StringVar()
    apellidos=StringVar()
    titulo=StringVar()
    direccion=StringVar()
    ciudad=StringVar()
    email=StringVar()
    celular=StringVar()

    nuevos_nombres=StringVar()
    nuevos_apellidos=StringVar()
    nuevo_titulo=StringVar()
    nueva_direccion=StringVar()
    nueva_ciudad=StringVar()
    nuevo_email=StringVar()
    nuevo_celular=StringVar()
   
    nuevos_nombres=nombres
    nuevos_apellidos=apellidos
    nuevo_titulo=titulo
    nueva_direccion=direccion
    nueva_ciudad=ciudad
    nuevo_email=email
    nuevo_celular=celular
   
    label_rut = Label(root, text='Consulta RUT:')
    label_rut.grid(column=0, row=0, padx=5, pady=5)
    entry_rut = Entry(root)
    entry_rut.grid(column=1, row=0, padx=5, pady=5)

    label0=tk.Label(root, text='CodigoPro:')
    label0.grid(column=0, row=2, padx=5, pady=5)
    entry0 = tk.Entry(root, width=30, textvariable=codigoPro)
    entry0.grid(column=1, row=2, padx=5, pady=5)

    label1=tk.Label(root, text='RUT:')
    label1.grid(column=0, row=3, padx=5, pady=5)
    entry1 = tk.Entry(root, width=30, textvariable=rut)
    entry1.grid(column=1, row=3, padx=5, pady=5)

    label2=Label(root, text='Nombres:')
    label2.grid(column=0, row=4, padx=5, pady=5)
    entry2 = Entry(root, width=30, textvariable=nombres)
    entry2.grid(column=1, row=4, padx=5, pady=5)

    label3=tk.Label(root, text='Apellidos:')
    label3.grid(column=0, row=5, padx=5, pady=5)
    entry3 = tk.Entry(root, width=30, textvariable=apellidos)
    entry3.grid(column=1, row=5, padx=5, pady=5)

    label4=tk.Label(root, text='Titulo:')
    label4.grid(column=0, row=6, padx=5, pady=5)
    entry4 = tk.Entry(root, width=30, textvariable=titulo)
    entry4.grid(column=1, row=6, padx=5, pady=5)

    label5=tk.Label(root, text='Dirección:')
    label5.grid(column=0, row=7, padx=5, pady=5)
    entry5 = tk.Entry(root, width=30, textvariable=direccion)
    entry5.grid(column=1, row=7, padx=5, pady=5)

    label6=tk.Label(root, text='Ciudad:')
    label6.grid(column=0, row=8, padx=5, pady=5)
    entry6 = tk.Entry(root, width=30, textvariable=ciudad)
    entry6.grid(column=1, row=8, padx=5, pady=5)

    label7=tk.Label(root, text='Email:')
    label7.grid(column=0, row=9, padx=5, pady=5)
    entry7 = tk.Entry(root, width=30, textvariable=email)
    entry7.grid(column=1, row=9, padx=5, pady=5)

    label8=tk.Label(root, text='Celular:')
    label8.grid(column=0, row=10, padx=5, pady=5)
    entry8 = tk.Entry(root, width=30, textvariable=celular)
    entry8.grid(column=1, row=10, padx=5, pady=5)

    boton_consultar = Button(root, text='consultar RUT', command=consultar_rut)
    boton_consultar.grid(column=2, row=0, padx=5, pady=5)   

    boton_Agregar=tk.Button(root, text="Agregar", command=lambda: operacion_seleccionada\
    ([codigoPro.get(), rut.get(), nombres.get(), apellidos.get(), titulo.get(), \
    direccion.get(), ciudad.get(), email.get(), celular.get()], "Agregar"))
    boton_Agregar.place(x=20,y=350,width=70,heigh=25)


    boton_Modificar = tk.Button(root, text="Modificar", command=lambda: operacion_seleccionada\
    ([codigoPro.get(), rut.get(), nuevos_nombres.get(), nuevos_apellidos.get(), nuevo_titulo.get(), \
    nueva_direccion.get(), nueva_ciudad.get(), nuevo_email.get(), nuevo_celular.get()], "Modificar"))
    boton_Modificar.place(x=100,y=350,width=70,heigh=25)

    boton_Eliminar = tk.Button(root, text="Eliminar", command=lambda: operacion_seleccionada\
    ([codigoPro.get(), rut.get()], "Eliminar"))
    boton_Eliminar.place(x=180, y=350, width=70, height=25)

    boton_limpiar = tk.Button(root, text="Limpiar Campos", command=lambda: limpiar_entries(root))
    boton_limpiar.place(x=260, y=350, width=100, height=25)

    def limpiar_entries(self):
        entry_rut.delete(0, tk.END)
        entry0.delete(0, tk.END)
        entry1.delete(0, tk.END)
        entry2.delete(0, tk.END)
        entry3.delete(0, tk.END)
        entry4.delete(0, tk.END)   
        entry5.delete(0, tk.END)
        entry6.delete(0, tk.END)
        entry7.delete(0, tk.END)
        entry8.delete(0, tk.END)   
       
    root.mainloop()

[feder]

Hola, francisco estoy retomando Python:
tengo el código de serverIP_7.py(que usa la tabla profesores) y luego tengo el código de
clienteIP_7.py (que usa la tabla profesores).

Pretendo hacer el código de serverIP_8.py(que usa la tabla8)
y hacer el código para clienteIP_8 (que usa la tabla8).

Pretendo hacer el código de serverIP_9.py(que usa la tabla9)
y luego hacer el código clienteIP_9.py (que usa la tabla9)

Pregunta, como hago sólo un código serverIP.py que escuche a los
clientesIP(clienteIP_7.py, clienteIP_8.py, cliente_9.py) que estarán
todos integrados en uno solo .py, con su respectivo menu que llamará
a cada clienteIP_7, clienteIP_8, clienteIP_9.

Porque todos llgarán al primer código que es este.

def manejar_cliente(cliente_socketC):
if __name__ == '__main__':
ejecutar_servidor()

Y no saltarán al código que les corresponde (en este caso serverIP_8 y tabla8.
serverIP_9 y tabla9), que estarán integrados en un sólo serverIP.py

[Costero]

Uno de los valores que pasas del cliente al servidor puede ser la accion que quieres hacer.
Entonces el servidor leer ese valor especial para saber si debe de llamar la function que trabaja con la tabla profesor, o tabla8, etc.

El codigo en el servidor seria algo asi:

Código:

def confirmando_rut_en_baseDedatos(rut):
    print(f"Got profesor id: {rut}")
    # Aqui creates to SQL, etc...


def agregar_registro(codigoPro, rut, nombres, apellidos, titulo, direccion, ciudad, email, celular):
    print(f"Nombres: {nombres}")


def tabla8(name, age):
    print(f"The person age is {age} and name is {name}")
    # sql a la tabla8
    return "Ok"


funcs = {
    "profesor": confirmando_rut_en_baseDedatos,
    "tabla8": tabla8,
    "agregar_registro": agregar_registro
}

# Los valores keys del dictionary vendrian del cliente ...
funcs["profesor"]("123")

funcs["agregar_registro"]("cod_123", 123, "Muchos nombres", "apellidos",
                          "titulo", "direccion", "ciudad", "email", "celular")

result = funcs["tabla8"]("William", 24)
print(result)

Alguna razon por que utilzas sockets?. Por que no un web servidor como FastAPI o Flask?. Simplificaria to codigo.