Does there exist a Python IDE that allows one to emulate C#-like intellisense for autocompleting method calls on an object?
<p>For example, suppose I have the code:</p>

<pre><code>class Foo(object):
  def bar(self, x):
    '''blah blah blah'''
    return x+1
</code></pre>

<p>And suppose I am creating another class, that has a method that takes an instance of a Foo object and does something:</p>

<pre><code>class Baz(object):
  def goo(self, foo):
    foo.bar(1) ### I am a 'Foo' object. Auto-complete me, please
</code></pre>

<p>I would desperately LOVE if after typing <code>foo.</code> while creating the goo() method in the Baz class, the IDE would provide me with intellisense. You know, show the available methods of the Foo class, their params, their doc, etc. </p>

<p>In C# I would have to declare that param 'foo' is type 'Foo', so the autocompletion is trivial.</p>

<p>I realize that Python is dynamically typed, so there is no way for any IDE to know that the 'foo' parameter is of type Foo. But is there some other info, directive, or convention that some IDE can use to determine the type ... strictly for the sake of intellisense and auto-completion?</p>

<p>One workaround I've found is to type <code>Foo.</code> which will cause most IDE's to show intellisense for the methods in Foo. This is useful, but it's not exactly what I'm looking for.</p>

<p>Another workaround is to type <code>foo = Foo()</code>, and then go about using foo as you normally would. Some IDE's sniff that foo is type Foo and provide intellisense. But then you must remember to delete the line <code>foo = Foo()</code>, else you've got a nasty bug.</p>

<p>Perhaps, there is a much better way to accomplish what I'm trying to do. I'm using C# intellisense as a point of reference, and maybe that's a Visual Studio thing, whereas when coding Python I should open my mind for a different way of accomplishing a similiar thing. Any suggestions would be much appreciated. I'm sure I can't be the only one craving intellisense for Python objects.</p>
