Flow

Start a configured flow alongside the main flow. You can send messages as soon as this call returns. At most two background flows can run; they may also start other flows. A name cannot run twice, even while paused or stopping. Invalid or duplicate names, a full background limit, or a flow error stops the entire Run. System.stop() and Main Stop also stop all flows. The main flow waits for background flows before Run finishes: explicitly stop flows that run indefinitely. Starting data is copied using the limits in Flow.send().

Flow.start(name, params=None)

# Start recognition and telemetry beside the main flow
recognition_no = Flow.start("recognition", {"region": "arena", "threshold": 0.86})
telemetry_no = Flow.start("telemetry")

# Inside the configured recognition flow, read this branch's copied input
region_name = Flow.params.get("region", "full_screen")
threshold = Flow.params.get("threshold", 0.8)

Send an independent copy to a running flow without waiting. Messages are safe to send from multiple flows and are received in the order sent, including while paused. Allowed values are None, Boolean, finite numbers, String, list, tuple and dict with String keys. Maximum nesting depth is 8, total values 512 and total text length 65536. Functions, resource or app objects, and circular references cause an error. Each start has a new message queue; stopping or finishing discards unread messages.

Flow.send(name, data)

# Send an ARM command to the configured watcher
Flow.start("watch_enemy")
accepted = Flow.send("watch_enemy", {"command": "ARM"})
print(accepted)

Wait for and remove the oldest message for this flow. The main flow and background flows can receive messages. A nested named group running in the same flow shares that flow’s queue. Cancellation ends the wait promptly; Pause keeps queued messages. Received lists and dicts are independent copies.

Flow.receive(timeout=None)

# Configured watch_enemy flow: wait for ARM, then check commands between work
message = Flow.receive()
if message is not None and message.get("command") == "ARM":
    while True:
        command = Flow.poll()
        if command is not None:
            print(command)
        if Region().find("enemy", timeout=0).found:
            print("enemy")
        wait(100)

Immediately take the oldest message for this flow without waiting. Uses the same message queue and independent copies as Flow.receive().

Flow.poll()

# Check for a command without waiting
message = Flow.poll()
if message is not None:
    print(message)

Check whether the named flow is running or paused. The result may change immediately after the call.

Flow.running(name)

print(Flow.running("watch_enemy"))

Request that one background flow stop; return without waiting for cleanup. The main flow and other flows keep running. This cannot stop the main flow. Stopping yourself ends the calling flow. For a nested named group, stops the background flow that owns it. Wait for cleanup before restarting the same name. Background dock controls provide Pause/Resume. Main Pause/Resume affects all flows; Main Resume also clears their individual pause settings.

Flow.stop(name)

print(Flow.stop("watch_enemy"))