I was reading some module documentation and saw something I didn't understand, in the explanation of parameters for a method:
callback - callback function which will be called with argument
list equal to callbackargs+(result,)
as soon as calculation is done
callbackargs - additional arguments for callback function
group - job group, is used when wait(group) is called to wait for
jobs in a given group to finish
How can I call the method and correctly supply arguments for these parameters? What are they used for, and how does this "callback" scheme work?
A callback is a function provided by the consumer of an API that the API can then turn around and invoke (calling you back). If I setup a Dr.'s appointment, I can give them my phone number, so they can call me the day before to confirm the appointment. A callback is like that, except instead of just being a phone number, it can be arbitrary instructions like "send me an email at this address, and also call my secretary and have her put it in my calendar.
Callbacks are often used in situations where an action is asynchronous. If you need to call a function, and immediately continue working, you can't sit there wait for its return value to let you know what happened, so you provide a callback. When the function is done completely its asynchronous work it will then invoke your callback with some predetermined arguments (usually some you supply, and some about the status and result of the asynchronous action you requested).
If the Dr. is out of the office, or they are still working on the schedule, rather than having me wait on hold until he gets back, which could be several hours, we hang up, and once the appointment has been scheduled, they call me.
In this specific case, the documented method will compute the result, put it together with any callbackargs specified, and call callback, passing it those values as the arguments.
If you want some code to be executed as soon as the result is ready, put that code into a function and pass it as the callback argument. For example, supposing no other arguments are needed for that function:
def itsdone(result):
print(f"Done! result={result}")
...
submit(..., callback=itsdone)
For more on how this works in Python, see e.g. my presentation on the topic.
Looking at the link, just looks like a hook which is called.
callback - callback function which
will be called with argument
list equal to callbackargs+(result,)
as soon as calculation is done
The "as soon as calculation is done" bit seems ambiguous. The point, as far as I can see of this thing is that the submit() call distributes work to other servers and then returns. Because the finishing is asynchronous, rather block, it allows you to provide a function which is called when some unit of work finishes. If you do:
submit( ..., callback=work_finished, ... )
Then submit will ensure work_finished() is called when the unit of distributed work is completed on the target server.
When you call submit() you can provide a callback which is called in the same runtime as the caller of submit() ... and it is called after the distribution of the workload function is complete.
Kind of like "call foo(x,y) when you have done some stuff in submit()"
But yea, the documentation could be better. Have a ganders at the ppython source and see at which point the callback is called in submit()
A callback is a function you define that's later called by a function you call.
As an example, consider how AJAX works: you write code that calls a back-end server function. At some point in the future, it returns from that function (the "A" stands for Asynchronous, which is what the "Parallel" in "Parallel Python" is all about). Now - because your code calls the code on the server, you want it to tell you when it's done, and you want to do something with its results. It does so by calling your callback function.
When the called function completes, the standard way for it to tell you it's done is for you to tell it to call a function in your code. That's the callback function, and its job is to handle the results/output from the lower-level function you've called.
A callback is simply a function. In Python, functions are just more objects, and so the name of a function can be used as a variable, like so:
def func():
...
something(func)
Note that many functions which accept a callback as an argument usually require that the callback accept certain arguments. In this case, the callback function will need to accept a list of arguments specified in callbackargs.
Related
On a bokeh server, I use doc.add_periodic_callback(callback_fn, 1000). This returns the periodic callback ID and nothing else. Is it possible to access the value returned by callback_fn too?
It is not possible to access any return value. This is common for callback-based APIs, since: who/what would receive a return value? The callback is invoked by the system as an automatic process in the background.
If I schedule a callback using loop.call_later() (or with loop.call_at(), which behaves the same way), is it possible to cancel its execution?
Why? Let's say I schedule something to run one minute from now. However, due to some condition, the code decides to abort that execution (because it's not needed anymore), or alternatively decides to reschedule it for another time. The question is how to implement it using Python's asyncio?
If you are familiar with JavaScript, I'm looking for equivalents of setTimeout() and clearTimeout().
From the docs you linked:
An instance of asyncio.TimerHandle is returned which can be used to cancel the callback.
And from the docs of asyncio.Handle, a superclass of asyncio.TimerHandle:
cancel()
Cancel the callback. If the callback has already been canceled or executed, this method has no effect.
So just call the handle's cancel method.
I have a very basic Tkinter application that I'm trying to set to automatically refresh. I am using threading.Timer to trigger a function called go at the end of which cocalls the timer to reset it to run again.
def SetTimer():
t=threading.Timer(5,go())
t.start
SetTimer()
I've spent most of my afternoon trying to resolve this but I can't seem to figure out what I'm doing wrong. Based upon the other questions I've read I understand that each instance creates a separate thread with the timer, but why isn't it waiting for the time to elapse prior to triggering the function.
Use:
t=threading.Timer(5,go)
Note the go rather than go(). The parentheses tell Python to call the function. In contrast, go is a function object. Functions are "first-class" objects in Python; they can be passed to functions just like any other object.
Python evaluates the arguments to a function before calling the function. So using go() calls the go before calling threading.Timer. The value returned by go() gets sent to Timer, which is not what you want.
Note that all Tkinter UI code should be called from a single thread. For this reason, using Tkinter's root.after method is probably a better choice for what you want to do. The after method schedules a function to be called by Tkinter's mainloop. Here are some examples using after:
Tkinter and Threads
A rotating image
I am trying to implement a program that will be able to execute 2 functions asynchronously, e.g. let each function be triggered regardless of whether the other one is running and how long its been running for.
I know python supports threading, but all examples I have seen call functions in the script, so there is a predetermined order and time separation between the functions.
My question is how to get passed that and trigger the functions myself whenever I am ready.
I write a python class which makes asynchronous method calls using D-Bus. When my reply_handler is called, it stores data in list. This list can be used by another class methods at the same time. Is it safe or I can use only synchronized data structures like Queue class?
If you do not modify the list outside of the callback context, then you do not necessarily need synchronization - you will just need to be aware that the list object's state is volatile.
If the list must be modified both in the callback handler as well as, say, the main execution context (or other threads, etc.), then yes you will need synchronization.
The Python synchronized Queue works naturally for message pumps - allowing you to perform actions sequentially in the order that the events come in one of your own contexts. This benefits code simplicity and readability as well since major state changes are easier to track. Callbacks generally shouldn't be too complicated anyway as the outside context in which the callbacks are called shouldn't (and probably doesn't) have to deal with exceptions raised from your code. There are also potential timing considerations as well - the callback will block the async emitter's context - so keeping the handler short and sweet is also good.