Function caller (to multiple receivers) interface
If I understand correctly,
the purpose of Caller seems to be to call a function on multiple objects.
It works like this:


Construct a Caller x by passing 1 or more objects in the constructor
Call any method m on x, and it will be dispatched to method m of all objects


Right? The docstring doesn't explain this very well.
CallDispatcher might be a better name.

My impression is that you're discovering powerful features of Python,
and you're trying to use them because you can,
not because you have a concrete purpose.
Sort of like an exercise, not for real-life use.

It seems to me that __getattr__ is seriously abused.
I don't have experience overriding this method,
but I would guess it's designed to implement getters dynamically.
First of all,
adding getters dynamically seems like a hack that should be used with extreme care,
including a good justification that it's the best option.
Secondly,
instead of behaving as a getter,
this implementation mutates the object and returns self.
I see you did that to make chaining and currying possible,
it's interesting, but it seems a misuse of the language.

Another thing I don't like about the approach is the heavy dependence on duck typing.
The objects that can be used with Caller don't have to follow a well-defined interface,
they can be anything.
The user just has to make sure that when they call a .hello function on a Caller object,
all the objects inside have a .hello function defined.
It's great that Python let's us do this kind of thing,
but it doesn't mean that we should.
I prefer to have well-defined and well-documented interfaces,
with a list of legitimate methods that I'm allowed to call.

Python conventions

Instead of:


class Caller():



The class should be declared as:

class Caller:


Instead of:


    if len(self._names) == 0:



The Pythonic way:

    if not self._names:


Instead of:


        print ("Receiver3 - b", arg)



There should be no space before the opening paren:

        print("Receiver3 - b", arg)