overriding methods - two questions

[Donn Ingle]

Hi,
Here's a framework for the questions:

--- In a module, part of an API ---
class Basis ( object ):
def foo ( self, arg ):
pass

--- In user's own code ---
class Child ( Basis ):
def foo ( self, not, sure ):
...
Question 1:

Given that the user of the API can choose to override foo() or not, how can
I control the signature that they use? In the example the user has chosen
bad arguments and Python will complain, but it's describing the sig of the
*overridden* method and not the one in the parent class.

Is there some way I can control the error message to make it clear to the
user that they are using the signature of foo() incorrectly?

Question 2:

Say I am in class Basis, doing a loop and I have a list of Child objects. I
want to run the foo() method for each one that *has* a foo() method. i.e.
user has done this:

class Sam ( Child ):
...
*Sam does not define foo()

class Judy ( Child ):
def foo ( self, arg ):
...
* Judy does define foo()

Instances of Sam and Judy have been put into the list (within the instance)
of Basis. I want Basis to detect that Judy has foo() and run it.

I can handle question 2 by using a flag that must be set by the user.
Something like:
class Judy ( child ):
def __init__( self ):
self.pleaseCall Foo = true

And now, Basis can check for that var and only then call foo(), but this is
ugly and means more for the user to learn API-wise.

Any ideas?
/d

[Paul McGuire]

On Nov 16, 11:03 am, Donn Ingle <donn.in...@gma il.comwrote:

Hi,
Here's a framework for the questions:

--- In a module, part of an API ---
class Basis ( object ):
def foo ( self, arg ):
pass

--- In user's own code ---
class Child ( Basis ):
def foo ( self, not, sure ):
...

Question 1:

Given that the user of the API can choose to override foo() or not, how can
I control the signature that they use? In the example the user has chosen
bad arguments and Python will complain, but it's describing the sig of the
*overridden* method and not the one in the parent class.

Actually, Python is complaining about your user's poor choice of
argument names. 'not' is a reserved keyword. Change it to 'naught' or
'knot' or 'not_' and Python will accept this just fine.

Whether this is a good idea or not is a separate question. But given
Python's philosophy of "you are the human, so you must know what you
are doing" (which is both an assumption and a directive), I don't
think you will find much language machinery to prevent it.

-- Paul
-- Paul

[bearophileHUGS]

Donn Ingle:

Say I am in class Basis, doing a loop and I have a list of Child objects. I
want to run the foo() method for each one that *has* a foo() method.

This may help (on an old Python version):

>>class Sam: pass

....

>>class Judy:

.... def foo(self): pass
....

>>children = [Sam(), Judy(), Sam()]
for child in children: hasattr(child, "foo")

....
False
True
False

Bye,
bearophile

[Donn Ingle]

Actually, Python is complaining about your user's poor choice of

argument names. 'not' is a reserved keyword.

My example was poor, but my actual test code did't use 'not'. Python simply
checks the use of foo() to the local sig of foo() and does not go up the
chain. This is understandable and your next answer is more-or-less what I
was expecting.

Python's philosophy of "you are the human, so you must know what you
are doing" (which is both an assumption and a directive), I don't
think you will find much language machinery to prevent it.

Yeah. I guess I was hoping there'd be some clever trick to do it.

/d

[Bruno Desthuilliers]

Donn Ingle a écrit :

Hi,
Here's a framework for the questions:

--- In a module, part of an API ---
class Basis ( object ):
def foo ( self, arg ):
pass

--- In user's own code ---
class Child ( Basis ):
def foo ( self, not, sure ):
...
Question 1:

Given that the user of the API can choose to override foo() or not, how can
I control the signature that they use?

While technically possible (using inspect.getargs pec), trying to make
your code idiot-proof is a lost fight and a pure waste of time.

Question 2:

Say I am in class Basis, doing a loop and I have a list of Child objects. I
want to run the foo() method for each one that *has* a foo() method. i.e.
user has done this:

class Sam ( Child ):
...
*Sam does not define foo()

class Judy ( Child ):
def foo ( self, arg ):
...
* Judy does define foo()

Instances of Sam and Judy have been put into the list (within the instance)
of Basis. I want Basis to detect that Judy has foo() and run it.

I can handle question 2 by using a flag that must be set by the user.
Something like:
class Judy ( child ):
def __init__( self ):
self.pleaseCall Foo = true

And now, Basis can check for that var and only then call foo(), but this is
ugly and means more for the user to learn API-wise.

Indeed.

Any ideas?

Quite a few, but I don't have enough context to tell which one would be
the best - nor why you want to do such a thing. Anyway, the simplest is
to just check :

for child in self.childrens:
if 'foo' in child.__class__ .__dict__:
child.foo()

but this won't call foo for :

class Dude(Judy):
pass

Don't know if that's what you want. If not (ie, you want to call
child.foo if foo is not Basis.foo), then:

for child in self.childrens:
if child.foo.im_fu nc is not self.foo.im_fun c:
child.foo()

HTH

[Donn Ingle]

>This may help (on an old Python version):

>>>class Sam: pass
class Judy:

... def foo(self): pass
...

>>>children = [Sam(), Judy(), Sam()]
for child in children: hasattr(child, "foo")

...
False
True
False

That's not what my tests are showing. While Sam has no foo, it's coming from
(in my OP) Child (which is the parent class), so hasattr(Sam()," foo") is
returning True.

/d

[Donn Ingle]

for child in self.childrens:

if 'foo' in child.__class__ .__dict__:
child.foo()

Bruno, you're the man! I really must take the time to look into all those
under-under score things!

Thanks.

/d

[Bruno Desthuilliers]

Donn Ingle a écrit :

>for child in self.childrens:
if 'foo' in child.__class__ .__dict__:
child.foo()

Bruno, you're the man! I really must take the time to look into all those
under-under score things!

Knowing Python's object model can help, indeed !-)

Now while this kind of stuff is ok in the low-level parts of a
framework, it shouldn't be seen too much in application code IMHO.

[davisn90210]

On Nov 16, 11:35 am, Donn Ingle <donn.in...@gma il.comwrote:

This may help (on an old Python version):

>>class Sam: pass
class Judy:

... def foo(self): pass
...

>>children = [Sam(), Judy(), Sam()]
for child in children: hasattr(child, "foo")

...
False
True
False

That's not what my tests are showing. While Sam has no foo, it's coming from
(in my OP) Child (which is the parent class), so hasattr(Sam()," foo") is
returning True.

/d

But also in your OP: "I want to run the foo() method for each one that
*has* a foo() method ...." So hasattr(child, "foo") really does
answer the question as posed, even if it's not really what you want.
I am curious as to why you want to go through such contortions. What
do you gain. What happens, for example, if a subclass of Judy is
passed in that does not override foo? Should foo be called in that
case or not?

--Nathan Davis

[Steven D'Aprano]

On Fri, 16 Nov 2007 18:28:59 +0100, Bruno Desthuilliers wrote:

>Question 1:

Given that the user of the API can choose to override foo() or not, how
can I control the signature that they use?

While technically possible (using inspect.getargs pec), trying to make
your code idiot-proof is a lost fight and a pure waste of time.

Worse: it's actually counter-productive!

The whole idea of being able to subclass a class means that the user
should be able to override foo() *including* the signature. Why do you
want to stop them? It's their subclass, not yours. You don't know what
arguments it needs.

Let me give a practical example: in mathematics there is a construct
known as a continued fraction. What it is isn't especially important, if
you're curious you can google for it. If you were defining a class for
continued fractions, you might do this:

class ContinuedFracti on(object):
def __init__(self, list_of_numerat ors, list_of_denomin ators):
pass
# lots of other methods

cf = ContinuedFracti on([3, 7, 2, 8, 9, 5], [2, 3, 1, 5, 3, 7])

If I wanted to subclass your ContinuedFracti on class to provide regular
continued fractions, I could do this:

class RegularCF(Conti nuedFraction):
def __init__(self, *denominators):
numerators = [1]*len(denominato rs)
super(RegularCF , self).__init__( numerators, denominators)
# all other methods are inherited from super-class without change

cf = RegularCF(4, 9, 1, 2, 6, 3)
But if you did what you're proposing to do, I couldn't do that. I'd need
to do something silly like this:

class RegularCF(Conti nuedFraction):
def __init__(self, list_of_numerat ors, list_of_denomin ators):
numerators = [1]*len(list_of_de nominators)
super(RegularCF , self).__init__( numerators, list_of_denomin ators)

cf = RegularCF(None, [4, 9, 1, 2, 6, 3])
just so that the signatures matched. What a waste of time.

And worse, what if my subclass needed *more* arguments than your
signature provided? The hoops I would have to jump through would not only
be flaming, they'd be spinning and flying through the air, with rotating
knives and trip-wires.

--
Steven