I want to do reboot testing on one computer (lets call it A) by turning power off and on via a network controlled power outlet by a computer B. I want the computer A to report to a computer B on each boot so that it can keep track of when it succeeded. What is the simplest python setup that can do this?
Here's a simple Python setup that can accomplish what you want:

1. On Computer A, write a Python script that will run on each boot and send a message to Computer B to report its status. The script can use a library like socket or smtplib to send the message over the network.

2. On Computer B, write a Python script that listens for incoming messages from Computer A and records the status updates in a log file or a database.

Here's some example code for Computer A:
```python
import socket

def send_message(message):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((computer_b_ip, 8080))
        s.sendall(message.encode())

send_message(Reboot succeeded)
```

And here's some example code for Computer B:
```python
import socket

def listen_for_messages():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((0.0.0.0, 8080))
        s.listen()
        conn, addr = s.accept()
        with conn:
            while True:
                data = conn.recv(1024)
                if not data:
                    break
                print(Message from, addr, :, data.decode())

listen_for_messages()
```

This is just a starting point. You may want to add error handling, logging, or other features to the code to make it more robust and usable for your specific needs.
Can you explain how the listen_for_messages() function works?
The `listen_for_messages` function uses the `socket` module in Python to create a TCP/IP socket that listens for incoming messages on port 8080 of the IP address `0.0.0.0`. The function uses the `with` statement to ensure that the socket is closed properly, even if an exception occurs.

The function calls `s.bind((0.0.0.0, 8080))` to bind the socket to the specified IP address and port number. The function then calls `s.listen()` to start listening for incoming connections.

When a connection is received, the function calls `s.accept()` to accept the connection and return a new socket object, `conn`, that is connected to the client, along with the client's address, `addr`. The function then enters a `while` loop, where it repeatedly calls `conn.recv(1024)` to receive data from the client.

The `recv` method returns `None` when the connection is closed, so the `if` statement `if not data: break` is used to exit the loop and close the connection when no more data is available. The function then decodes the received data and prints it to the console.