Re: Checking function calls
Fredrik Tolf wrote: > On Mon, 2006-03-06 at 20:25 -0800, James Stroud wrote: > >>Fredrik Tolf wrote: >> >>>If I have a variable which points to a function, can I check if certain >>>argument list matches what the function wants before or when calling it? >>> >>>Currently, I'm trying to catch a TypeError when calling the function >>>(since that is what is raised when trying to call it with an illegal >>>list), but that has the rather undesirable side effect of also catching >>>any TypeErrors raised inside the function. Is there a way to avoid that? >>> >>>Fredrik Tolf >>> >>> >> >>Since python is "weakly typed", you will not be able to check what >>"type" of arguments a function expects. [...] > > > Sorry, it seems I made myself misunderstood. I don't intend to check the > type of the values that I pass to a function (I'm well aware that Python > is dynamically typed). The reason I refer to TypeError is because that > seems to be the exception raised by Python when I attempt to call a > function with an argument list that wouldn't be valid for it (for > example due to the number of parameters being wrong). I just want to > check in advance whether a certain arglist would be valid to call a > certain function. > > >>So, if you want to know the number of >>arguments expected, I've found this works: >> >>py> def func(a,b,c): >>... print a,b,c >>... >>py> func.func_code.co_argcount >>3 > > > Not very well, though: > def a(b, c, *d): pass > > ... > print a.func_code.co_argcount > > 2 > > Here, that would indicate that I could only call `a' with two arguments, > while in fact I could call it with two or more arguments. > What is your goal? To avoid TypeError? In that case the minimum for no error is 2, as *d could be empty. It would then be safe to check against co_argcount to avoid errors: py> def a(a,b,*c): ... print a,b ... py> a(*range(a.func_code.co_argcount)) 0 1 py> a(*range(a.func_code.co_argcount + 5)) 0 1 py> a(*range(a.func_code.co_argcount - 1)) Traceback (most recent call last): File "", line 1, in ? TypeError: a() takes at least 2 arguments (1 given) If the function requires 3 arguments to work, you may want to change the definition to reflect that fact as the *args are implicitly optional. This will help with using co_argcount as a test. James -- James Stroud UCLA-DOE Institute for Genomics and Proteomics Box 951570 Los Angeles, CA 90095 http://www.jamesstroud.com/ -- http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
Fredrik Tolf wrote:
> On Mon, 2006-03-06 at 20:25 -0800, James Stroud wrote:
>
>>Fredrik Tolf wrote:
>>
>>>If I have a variable which points to a function, can I check if certain
>>>argument list matches what the function wants before or when calling it?
>>>
>>>Currently, I'm trying to catch a TypeError when calling the function
>>>(since that is what is raised when trying to call it with an illegal
>>>list), but that has the rather undesirable side effect of also catching
>>>any TypeErrors raised inside the function. Is there a way to avoid that?
>>>
>>>Fredrik Tolf
>>>
>>>
>>
>>Since python is "weakly typed", you will not be able to check what
>>"type" of arguments a function expects. [...]
>
>
> Sorry, it seems I made myself misunderstood. I don't intend to check the
> type of the values that I pass to a function (I'm well aware that Python
> is dynamically typed). The reason I refer to TypeError is because that
> seems to be the exception raised by Python when I attempt to call a
> function with an argument list that wouldn't be valid for it (for
> example due to the number of parameters being wrong). I just want to
> check in advance whether a certain arglist would be valid to call a
> certain function.
>
>
>>So, if you want to know the number of
>>arguments expected, I've found this works:
>>
>>py> def func(a,b,c):
>>... print a,b,c
>>...
>>py> func.func_code.co_argcount
>>3
>
>
> Not very well, though:
>
def a(b, c, *d): pass
>
> ...
>
print a.func_code.co_argcount
>
> 2
>
> Here, that would indicate that I could only call `a' with two arguments,
> while in fact I could call it with two or more arguments.
>
> More exactly, what I'm trying to do is this; I writing a small protocol
> server class as part of a program, and I thought it would be convenient
> to be able to define new commands in the protocol by just adding a
> function for them, like this:
>
> class client:
> # ...
> # Read is called from the event driver when data is available on the
> # socket.
> def read(self):
> self.buf += self.sk.recv(65536)
> for c in self.buf.split("\n")[:-1]:
> cv = tokenize(c)
> if len(cv) > 0:
> f = getattr(self, "cmd_" + cv[0], None)
> if callable(f):
> f(*cv[1:])
> else:
> self.reply("err", "unk")
> # Example:
> def cmd_echo(self, arg1):
> self.reply("ok", arg1)
>
> So basically, I want to be able to handle to client giving the wrong
> number of arguments and reply with an error rather than the server
> process crashing and dying. Therefore, I'm currently catching TypeErrors
> when calling the function:
>
> # ...
> if callable(f):
> try:
> f(*cv[1:])
> except TypeError:
> self.reply("err", "argno")
> # ...
It might be more reasonable to program your cmd_* functions to be more
flexible themselves. This would be more pythonic. E.g.
def cmd_echo(self, *args):
if not len(args):
answer = 'OMITTED' # or raise your own exception
else:
answer = args[0]
self.reply("ok", answer)
Now, you never have to worry about length of the argument list.
You could, of course factor this behavior. Here's how I might do it:
# first make a custom exception class, called whatever you want
class ServerError(exception): pass
#... somewhere in your client class
def preprocess_args(self, args, numexpected):
"""
This is the more flexible way.
A less flexible way would to check for the exact number of
arguments. But that goes against the "lenient in what you accept"
maxim.
"""
if len(args) < numexpected:
raise ServerError, 'Too few args!'
else:
return args[:numexpected]
def cmd_echo(self, *args):
(answer,) = preprocess_args(args, 1) # preprocess returns tuple
self.reply("ok", answer)
#... elsewhere in your client class
if callable(f):
try:
f(*cv[1:])
except ServerError, e:
self.reply("err", "argno") # can also make use of exception e
You could factor even further with a dictionary:
minargs = {'echo' : 1, 'etc' : 5000}
#... somewhere in your client class
def preprocess_args(self, cv):
"""
This is the more flexible way.
A less flexible way would to check for the exact number of
arguments. But that goes against the "lenient in what you accept"
maxim.
"""
args = cv[1:]
expected = minargs[cv[0]]
if len(args) < expected:
raise ServerError, 'Too few args!'
else:
return args[:expected]
# ...
def cmd_echo(self, answer):
self.reply("ok", answer)
# ... elsewhere
if callable(f):
try:
args = preprocess_args(cv)
except ServerError, e:
self.reply("err", "argno") # can also make use of exception e
f(*args)
Now you shouldn't have to rewrite any cmd_* functions.
James
--
James Str
Re: Checking function calls
Fredrik Tolf wrote:
> # ...
> if callable(f):
> try:
> f(*cv[1:])
> except TypeError:
> self.reply("err", "argno")
> # ...
>
> However, this results in bugs in the server code that would cause
> TypeError to reply to the client that it had the wrong number of args,
> and I can't see what the real cause is without turning off that check
> while debugging. Therefore, I'd like to check in advance whether cv[1:]
> would raise a TypeError upon calling f with it or not. And of course,
> I'd like to be able to use cmd_* functions with variable arglists as
> well.
If you must, just check the error message, not just the type of exception.
I'd just drop the cryptical error codes like 'argno' and 'unk' and pass on
the actual error message:
try:
f(*cv[1:])
except:
tp, exc, traceback = sys.exc_info()
self.reply("err", str(exc))
Note that the check whether f is callable is also gone.
Peter
--
http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
On Mon, 2006-03-06 at 20:25 -0800, James Stroud wrote:
> Fredrik Tolf wrote:
> > If I have a variable which points to a function, can I check if certain
> > argument list matches what the function wants before or when calling it?
> >
> > Currently, I'm trying to catch a TypeError when calling the function
> > (since that is what is raised when trying to call it with an illegal
> > list), but that has the rather undesirable side effect of also catching
> > any TypeErrors raised inside the function. Is there a way to avoid that?
> >
> > Fredrik Tolf
> >
> >
>
> Since python is "weakly typed", you will not be able to check what
> "type" of arguments a function expects. [...]
Sorry, it seems I made myself misunderstood. I don't intend to check the
type of the values that I pass to a function (I'm well aware that Python
is dynamically typed). The reason I refer to TypeError is because that
seems to be the exception raised by Python when I attempt to call a
function with an argument list that wouldn't be valid for it (for
example due to the number of parameters being wrong). I just want to
check in advance whether a certain arglist would be valid to call a
certain function.
> So, if you want to know the number of
> arguments expected, I've found this works:
>
> py> def func(a,b,c):
> ... print a,b,c
> ...
> py> func.func_code.co_argcount
> 3
Not very well, though:
>>> def a(b, c, *d): pass
...
>>> print a.func_code.co_argcount
2
Here, that would indicate that I could only call `a' with two arguments,
while in fact I could call it with two or more arguments.
More exactly, what I'm trying to do is this; I writing a small protocol
server class as part of a program, and I thought it would be convenient
to be able to define new commands in the protocol by just adding a
function for them, like this:
class client:
# ...
# Read is called from the event driver when data is available on the
# socket.
def read(self):
self.buf += self.sk.recv(65536)
for c in self.buf.split("\n")[:-1]:
cv = tokenize(c)
if len(cv) > 0:
f = getattr(self, "cmd_" + cv[0], None)
if callable(f):
f(*cv[1:])
else:
self.reply("err", "unk")
# Example:
def cmd_echo(self, arg1):
self.reply("ok", arg1)
So basically, I want to be able to handle to client giving the wrong
number of arguments and reply with an error rather than the server
process crashing and dying. Therefore, I'm currently catching TypeErrors
when calling the function:
# ...
if callable(f):
try:
f(*cv[1:])
except TypeError:
self.reply("err", "argno")
# ...
However, this results in bugs in the server code that would cause
TypeError to reply to the client that it had the wrong number of args,
and I can't see what the real cause is without turning off that check
while debugging. Therefore, I'd like to check in advance whether cv[1:]
would raise a TypeError upon calling f with it or not. And of course,
I'd like to be able to use cmd_* functions with variable arglists as
well.
Surely, there ought to be some way in python to see whether a certain
argument list would be valid for a function call, without checking magic
values of f.func_code?
Fredrik Tolf
--
http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
If you have access to the source of the function you want to call (and know
what kind of data types it wants in its args) you can raise something else for
bad parameters, eg:
class ArgTypeError(TypeError):
def __init__(self, arg):
self.arg = arg
def __str__(self):
return "bad type for argument %r" % self.arg
def moo(cow):
if not isinstance(cow, str):
raise ArgTypeError('cow')
print "%s says moo!" % cow
# this error is not caused by wrong arg type:
var = 1 + 's'
function = moo
for arg in [1, 'rose']:
try:
function(arg)
except ArgTypeError, e:
print e
Output:
bad type for argument 'cow'
rose says moo!
Traceback (most recent call last):
File "/merlot1/yohell/eraseme/test.py", line 23, in -toplevel-
make_noise('rose')
File "/merlot1/yohell/eraseme/test.py", line 13, in moo
raise TypeError
TypeError
Hope it helps
/Joel Hedlund
--
http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
Roy Smith wrote: > Fredrik Tolf wrote: > >If I have a variable which points to a function, can I check if certain > >argument list matches what the function wants before or when calling it? > > > >Currently, I'm trying to catch a TypeError when calling the function > >(since that is what is raised when trying to call it with an illegal > >list), but that has the rather undesirable side effect of also catching > >any TypeErrors raised inside the function. Is there a way to avoid that? > > The only way is to read the documentation for the function (or, the > source code). > > Can you be a little more specific about what you're trying to do? Can > you post your code? if you know ahead of runtime which methods are at issue and what method signatures you want, multimethod decorators, maybe? http://www.artima.com/weblogs/viewpost.jsp?thread=101605 (read comments: PJE, ian bicking or you can arg-test inside the method, which isn't much fun http://www.python.org/doc/faq/programming.html#how-can-i-overload-constructors-or-methods-in-python -- http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
Fredrik Tolf wrote: >If I have a variable which points to a function, can I check if certain >argument list matches what the function wants before or when calling it? > >Currently, I'm trying to catch a TypeError when calling the function >(since that is what is raised when trying to call it with an illegal >list), but that has the rather undesirable side effect of also catching >any TypeErrors raised inside the function. Is there a way to avoid that? The only way is to read the documentation for the function (or, the source code). Can you be a little more specific about what you're trying to do? Can you post your code? -- http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
James Stroud wrote:
(snip)
> Since python is "weakly typed",
s/weakly/dynamically/
(snip)
--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in '[EMAIL PROTECTED]'.split('@')])"
--
http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
Jay Parlar wrote: > > On Mar 6, 2006, at 8:44 PM, James Stroud wrote: > >> Since python is "weakly typed", you will not be able to check what >> "type" of arguments a function expects. TypeErrors relating to the >> type of argemtns you pass will be raised inside the function only and >> not when it is called. I.e. there is no type checking when a function >> is called, only in its body. >> > > I don't mean to take a tangent from the original purpose of the thread, > but it is generally accepted that Python is STRONGLY, dynamically typed. > An example of weak dynamic typing would be Perl. I think I meant "STRONGLY, dynamically typed". I've always been a little CS lingo challenged. > A lot of it of course comes down to one's definitions of strong/weak, > but general consensus (at least around c.l.p.) is that Python is a > strongly typed language. > > Jay P. > -- James Stroud UCLA-DOE Institute for Genomics and Proteomics Box 951570 Los Angeles, CA 90095 http://www.jamesstroud.com/ -- http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
On Mar 6, 2006, at 8:44 PM, James Stroud wrote: > Since python is "weakly typed", you will not be able to check what > "type" of arguments a function expects. TypeErrors relating to the > type of argemtns you pass will be raised inside the function only and > not when it is called. I.e. there is no type checking when a function > is called, only in its body. > I don't mean to take a tangent from the original purpose of the thread, but it is generally accepted that Python is STRONGLY, dynamically typed. An example of weak dynamic typing would be Perl. A lot of it of course comes down to one's definitions of strong/weak, but general consensus (at least around c.l.p.) is that Python is a strongly typed language. Jay P. -- http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
Fredrik Tolf wrote:
> If I have a variable which points to a function, can I check if certain
> argument list matches what the function wants before or when calling it?
>
> Currently, I'm trying to catch a TypeError when calling the function
> (since that is what is raised when trying to call it with an illegal
> list), but that has the rather undesirable side effect of also catching
> any TypeErrors raised inside the function. Is there a way to avoid that?
>
> Fredrik Tolf
>
>
Since python is "weakly typed", you will not be able to check what
"type" of arguments a function expects. TypeErrors relating to the type
of argemtns you pass will be raised inside the function only and not
when it is called. I.e. there is no type checking when a function is
called, only in its body.
Types erros can be raised when calling a function like this:
func(*avar)
or
func(**avar)
In the former case, if avar is not a sequence, you will get a TypeError.
In the latter case, if avar is not a dictionary, you will get a TypeError.
In this latter case, if your dictionary has keys that are not in the
parameter list, you will get a TypeError.
This would be similar to explicitly specifying a keyword argument that
is not in the parameter list (e.g. func(aparam=someval)).
TypeError will be raised also if you give an improper number of
arguments to the function. So, if you want to know the number of
arguments expected, I've found this works:
py> def func(a,b,c):
... print a,b,c
...
py> func.func_code.co_argcount
3
To check the parameter names, use
py> func.func_code.co_names
('a', 'b', 'c')
James
--
James Stroud
UCLA-DOE Institute for Genomics and Proteomics
Box 951570
Los Angeles, CA 90095
http://www.jamesstroud.com/
--
http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
I will be out of the office from March 3rd to March 31st. In urgent cases please contact [EMAIL PROTECTED] -- http://mail.python.org/mailman/listinfo/python-list
Re: Checking function calls
You can match if the list contains the legal number of arguments with. func_variable.func_code.co_argcount Type checking arguments has to be done manually since Python is a dynamic language. Perhaps, you could try some typechecking decorators. http://www.ilowe.net/software/typecheck/ >From the docs, this one raises TypeCheckError (not TypeError), so you should do fine. -- http://mail.python.org/mailman/listinfo/python-list
Checking function calls
If I have a variable which points to a function, can I check if certain argument list matches what the function wants before or when calling it? Currently, I'm trying to catch a TypeError when calling the function (since that is what is raised when trying to call it with an illegal list), but that has the rather undesirable side effect of also catching any TypeErrors raised inside the function. Is there a way to avoid that? Fredrik Tolf -- http://mail.python.org/mailman/listinfo/python-list
