Why does the Python Socket program stop working when converted to an exe file?

I have written an online chess app, using Python and Sockets. When I run the server and connect the clients, everything runs perfectly smooth. However, when I convert the client into an exe file and run it, the client isn't able to connect to the server anymore.

I have also tried to convert the server into an executable and it stopped working either. I think it has problems with the command server.listen(), because the ouput is only [STARTING] Server is starting... (More details in the server side code below)

Has anybody encountered problems too, when converting a socket app into an exe file? I didn't get any results with a Google search.

Shortened client side code:

import socket

HEADER = 64
PORT = 5050
FORMAT = 'utf-8'
DISCONNECT_MESSAGE = "!DISCONNECT"
NONE_MESSAGE = "!NONE"
OPPONENT_DISCONNECTED = "!OPPONENT_DISCONNECTED"
SERVER = "192.168.56.1"
ADDR = (SERVER, PORT)


def send(client, msg):
    message = msg.encode(FORMAT)
    msg_length = len(message)
    send_length = str(msg_length).encode(FORMAT)
    send_length += b' ' * (HEADER - len(send_length))
    client.send(send_length)
    client.send(message)


def recieve(client):
    send(client, NONE_MESSAGE)
    msg_length = client.recv(HEADER).decode(FORMAT)
    if msg_length:
        msg_length = int(msg_length)
        msg = client.recv(msg_length).decode(FORMAT)
        if msg != NONE_MESSAGE:
            return msg
    return False

Server side code:

import socket
import threading
import random

HEADER = 64
PORT = 5050
SERVER = socket.gethostbyname(socket.gethostname())
ADDR = (SERVER, PORT)
FORMAT = 'utf-8'
DISCONNECT_MESSAGE = "!DISCONNECT"
NONE_MESSAGE = "!NONE"
OPPONENT_DISCONNECTED = "!OPPONENT_DISCONNECTED"

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(ADDR)


def recieve(conn):
    send(conn, NONE_MESSAGE)
    msg_length = conn.recv(HEADER).decode(FORMAT)
    if msg_length:
        msg_length = int(msg_length)
        msg = conn.recv(msg_length).decode(FORMAT)
        if msg != NONE_MESSAGE:
            return msg
    return False


def send(conn, msg):
    message = msg.encode(FORMAT)
    msg_length = len(message)
    send_length = str(msg_length).encode(FORMAT)
    send_length += b' ' * (HEADER - len(send_length))
    conn.send(send_length)
    conn.send(message)


def get_opponent(addr):
    for c1, c2 in client_pairs:
        if c1 == addr:
            return c2
        if c2 == addr:
            return c1
    return None


def handle_client(conn, addr):
    global new_client
    global new_client_name
    name = recieve(conn)
    if new_client:
        print(f"[NEW CONNECTION] {addr} connected to {new_client}")
        client_pairs.append((new_client, addr))
        color = random.choice(['w', 'b'])
        send(conn, color+new_client_name)
        if color == 'w':
            messages_to_send[new_client] = 'b'+name
        else:
            messages_to_send[new_client] = 'w'+name
        new_client = None
        new_client_name = None
    else:
        new_client_name = name
        new_client = addr
        print(f"[NEW CONNECTION] {addr} waiting")

    connected = True
    while connected:
        if addr in messages_to_send.keys():
            send(conn, messages_to_send[addr])
            del messages_to_send[addr]
        if addr in disconnects:
            send(conn, OPPONENT_DISCONNECTED)
            disconnects.remove(addr)
        msg = recieve(conn)
        if msg:
            if msg == DISCONNECT_MESSAGE:
                if new_client == addr:
                    new_client = None
                opponent = get_opponent(addr)
                if opponent:
                    disconnects.append(opponent)
                connected = False
            opponent = get_opponent(addr)
            if opponent:
                messages_to_send[opponent] = msg
            print(f"[{addr}] {msg}")

    conn.close()


new_client = None
new_client_name = None
messages_to_send = {}
client_pairs = []
disconnects = []


def start():
    server.listen()
    print(f"[LISTENING] Server is listening on {SERVER}")
    while True:
        conn, addr = server.accept()
        thread = threading.Thread(target=handle_client, args=(conn, addr))
        thread.start()
        print(f"[ACTIVE CONNECTIONS] {threading.activeCount()-1}")


print("[STARTING] Server is starting...")
start()