Displaying user-defined functions and their docstrings

Question

Let's say I want to create dynamic documentation of functions I wrote, without using the help() function (I don't want the user to care about arguments accepted by my function, nor get cluttered with other stuff like the copyright info, or other stuff that aren't functions).

Here's an attempt:

import inspect

def foo():
    """Return 'foo' string"""
    return "foo"

def user_defined_functions():
    """Return names of user-defined functions"""
    for name in globals():
        if inspect.isfunction(eval(name)):
            docstring = eval(name + ".__doc__")
            print("{}:\n   {}".format(name, docstring))

And here's the pretty result:

>>> import test
>>> test.user_defined_functions()
user_defined_functions:
   Return names of user-defined functions
foo:
   Return 'foo' string

If I had just used the help function I could have gotten extra stuff I don't need (I'm not writing a library, so the user doesn't need all of this):

Help on module test:

NAME
    test

FUNCTIONS
    foo()
        Return 'foo' string

    user_defined_functions()
        Return names of user-defined functions

FILE
    /home/wena/src/utils/test.py

Answer 1

Use for name, value in globals().items(): then you don't need to use eval

Answer 2

Peeking inside the source code you linked I'd say that what you need is some sort of command table: a dictiony with all the commands and their aliases should do.

To suggest that, other then the fact that you'll need it for what you asked, is that it's almost already written. It's in that ugly if/elif into the help function, but it's almost already there :)

At the beginning of the file:

COMMANDS_TABLE = {"autoalts": ["autoalternatives"],
                  "builddeps": ["builddepend", "builddepends", "builddeps"], 
                  #....

With this table your help function will more or less look like:

def help(args):
    # ...
    for command in in args[1:]:
         for func_name,aliases in COMMANDS_TABLE.items():
             if command in aliases:
                 command = func_name
                 break
         # ...

And your listcommands could be:

def listcommands(args):
    for func_name in sorted(COMMANDS_TABLE):
        print globals()[func_name].__doc__

But this still looks like a hack, and the reason is that a good command table should map the function themselves not their name:

COMMANDS_TABLE = {autoalts: ["autoalternatives"],
                  builddeps: ["builddepend", "builddepends", "builddeps"], 
                  #....

Everything will be a lot easier, because once you get the function, you can ask whatever you want:

def listcommands(args):
    for func in sorted(COMMANDS_TABLE, key=operator.attrgetter('__name__')):
        print func.__doc__

Now, this is a good design! You could later on transform those functions into callables and this code will still work :)

In the source code you linked, there's also a util.help() function, that might need the same kind of changes.