If I request a SysEx dump but the intended instrument is turned off the program keeps waiting endlessly. Is there a way to avoid it?

[DanGylez]

Code looks like this:

# SEND dump request
self.msg_send(message)    # this is a method I wrote that just sends messages thru the currently active port

# CATCH answer
with md.open_input(self.cur_in_port) as port:    # .cur_in_port is the currently active input port saved as a Class attribute
     message = port.receive()

I tried with port.poll() which 'will return None immediately if no message is available' according to the docs, but the result is the same.

[rdoursenaud]

I edited your message slightly to enable syntax highlighting.

When opening a port using the with statement, you have to enumerate the messages from the port.
No need for receive() nor poll():

with mido.open_input() as port:
    for message in port:
        # do something with each "message"

Tangentially, know that receive() is blocking by default (waiting for a message).
You can use receive(block=False) or poll() but you may run into the opposite issue if the instrument takes some time to respond.

The best way to avoid these blocking issues altogether and my personal favorite is to pass a callback function to the port instead.
The function will then be called asynchronously upon incoming messages.

Hope it helps you reach your synthesizer collection control goal ;)
Feel free to ask anything, I’ll be glad to help.

[DanGylez]

I've got the worse of two worlds: I'm an old person, AND a very inexperienced programmer, ha ha ha. So, the 'callback function' concept is kinda obscure and esoteric to me. Nevertheless, I'm very grateful for the recomendation and more than willing to give it a serious try. Still, if you have anything in the way of a written example —additional to the code indluded in the docs— it'll be also deeply appreciated, my man. Thanks!

[rdoursenaud]

Sure, it’s pretty simple really:

def handle_received_message(message):
    # Do what you have to do with the received message.
    # For example, let’s print it:
    print(message)

input = mido.open_input("portname", callback=handle_received_message)
# From now on, upon receiving a message, mido will call the handle_received_message function
# and pass it the received message.

# Of course you need to wait for the messages to arrive.
# You won’t receive anything if your application exits here.
while True:
    # Usually it’s the main loop of the application that’s running there.
    # If you use a GUI framework, you can use the provided one.
    pass

# Don’t forget to close the port(s) when you’re finished.
input.close()

The only thing to keep in mind is that the handle_received_message is running alongside your main loop.

If you want to learn by example, you may want to read parts of my - shameless plug - midiexplorer application especially the ports handling.
There I combine the callback with a queue for handling messages later in the main loop and avoid synchronization issues. I also wrap mido ports into a thin wrapper class to help with keeping track of the sources and configuration.
This may however be a bit more advanced than what you need.

Good luck!

[rdoursenaud]

My sample code had a few mistakes and syntax errors I just fixed. If you receive this by email, make sure to look at the version on GitHub.

[DanGylez]

What a master class! Thank you, bro. I already put together something up using your previous suggestions and it did (kinda) work, but I'm sure this will make things go smootier. I'll give it a try tomorrow during my daily programming session.
And I also definitely will visit your app... so, expect more questions, ha ha ha.