It sounds like you’re running into a common issue when working with sockets in Python. When your client closes the connection using sock.close(), the server does indeed receive an EOF on its recv() call, indicating that the client has disconnected. However, for the socket on the server side to fully transition out of the CLOSE_WAIT state, you need to ensure that you’re properly closing the server’s socket as well.

Here’s what you might want to consider:

• Check your server code: After you detect that the client has closed the connection (you’ll see that when recv() returns an empty bytes object), you should immediately close the server’s socket for that particular client. This is typically done using something like client_socket.close().
• Verify your socket handling: Ensure that your server is not only listening for new connections but also handling existing connections in a way that properly closes sockets. Each client connection should be handled either in a loop or in a separate thread/process, and you should be closing the socket when done with that connection.
• Example of handling disconnections: Here’s a simple example of how you might structure the server side to handle client disconnections:

import socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 12345))
server_socket.listen(5)

while True:
    client_socket, addr = server_socket.accept()
    print(f"Connection from {addr} has been established!")
    
    try:
        while True:
            data = client_socket.recv(1024)
            if not data:
                break  # Client has disconnected
            print("Received:", data)
    finally:
        client_socket.close()  # Close the client socket
        print("Client socket closed.")

In this example, when recv() returns a zero-length byte string, that means the client has disconnected, and the server immediately closes the client_socket.

By ensuring that each connection is properly closed on the server side when you detect a disconnection, you should be able to avoid the CLOSE_WAIT state. Also, keep in mind that the server’s main listening socket remains open if you’re planning to accept more connections, so you only close the individual client sockets.

Finally, make sure to handle any exceptions that might arise, as well as keeping an eye on resource management to prevent leaks. Good luck, and keep experimenting!