views:

31

answers:

1

I have Python classes with object attributes which are only declared as part of running the constructor, like so:

class Foo(object):
    def __init__(self, base):
        self.basepath = base

        temp = []
        for run in os.listdir(self.basepath):
            if self.foo(run):
                temp.append(run)
        self.availableruns = tuple(sorted(temp))

If I now use either help(Foo) or attempt to document Foo in Sphinx, the self.basepath and self.availableruns attributes are not shown. That's a problem for users of our API.

I've tried searching for a standard way to ensure that these "dynamically declared" attributes can be found (and preferably docstring'd) by the parser, but no luck so far. Any suggestions? Thanks.

+1  A: 

I've tried searching for a standard way to ensure that these "dynamically declared" attributes can be found (and preferably docstring'd) by the parser, but no luck so far. Any suggestions?

They cannot ever be "detected" by any parser.

Python has setattr. The complete set of attributes is never "detectable", in any sense of the word.

You absolutely must describe them in the docstring.

[Unless you want to do a bunch of meta-programming to generate docstrings from stuff you gathered from inspect or something. Even then, your "solution" would be incomplete as soon as you starting using setattr.]

class Foo(object):
    """
    :ivar basepath:
    :ivar availableruns:
    """
    def __init__(self, base):
S.Lott
Thanks. Yes, I appreciate that the attributes aren't computable in general, just wasn't sure if there was a heuristic for getting some of those declared in a simple/standard way by e.g. source scanning rather than class object inspection. Or by modifying the code to declare these attrs as properties so that Sphinx/help would "find" them.But anyway, that pointer to the Sphinx syntax for declaring their existence for doc purposes will do fine: cheers!
andybuckley
"Or by modifying the code to declare these attrs as properties"? "declare" is not a Python concept. Using properties method functions for your attributes will work if you are going to have the members automatically documented. That seems like **more** work than simply documenting them in the docstring.
S.Lott
But would mean that they get documented on an equal footing with other methods, which I think significantly improves the quality of documentation. I'm prepared to put in a little more work for that, if it doesn't either hit performance or make the code impenetrable. That was the point of the initial question: I'm sure I can find a way to do it, but I was wondering if there is a (de facto) standard approach which minimises the downsides.
andybuckley
"if there is a (de facto) standard approach". Yes. `:ivar name:` is the standard approach. Creating a bunch of properties won't "significantly improves the quality of documentation" at all. It will not improve it over `:ivar name:` in any way. And you'll do a ton of work for no better documentation.
S.Lott